Difficulté pour obtenir la surcharge de l'opérateur '==' au travail (C++)

Question

Bon, je ne sais pas ce que je fais ici, sinon ce n'est pas correct. Essayer de surcharger la méthode '==' d'une classe, et ça ne marche pas. Au moins, je reçois un faux retour de mon main, et le cout dans l'implémentation de '==' ne produit pas.

Ce sont mes trois fichiers:

// TestClass.h 

#ifndef TESTCLASS_H 
#define TESTCLASS_H 

class TestClass { 
public: 
    TestClass(int contents); 
    TestClass(const TestClass& orig); 
    virtual ~TestClass(); 
    bool operator==(const TestClass& other); 
private: 
    int contents; 
}; 

#endif /* TESTCLASS_H */ 



// TestClass.cpp 

#include <iostream> 

#include "TestClass.h" 

TestClass::TestClass(int contents) { 
    this->contents = contents; 
} 

TestClass::TestClass(const TestClass& orig) { 
    this->contents = orig.contents; 
} 

TestClass::~TestClass() { 
} 

bool TestClass::operator ==(const TestClass& other) { 
    std::cout << "COMPARING" << std::endl; 
    return (contents == other.contents); 
} 


// Main.cpp 

#include <cstdlib> 
#include <iostream> 

#include "TestClass.h" 

using namespace std; 

/* 
* 
*/ 
int main(int argc, char** argv) { 

    TestClass* tc = new TestClass(1); 
    TestClass* tc1 = new TestClass(1); 

    cout << (tc == tc1) << endl; 

    return 0; 
} 

La question est - ce que je fait de mal? Je m'excuse pour ce qui est probablement une erreur très stupide quelque part, mais je ne peux pas le voir.

Answer 1

tc == tc1 compare les valeurs de pointeur. Il "devrait" être *tc == *tc1, mais je ne comprends pas pourquoi vous allouer dynamiquement en premier lieu.

L'allocation automatique (pile) est fortement préférée, allouée uniquement dynamiquement lorsque l'objet doit être indépendant de la portée. (Et puis garder une trace de celui-ci avec des pointeurs intelligents attribués automatiquement, ce qui supprimera le pointeur quand il est approprié.)

---

En outre, l'opérateur doit être const, car il ne modifie pas this:

//          vvvvv 
bool operator==(const TestClass& other) const; 

mieux encore, cependant, est une fonction libre:

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

Ce qui serait peut-être un ami. (Les fonctions libres sont toujours préférées, plus cela permet au 5 == tc de fonctionner.)

Answer 2

Vous comparez des pointeurs. Essayez qu'au lieu:

cout << (*tc == *tc1) << endl; 

Deux remarques:

• Vous devez libérer la mémoire allouée à supprimer ou utiliser un pointeur intelligent

• Vous devez déclarer opérateur == const:

  bool operator==(const TestClass& other) const