Bonjour, je suis entrain de coder un petit projet pour m'entraîner en C++. J'ai défini deux objets (Vector et Ball) avec les constructeurs, getters et setters.

Vector.cpp

#include <iostream>
#include <math.h>

#include "Vector.hpp"

Vector::Vector()
{
    x_ = 0;
    y_ = 0;
}

Vector::Vector(double _x, double _y)
{
    x_ = _x;
    y_ = _y;
}

void Vector::setX(double _x)
{
    x_ = _x;
}

void Vector::setY(double _y)
{
    y_ = _y;
}

void Vector::setVector(Vector vect)
{
    x_ = vect.getX();
    y_ = vect.getY();
}

void Vector::setVector(double _x, double _y)
{
    x_ = _x;
    y_ = _y;
}

double Vector::norm()
{
    return sqrt(pow(x_,2) + pow(y_,2));
}

std::ostream& operator<<(std::ostream &_flow, Vector _vect)
{
    _flow << "(x = " << _vect.getX() << ", y = " << _vect.getY() << ")" << std::endl;
    return _flow;
}

Ball.cpp

#include <iostream>

#include "Vector.hpp"
#include "Ball.hpp"

Ball::Ball()
{
    mass_   = 1;
    radius_ = 1;
    color_  = 0;
    Vector position_(0,0);
    Vector velocity_(0,0);
}

Ball::Ball(double _mass, double _radius, int _color, Vector _position, Vector _velocity)
{
    mass_   = _mass;
    radius_ = _radius;
    color_  = _color;
    Vector position_(_position.getX(), _position.getY());
    Vector velocity_(_velocity.getX(), _velocity.getY());
}

Ball::Ball(double _mass, double _radius, int _color, double _p_x, double _p_y, double _v_x, double _v_y)
{
    mass_   = _mass;
    radius_ = _radius;
    color_  = _color;
    Vector position_(_p_x, _p_y);
    std::cout << position_.getX() << std::endl;
    Vector velocity_(_v_x, _v_y);
}

void Ball::setMass(double _mass)
{
    mass_ = _mass;
}

void Ball::setRadius(double _radius)
{
    radius_ = _radius;
}

void Ball::setColor(int _color)
{
    color_ = _color;
}

void Ball::setPosition(Vector _position)
{
    position_.setVector(_position);
}

void Ball::setPosition(double _p_x, double _p_y)
{
    position_.setVector(_p_x, _p_y);
}

void Ball::setVelocity(Vector _velocity)
{
    velocity_.setVector(_velocity);
}

void Ball::setVelocity(double _v_x, double _v_y)
{
    velocity_.setVector(_v_x, _v_y);
}

std::ostream& operator<<(std::ostream &_flow, Ball _ball)
{
    _flow << "Mass = "     << _ball.getMass()     << std::endl;
    _flow << "Radius = "   << _ball.getRadius()   << std::endl;
    _flow << "Color = "    << _ball.getColor()    << std::endl;
    _flow << "Position = " << _ball.getPosition();
    _flow << "Velocity = " << _ball.getVelocity();

    return _flow;
}

J'ai voulu tester toutes les méthodes, mais j'ai un problème avec le constructeurs de Ball. J'initialise une "ball1" et j'essaye de visualiser tous ses attributs :
main.cpp

#include <iostream>

#include "Vector.hpp"
#include "Ball.hpp"

int main()
{

    Ball ball1(0.99, 0.8, 4, 1.8, 1.9, 1, 2);

    std::cout << ball1 << std::endl;
}

Mais là sans que je ne comprenne pourquoi, chaque attribut est bien initialisé sauf position_ et velocity_. J'ai vérifié le constructeur de Vector fonctionne bien, et quand j'utilise ball1.setPosition( , ) cette fois les valeurs de position/velocity sont bien changées. J'en ai déduit que c'était un problème de constructeurs pour Ball.
Si quelqu'un a une idée je suis preneur
Merci

position_(0,0);
velocity_(0,0);

lmghs a écrit:

Utilise la "liste d'initialisation". C'est fait pour, et c'est le seul mécanisme qui permette cela.

OK ça a marché merci beaucoup, mais je me demandais, il n'y a vraiment pas d'autres façon de faire afin de l'initialiser dans le bloc de la fonction ?

-
Edité par Nababe 26 avril 2022 à 21:03:20

Nababe a écrit:

lmghs a écrit:

Utilise la "liste d'initialisation". C'est fait pour, et c'est le seul mécanisme qui permette cela.

OK ça a marché merci beaucoup, mais je me demandais, il n'y a vraiment pas d'autres façon de faire afin de l'initialiser dans le bloc de la fonction ?

