De cours de chargement * l'opérateur doit prendre zéro ou un des arguments

Je suis nouveau à la surcharge des opérateurs, j'ai fait quelques recherches et trouvé cet article utile, j'ai écrit mon propre code, comme l'auteur l'a fait, mais je reçois vector vector::operator*(float, vector) must take either zero or one argument erreur.

Voici mon code:

class vector
{
      public:
       float x;
       float y;

      vector(float, float);
      float operator$ (vector, vector);
      vector operator* (float, vector);
      vector operator* (vector, float);
};

vector::vector(float _x = 0, float _y = 0)
{
   x = _x;
   y = _y;     
}
const float vector::operator$ (const vector &v1, const vector &v2)
{
    return (v1.x * v2.x) + (v1.y * v2.y);
}

const vector vector::operator* (const float &m, const vector &v)
{
    vector ret_val = v;
    ret_val.x *= m;
    ret_val.y *= m;
    return ret_val;
}

const vector vector::operator* (const vector &v, const float &m)
{
      return m * vector;     
}

Mon système d'exploitation est kubuntu 12.04 et mon IDE est dev-C++ fonctionnant sur linux en utilisant wine programme windows loader.

Première fois que je l'ai jamais vu quelqu'un de surcharge $.....
j'ai essayé de trouver un bon opérateur pour représenter le produit scalaire de vecteurs, rien de bon n'est venu dans mon esprit, nous pouvons définir un nouvel opérateur comme ce que j'ai fait?

OriginalL'auteur MJafar Mash | 2012-11-24

  1. 15

    Parce que vous êtes la définition operator*() comme une fonction membre, il y a déjà un paramètre implicite: l'objet pour lequel la méthode est invoquée! Par conséquent, les fonctions de membre de prendre un paramètre explicite, pas deux.

    on peut accéder au paramètre implicite par this. ..., ai-je le droit?
    C'est exact que vous pouvez, mais vous n'avez pas vraiment besoin. this->x est l'équivalent d'un peu x à l'intérieur d'une fonction membre. Le compilateur va convertir x à this->x.
    Que faire si j'ai besoin de garder de l'ordre comme MyClass = OtherClass * MyClass?

    OriginalL'auteur chrisaycock

  2. 7

    Il suffit de déclarer votre opérateur de surcharge de la fonction à l'extérieur de la classe. Aussi, vous êtes de retour d'une const qui pourrait ne pas être ce que vous voulez.

    class foo {
  //code
};

foo operator*(foo& lhs, bar& rhs) const;
foo operator*(bar& lhs, foo& rhs) const;
    pourquoi déclarer l'opérateur de surcharge de fonction à l'extérieur de la classe?
    Ce lien explique la raison. Espérons que cela aide. stackoverflow.com/questions/4652932/...

    OriginalL'auteur ajp013