surcharge de l'opérateur C++

Question

J'essaye de préformer la surcharge de l'opérateur en C++; pour une raison quelconque le compiles ne cesse de me donner l'erreur

error: ‘bool Matrix::operator==(const Matrix&, const Matrix&)’ must take exactly one argument

Maintenant, je sais qu'il ya un moyen de lui avec un argument à l'aide, mais je compris qu'en utilisant ami, je peux le faire de cette façon , mais ça ne marche toujours pas.

Voici mon code,

Merci d'avance.

class Matrix{ 
public: 
Matrix(); 
friend bool operator==(Matrix &mtrx1,Matrix &mtrx2); 
friend bool operator!=(Matrix &mtrx1,Matrix &mtrx2); 

protected: 
std::vector<Cell> _matrix; 
int _row; 
int _col; 

}; 

inline bool Matrix::operator==(const Matrix& mtrx1, const Matrix& mtrx2){ 

/* .......... */ 
} 

Answer 1

Bien que vous avez mis la déclaration friend dans la classe, il est pas membre. Ainsi, la définition de la fonction devrait être un non-membre:

inline bool operator==(const Matrix& mtrx1, const Matrix& mtrx2) {...} 

Vous devez également ajouter const qualificatifs aux arguments des déclarations, pour correspondre à celles de la définition.

Answer 2

Vous le faites avec 2 paramètres si vous le faites en dehors de la classe, pas en tant que fonction membre.

En fonction de membre, vous devez seulement 1 paramètre (l'autre paramètre est *this)

Answer 3

Le operator==membre fonction est déclarée comme:

class foo { 
    public: 
    bool operator==(foo const & rhs) const; 
}; 

La operator==fonction globale est déclarée :

bool operator==(foo const & lhs, foo const & rhs); 

---

Généralement, la fonction membre est déclarée et définie en premier. Ensuite, la fonction globale est définie en termes de la fonction membre en tant que

Un seul entre la fonction membre et la fonction globale est déclaré et défini. Ayant tous les deux est ambigu pour des déclarations comme (1) dans les domaines suivants

foo f1; 
foo f2; 
bool f1EqualsF2 = (f1 == f2); // (1), ambiguous 

et dans de tels cas d'erreur du compilateur retourne. En g ++, le message d'erreur ressemble

equals.cpp:24: error: ambiguous overload for ‘operator==’ in ‘f1 == f2’ 
equals.cpp:8: note: candidates are: bool foo::operator==(const foo&) const 
equals.cpp:17: note:     bool operator==(const foo&, const foo&) 

---

Chaque fois que operator== est fait, son recommandé de faire le operator!= correspondant.

Answer 4

class Matrix{ 
public: 
    Matrix(); 
    friend bool operator==(const Matrix &mtrx1, const Matrix &mtrx2); 
    friend bool operator!=(const Matrix &mtrx1, const Matrix &mtrx2); 

protected: 
    std::vector<Cell> _matrix; 
    int _row; 
    int _col; 
}; 

inline bool operator==(const Matrix& mtrx1, const Matrix& mtrx2){ 
    /* .......... */ 
    return true; 
} 

Passez la compilation dans Visual Studio 2005.

1. omettent le qualificatif const dans votre déclaration ami

2. ne ont pas besoin Matrice :: fonctionnement == définition