Overloading operatore += con oggetto template

[Blonic]

Salve sto lavorando ad uno stack di generici tipi T e volevo effettuare l'overload dell'operatore += che aggiunge allo stack l'elemento indicato. Il codice che ho scritto non funziona. La cosa che voglio fare si può fare? Se sì come? Qualcuno mi sa aiutare? Grazie!

Code:

#include<iostream>

using namespace std;

template <class T> class Stack{
     T * elementi;
     int max, testa, coda;
     public:
          Stack(int m) {max = m; testa=0; coda=0;};
          ~Stack() {delete [] elementi;};
          Stack<T> & operator+=(T & elem);     //Stack+=T; pusha T sullo stack
          template <class T1> friend ostream & operator<<(ostream & out, Stack<T1> &s);
};

template <class T> Stack<T> & Stack<T>::operator+=(T & elem){
      coda++;
      elementi[coda] = elem;
      return *this;
}

template <class T> ostream & operator<<(ostream & out, Stack<T> &s){
     out<<"prova";
     return out;
}

main(){
     Stack<float> s(10);
     cout<<s<<endl;
     s+=5.0;
     cout<<s<<endl;
     system("pause");
}

[Shin]

Il "problema" (che poi non è proprio un problema) sta qui:

Code:

Stack<T> & operator+=(T & elem);

perchè mettendo "T & elem" il metodo si aspetta un riferimento a T, ma tu nel main non passi un riferimento a T (nel tuo esempio T sarà un float) ma un direttamente un valore numerico (nel tuo esempio 5,0 che non ha alcun riferimento perchè non è allocato in memoria.

Quindi o cambi il metodo in:

Code:

Stack<T> & operator+=(T elem);

e quindi mettendo che prende in input "T elem" al posto di "T & elem",

oppure nel main metti qualcosa come:

Code:

float prova = 5.0f;
s+=prova;

al posto di:

Code:

s+=5.0;

[havoc]

O li metti entrambi (con reference e senza)

Code:

Stack<T>& operator+=(T& elem);
Stack<T>& operator+=(T elem);

[Blonic]

Vi ringrazio per le informazioni! Quindi vediamo se ho capito bene, la differenza fra questo

Code:

float prova = 5.0f;
s+=prova;

e questo

Code:

s+=5.0;

è che nel primo caso la variabile è un oggetto nel secondo è una costante, per cui in quest'ultimo caso non esiste un riferimento ad essa?

[Shin]

Vi ringrazio per le informazioni! Quindi vediamo se ho capito bene, la differenza fra questo

Code:

float prova = 5.0f;
s+=prova;

e questo

Code:

s+=5.0;

è che nel primo caso la variabile è un oggetto nel secondo è una costante, per cui in quest'ultimo caso non esiste un riferimento ad essa?

nell'ultimo caso non esiste un riferimento perchè non il valore "5.0" non è presente da nessuna parte in memoria.

O li metti entrambi (con reference e senza)

Code:

Stack<T>& operator+=(T& elem);
Stack<T>& operator+=(T elem);

buona idea!

[Blonic]

Ho capito, grazie mille!

[havoc]

In ogni caso va bene come esercizio, ma nella pratica sconsiglio l'overload di operatori quando possano creare problemi di leggibilità del codice.
Il C++ è un linguaggio estremamente potente ma da grandi poteri derivano grandi responsabilità!
Come disse il creatore del C++:

C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off.

[Blonic]

Come pensiero è correttissimo però a mio parere il significato di

Code:

T t;
Stack <T> s;
s+=t;

è molto intuitivo, fra l'altro la stessa cosa identica c'era in un esercitazione del prof, per aggiungere un punto (classe Point) al percorso (classe Path)

[havoc]

La davo come regola generale, perché in questo periodo sto leggendo "the practice of programming" di Kernighan e Pike, e nel primo capitolo tratta appunto la leggibilità del codice.
Poi è buona norma usare i nomi classici quando si implementano strutture o algortmi ben noti, e considerando la singola linea è sicuramente più leggibile s.push(5) rispetto a s+= 5.

Poi è risaputo che io sono di una pignoleria mostruosa, e inoltre nella mia carriera ho visto codice in C++ da far paura

[Blonic]

La pignoleria è una qualità per un informatico ed esprimere le proprie opinioni è sempre giusto.
Quel libro deve essere interessante, un giorno gli darò un occhiata!