Comment créer operator*(double) pour multiplier à la fois du côté gauche et du côté droit?

Question

Je cherche à comprendre comment écrire un opérateur surchargé pour ma classe Vector2d qui me permet de multiplier par un scalaire à la fois à gauche et à droite.

class Vector2d
{
    double _x;
    double _y;

public:
    Vector2d(double x = 0, double y = 0) : _x(x), _y(y) {}

    Vector2d operator*(const double s) const
        { return Vector2d(_x * s, _y * s); }

    friend Vector2d operator*(const double s, const Vector2d& v);
};

Vector2d operator*(const double s, const Vector2d& v)
{
    return Vector2d(v._x * s, v._y * s);
}

Si je définis uniquement l'opérateur membre *, mon objet peut être multiplié à droite par un scalaire mais pas à gauche. Si j'ajoute la fonction amie operator*, j'obtiens une erreur lors de la compilation :

Vector2D.h:61: définition multiple de `Gf::operator*(double, Gf::Vector2d const&)'
Vector2D.h:61: première définition ici
Vector2D.h:61: définition multiple de `Gf::operator*(double, Gf::Vector2d const&)'

Quelle est la bonne façon de faire cela ?

---

Je plaçais la fonction operator* dans le fichier d'en-tête. Une fois que je l'ai déplacée dans le fichier .cpp, elle a été compilée correctement.

Answer 1

Il semble que votre fichier a été inclus plusieurs fois, la plupart des compilateurs prennent en charge #pragma once de nos jours. Vous pouvez également utiliser un garde-header (vérifiez la définition d'un jeton avant de le définir avec le reste de votre en-tête) :

#ifndef VECTOR_2D
#define VECTOR_2D

class Vector2d
{
    double _x;
    double _y;

public:
    Vector2d(double x = 0, double y = 0) :_x(x), _y(y) {}

    Vector2d operator*(const double s) const
        { return Vector2d(_x * s, _y * s); }

    friend Vector2d operator*(const double s, const Vector2d& v);
};

Vector2d operator*(const double s, const Vector2d& v)
{
    return Vector2d(v._x * s, v._y * s);
}

#endif // VECTOR_2D