int main()
{
Breakout bricks;
bricks.draw_bricks();
bricks.draw_paddle();
bricks.draw_ball();
bricks.move_ball();
bricks.move_paddle();
bricks.brick_collision();
bricks.paddle_collision();
return 0;
}


What i want to ask is, if you call (bricks.move_ball(), bricks.move_paddle()) and then check collision and it turns "Oh they collided" next loop comes, you draw that wrong looking frame.

With that code id put it like this

Breakout bricks;
bricks.move_ball();
bricks.move_paddle();
bricks.brick_collision();
bricks.paddle_collision();
bricks.draw_bricks();
bricks.draw_paddle();
bricks.draw_ball();
return 0;


But it depends how your functions are made, in my code i make it this way

namespace en
{
enum
{
n_collision = 1,
y_collision = 2
};
};

void check_for_valid_position()
{
//Setup position for next movement for ball
int ball_new_x = ball_position_x + ball_velocity_x,
ball_new_y = ball_position_y + ball_velocity_y;

//Check if the balls new position is valid
if(check_collision(ball_new_x, ball_new_y) == en::y_collision)
// If the new position is invalid reverse ball_velocity x and y
{ /* bounce ball from the object */ }
else
// If the new position is valid, we apply it
{ ball_position_x = ball_new_x; ball_position_y = ball_new_y; }
}

The reason behind this is so i don't split ball_move() and ball_collision().
For exzample :
ball_move() moves ball for 5 pixels
ball_colision() detects that's invalid, and ball_collision now most do ball_move() job(move the ball - 5 pixels).

Just to add on to what Alvaro is bringing up: you're not actually using Object Oriented programming. You've made a class, but it's just a container for strictly procedural code. Also, as your game doesn't loop, it'll be over immediately.

A helpful heuristic for object oriented design is the "paragraph model". If you were to sit down and write out how your game works (what the code does, or what happens while playing the game) you'd find that most of the time, your objects would be the nouns in the sentences, the verbs would be your object's methods, and adjectives define additional properties of your objects. As an example:

"When the ball collides with the paddle, it bounces back in the other direction"

Already I could make an argument for a ball class, a paddle class, and two methods for ball could be Ball::Collide() and Ball::Bounce(). Though my experience tells me that you could simplify the design and make Bounce() just an internal method call inside Collide() that defines how you react to a collision.