Ball::Ball(double _mass, double _radius, int _color, Vector _position, Vector _velocity)
{
    mass_   = _mass;
    radius_ = _radius;
    color_  = _color;
    position_ = _position;
    velocity_ = _velocity;
}

Ainsi, tu mets du code dans le corps du constructeur. Mais en fait tu as initialisé 2 fois tes 5 membres! Tes membres doivent être créés et initialisés avant le corps, ensuite tu en changes la valeur. C'est quand même dommage!
En utilisant la liste d'initialisation, tu crées et initialises chacun de tes membres une seule fois.

Ball::Ball(double _mass, double _radius, int _color, Vector _position, Vector _velocity)
    : mass_{_mass}
    , radius_{_radius}
    , color_{_color}
    , position_{std::move(_position)}
    , velocity_{std::move(_velocity)}
{
}

OK je vois, donc tout sauf la "liste d'initialisation" est plus ou moins à bannir pour faire les choses correctement.

Petite questions cependant :
Dans une "liste d'initialisation" tu peux changer les () par des {} ?
Et le std::move ici apporte quoi en plus ?

Dalfab a écrit:

Mais en fait tu as initialisé 2 fois tes 5 membres

(1 initialisation et une affectation)

Nababe a écrit:

OK je vois, donc tout sauf la "liste d'initialisation" est plus ou moins à bannir pour faire les choses correctement.

Il ne faut pas oublier l'initialisation lors de la déclaration. (Meme si lmghs n'aime pas) 

struct Vector {
    double _x = 0.0;
    double _y = 0.0;
};

Nababe a écrit:

Dans une "liste d'initialisation" tu peux changer les () par des {} ?

Et le std::move ici apporte quoi en plus ?

oui.

Et move evite la copie dans ce code.

> Et move evite la copie dans ce code.

Dans ce code précis, il n'y a pas d'objets à charge déportée. Les moves finissent aussi en copies.

> à bannir pour faire les choses correctement.

Ici les setters aussi n'ont pas le moindre sens. Tes données n'ont pas d'invariants, et encore moins de services. OSEF si l'utilisateur va taper dedans.

> Il ne faut pas oublier l'initialisation lors de la déclaration. (Meme si lmghs n'aime pas)

J'ai repensé à notre discussion cet aprèm suite à l'annonce de GCC 12 par redhat. Il y a une amélioration de la détection des membres non initialisés.

lmghs a écrit:

> Et move evite la copie dans ce code.

Dans ce code précis, il n'y a pas d'objets à charge déportée. Les moves finissent aussi en copies.

Vrai.

lmghs a écrit:

> Il ne faut pas oublier l'initialisation lors de la déclaration. (Meme si lmghs n'aime pas)

J'ai repensé à notre discussion cet aprèm suite à l'annonce de GCC 12 par redhat. Il y a une amélioration de la détection des membres non initialisés.

Pas vu passer.

lmghs a écrit:

Ici les setters aussi n'ont pas le moindre sens. Tes données n'ont pas d'invariants, et encore moins de services. OSEF si l'utilisateur va taper dedans.

-
Edité par Nababe 27 avril 2022 à 10:14:49

Pourquoi la balle changerait de masse ou de couleur?

Et ensuite, si la position devait etre modifiée par l'extérieur, pourquoi la position devrait passer par un setter? Au lieu de

balle.position += balle.velocity * dt;

Un setter n'est pas un gage de bonne conception. C'est généralement tout le contraire. https://www.infoworld.com/article/2073723/why-getter-and-setter-methods-are-evil.html (une infinité de débats sur le sujet sur OC et ailleurs)

A la place ce qui aurait du sens, c'est fournir un service

Ball:update_position(double dt) {
    position += velocity * dt;
}

Et même chose pour les forces qui vont agir sur la vélocité.

Autant sur la balle on peut se poser une question car on peut imaginer des services propres à tout mobile.

Sur le vecteur par contre... Où sont les services autres que de stocker des coordonnées? Et éventuellement supporter une algèbre (pour les additionner, soustraire, multiplier, etc). Ici, il y a (AMA) un bon désign de vecteur mathématique: https://marzer.github.io/muu/structmuu_1_1vector.html

On peut imaginer différents events (bonus par exemple) qui donnerait des caractéristiques à la balle et donc pourquoi pas changerait de couleur. Mais je comprends le principe de ne pas mettre des setters pour tout et n'importe quoi, il faut plutôt privilégié des méthodes qui modifient les attributs certes mais dans des cas précis comme ton exemple

Ball:update_position(double dt);

Merci pour ces explications, je vais tacher de rendre le code plus propre !