[C++] problemi overload operator== con classe allocata dinamicamente

[matteo martis]

Salve!!
Stavo creando delle classi, ma mi sono accorto che vi erano dei problemi,
andando avanti ho scoperto che il problema era nell'operatore di ugualianza
overlodato.
Ho creato una classe Data per provare a risolvere il problema è ho scoperto
che quando istanzio staticamente la classe ( senza new ) va tutto bene, ma
se la istanzio dinamicamente ( con new ) l'operatore non da mai l'ugualianza,
a meno che non stia confrontando la medesima stessa classe.
Il codice della classe Data e del suo utilizzo e giù.
Come si può risolvere questo problema???
Grazie!!!

#include <cstdlib>
#include <iostream>
using namespace std;



class Data{
      public:
      int dd;
      int mm;
      int yy;
      Data( int giorno, int mese, int anno );
      ~Data();
      bool operator==( const Data& right );
};

Data::Data( int giorno, int mese, int anno ){
    if( giorno < 1 && giorno > 31 ){
      giorno = 1;
    }
    if( mese < 1 && mese > 12 ){
      mese = 1;
    }
    if( anno < 1 ){
      anno = 1;
    }
    dd = giorno;
    mm = mese;
    yy = anno; 
}
Data::~Data(){}
bool Data::operator==( const Data& right ){
    return( dd == right.dd  &&  mm == right.mm && yy == right.yy );
}

int main(){
    Data dat1 = Data( 15, 7, 1950 );
    Data dat2 = Data( 15, 7, 1950 );
    if( dat1 == dat2 ){
       cout << " uguali " << endl;
    }else{
       cout << " diversi " << endl;
    }
    Data* dat3 = new Data( 26, 10, 2013 );
    Data* dat4 = new Data( 26, 10, 2013 );
    if( dat3 == dat4 ){
       cout << " uguali " << endl;
    }else{
       cout << " diversi " << endl;
    }
    if( dat3 == dat3 ){
       cout << " uguali " << endl;
    }else{
       cout << " diversi " << endl;
    }
    system("PAUSE");
    return EXIT_SUCCESS;
}

[oregon]

Non CODICE ma CODE ...

[Rising1]

Se scrivi if(dat3==dat4) esegui una operazione tra puntatori, che è vera solo se i due puntatori puntano allo stesso oggetto (e questo non è il nostro caso). Per confrontare gli OGGETTI PUNTATI devi far precedere il nome del puntataore da *. Quindi è corretto if(*dat3==*dat4)

[lovesemiramide]

Semplicemente perché stai confrontando puntatori ad oggetti di tipo Data e non gli oggetti stessi.

[matteo martis]

Grazie!!!

[matteo martis]

Il problema è risolto per le classi standard, ma
con le le classi con template funziona, ma sono se accedo
direttamente al campo

#include <cstdlib>
#include <iostream>
using namespace std;

template<class T>
class Int{
      public:
      T i;
      Int( int* value );
      ~Int();
      bool operator==( const Int& right ); 
};

template<class T>
Int<T>::Int( int* value ){
    i = value;
}

template<class T>
Int<T>::~Int(){
    i = NULL;
}

template<class T>
bool Int<T>::operator==( const Int<T>& right ){
    return *i == *right.i;
}

int main(){
    int i1 = 15;
    int i2 = 15;
    int* p1 = &i1;
    int* p2 = &i2;
    Int<int*>* I1 = new Int<int*>( p1 );
    Int<int*>* I2 = new Int<int*>( p2 );
    
    if( *I1 == *I2 ){
     cout << "okk!!!" << endl;
    }
    system("PAUSE");
    return EXIT_SUCCESS;
}

Se provo ad utilizzare il metodo predisposto il
codice non funziona più e mi viene ritornato un errore
del tipo

' passing const<int*>' as 'this' argument of 'T Int<T>::getValue() [ with T = int* ]' discards qualifiers

[MegaAlchimista]

secondo me ti basterà qualche commento per capire quali errori concettuali stai commettendo

//TemplateClass.h


template<class T>
class Int{
public:
    T i;
    Int(int* value);
    ~Int();
    bool operator==(const Int& right);
};


template<class T> Int<T>::Int(int* value)
{
    i = value;                    //i è template e tu lo stai assegnando ad un puntatore ad intero!!!
}


template<class T> Int<T>::~Int()
{
    i = NULL;                //i non è un puntatore!
}


template<class T> bool Int<T>::operator==(const Int<T>& right)
{
    return *i == *right.i;    //di nuovo i non è un puntatore
}

pensaci bene :-)


//EDIT:
Inoltre il codice che hai appena messo non può dare l'errore su getValue() in quanto non esiste alcun metodo getValue().
Ad ogni modo cerca "C++ error discards qualifiers per capire di cosa si tratta (non hai dichiarato bene i const, oppure stai usando la funzione in un modo diverso da come è stata disegnata) e risolverlo

[matteo martis]

chiedo scusa, ma ho postato il codice errato e in modo incompleto. nel codice corretto
il template viene istanziato con il paramentro reale int*.
il construttore prende come parametro un parametro di tipo T.

#include <cstdlib>
#include <iostream>
using namespace std;

template<class T>
class Int{
      public:
      T i;
      Int( T value );
      T getValue();
      ~Int();
      bool operator==( const Int& right ); 
};

template<class T>
Int<T>::Int( T value ){
    i = value;
}

template<class T>
Int<T>::~Int(){
    i = NULL;
}

template<class T>
T Int<T>::getValue(){
   return i;
}
template<class T>
bool Int<T>::operator==( const Int<T>& right ){
    return *i == *right.getValue();
}

int main(){
    int i1 = 15;
    int i2 = 15;
    int* p1 = &i1;
    int* p2 = &i2;
    Int<int*>* I1 = new Int<int*>( p1 );
    Int<int*>* I2 = new Int<int*>( p2 );
    
    if( *I1 == *I2 ){
     cout << "okk!!!" << endl;
    }
    system("PAUSE");
    return EXIT_SUCCESS;
}

[matteo martis]

risolto... quando si passa come parametro un oggetto costante di posso invocare solo funzioni costanti... rendendo costante la funzione getValue() ho risolto.