Newsgroup: it.comp.lang.c++
Titolo: overloading operator<<

Salve a tutti.
Sto scrivendo un paio di classi, che mi dovrebbero fornire una struttura
dati tipo lista, quindi dei nodi con smart pointers e reference count.
Ora io sto studiando sul libricino che ha scritto il sig. Stroustrup - 3^
edizione del 2000, ma trovandomi a compilare su un sistema su cui gira
gcc version 3.2.3 20030422
mi trovo ad affrontare delle discrepanze con il testo.. specialmente per
quello che riguarda l'overloading degli operatori.
Ora noto che tutti gli operatori richiedono o uno o zero parametri passati
e fin qui va anche bene, anche se sono certo di avere cannato qualcosa
(c'è qualche reference guide che posso leggere a riguardo?)
la segnatura nella classe è la seguente:
--
class Insieme_int { // classe collezione tramite smartp && ref-count
private:
	// ...
        class smartp {
        private:
                nodo* ptr;
        public:	
		// METODI DI SMARTP
		// ...
	};
        class nodo {
        public:
                int el, ref; // el: elemento, ref: ref-couter
                smartp next; // puntatore al nodo successivo
	        // METODI di nodo
		// ...
	};
	smartp first;
public:
	// ...
        ostream& operator<< (const Insieme_int&);
        // ...
};
--
ora questo benedetto operatore dovrebbe stampare tutti gli elementi
dell'insieme (scorrendo i nodi) ma mi sorge il dubbio (e il compilatore me
lo segnala) che dovrei inizializzare l'ostream e nn ho la + pallida idea
di come fare (perdonate gli errori grossolani e idioti da parte mia, ma
sto cercando di imparare)
al momento l'ho definito così, ma non gli va bene... e nemmeno a me...
--
ostream& Insieme_int::operator<< (const Insieme_int& a) {
   ostream& os;
   os << '{';
   smartp tmp=a->first;
   while (tmp!=0) {
        os << tmp->el << ',';
        tmp = tmp->next;
   }
   return os << '}';
}
---
se qualcuno fosse così gentile da illuminarmi o indicarmi quantomeno la
strada da seguire (tipo un link decente da leggere) gliene sarei davvero
grato :)
Peach

 Peach
L'overloading dell'operatore << per usarlo come ti aspetti (cioe' per 
fare cout<<x per intenderci) devi ridefinirlo esternamente a una classe, 
eventualmente dichiari la funzione amica della tua classe.
la signatura sara' questa
ostream& operator<<(ostream&, const Insieme_int&);
la tua definizione interna alla classe e' comunque sbagliata, perche' 
come parametro deve avere un'ostream, l'Inisieme_int viene passato 
implicitamente tramite this.
ps: ma fai informatica a padova?

 ps: ma fai informatica a padova?
ti ringrazio per la risposta che mi ha chiarito quel po' di casino che mi
ero autogenerato nella testa :)
Peach
Ps: sì, si nota così tanto? ;)

 Ps: sì, si nota così tanto? ;)
si nota perche' ci sono anche io e il progetto di p2 lo conosco bene hehe :)

 si nota perche' ci sono anche io e il progetto di p2 lo conosco bene hehe :)
che culo  :D
superato questo dubbio sull'overloading mi trovo di fronte ad un altro
errore.
Nello specifico: l'errore in compilazione è:
test-main-super-minimale.cpp: In function `int main()':
test-main-super-minimale.cpp:12: no matching function for call to `Insieme_int
   ::Insieme_int()'
Insieme_int.h:6: candidates are: Insieme_int::Insieme_int(const
Insieme_int&)
il tutto si riferisce all'inizializzazione di un elemento tipo:
Insieme_int ins1;
questo mi da fastidio, perchè non avendo dichiarato nessun costruttore
da quello che so dovrebbe usare il costruttore standard, e i relativi
costruttori per i tipi primitivi e non (aka quelli che ho definito 
all'interno di class Insieme_int).
Cosa devo verificare?
che i tipi interni a Insieme_int abbiano un costruttore di default? (ad
esempio Insieme_int::smartp non ne ha, ma Insieme_int::nodo si)
giusto per ricordare la classe è definita così (membri principali e
costruttori):
class Insieme_int { // classe collezione tramite smartp && ref-count
private:
	class nodo; // incomplete declaration
	class smartp {
	private:
		nodo* ptr;
	public:
		// METODI di smartp
		smartp (nodo *p);
		smartp (const smartp&);
		~smartp();
		// ...
	};
	class nodo {
	public:
		int el, ref; // el: elemento, ref: ref-couter
		smartp next; // puntatore al nodo successivo
		// METODI di nodo
		nodo ();
		nodo (int, smartp);
	};
	smartp first;	
public:
	// ...
};
ammetto che forse dovrei provare a dormire un paio di ore visto che sn in
dritto da un paio di giorni e magari la cosa mi potrebbe viene più chiara...
grazie in anticipo
--
Peach

 Peach
probabilmente dichiari un Insieme_int senza paremetri e non c'e' a 
disposizione nessun costruttore senza parametri. il costruttore di 
default e' disponibile fintantoche' non e' definito nessun costruttore. 
se c'e' un costruttore senza parametri controlla che anche gli oggetti 
dentro alla classe possano essere costruiti (con costruttori di default 
o con parametri di default)

 o con parametri di default)
Ho risolto dichiarando un Insieme_int() senza parametri. 
Come avrai notato nn c'era nessun costruttore dichiarato, ma penso 
che il problema fosse legato al fatto che nn ci fosse un costruttore
senza parametri per Insieme_int::smartp
Ora nell'overloading di operator<< trovo un'altro problema
la dichiarazione è la sequente:
ostream& operator<< (ostream& os, const Insieme_int& a) {
	if (a.first==0) return os << "0";
	else {
		os << '{';
		Insieme_int::smartp tmp = a.first; 
		while (tmp!=0) {
			os << tmp->el << ',';
			tmp = tmp->next;
		}
		return os << '}';
	}
}
solo che compilando mi dice che:
Insieme_int.cpp:103: passing `const Insieme_int::smartp' as `this' argument of
   `bool Insieme_int::smartp::operator==(const Insieme_int::smartp&)' discards
   qualifiers
l'overloading di Insieme_int::smartp::operator== è la sequente:
bool Insieme_int::smartp::operator==(const smartp& p) {
   return ptr == p.ptr;
}
ho provato pure a segnare l'operatore come 
bool Insieme_int::smartp::operator==(smartp p);
ma nn cambia nulla al compilatore...

 }
  bool Insieme_int::smartp::operator==(const smartp& p) const {
Nota il 'const' in fondo.
Max