[C++] Overloading << e problemi col costruttore

[kirakira93]

Ciao ragazzi, mentre sto sviluppando la mia famosa libreria FTP lol mi sono incastrato in questo problema:

//costruttore
ftpstream::ftpstream()
{
hInternet = NULL;
/*blah blah blah*/
hInternet = InternetOpen(NULL,INTERNET_OPEN_TYPE_DIRECT,NULL,NULL,0);
/*blah blah blah*/

}

//distruttore
ftp::ftpstream::~ftpstream()
{
/*blah blah blah*/
if(hInternet != NULL)
    InternetCloseHandle(hInternet);
/*blah blah blah*/
}

Fino a qui tutto bene.

Ora però se io voglio overloaddare l'operatore << scrivere su un file FTP aperto precedentemente, come devo fare??
nel senso, il protipo della funzione lo devo dichiarere così?

ftpstream & operator << (ftpstream&,std::string &);
in teoria si, ma il compilatore mi dice: ERROR! Too many parameter for this operator function -.-

Come devo dichiararlo allora???

e poi, se io voglio evitare che nel ritorno non mi crei un altro oggetto temporaneo (e quindi chiami il costruttore creando un altro HANDLE hInternet, diverso da quello che mi serve), devo usare il Costruttore di Copia?
Mah! Che dite?

[lolide]

Originariamente inviato da kirakira93
ftpstream & operator << (ftpstream&,std::string &);
in teoria si, ma il compilatore mi dice: ERROR! Too many parameter for this operator function -.-

Veramente in teoria no.

Il prototipo di operator << è

T T::operator << (T& a);​

T: un tipo.

Quindi nel tuo caso scrivi

ftpstream & operator << (std::string &);

Originariamente inviato da kirakira93
e poi, se io voglio evitare che nel ritorno non mi crei un altro oggetto temporaneo (e quindi chiami il costruttore creando un altro HANDLE hInternet, diverso da quello che mi serve), devo usare il Costruttore di Copia?
Mah! Che dite?

Mica devi ritornare per forza un oggetto temporaneo.
Basta ritornare this e risolvi tutto (se devi operare su quell'oggetto).

In pratica dipende da cosa vorresti fare.
Se devi fare delle operazioni su quell'handler (privato o protected spero ), allora fai tutto quello che devi e poi ritorna this.

[kirakira93]

Allora, il fatto è questo:

il prototipo della funzione l'ho dichiarato così:

ftpstream * operator << (std::string &);

perchè se scrivevo ftpstream operator <<... o ftpstream & operator << .... non povevo ritornare this, che è const ftpstream *

Il problema è che con questo codice se io scrivo così:

ftpstream ciao;
ciao << "1" << "2" << "3";
mi chiama il costruttore di ciao, e poi mi chiama 3 volte il distruttore! dopo aver eseguito l'operatore!

Come posso fare?????

[kirakira93]

Ragazzi ho risolto il problema abbastanza elegantemente!

Quando ritorno il puntatore a ftpstream esso chiama il costruttore di copia, io nel costruttore di copia copio gli indirizzi degli HANDLE e poi modifico questo valore: is_this_temporary (è un oggetto temporaneo) a true, nel costruttore controllo se l'oggetto è temporaneo o no...

posto il codice casomai servisse a qualcuno, ma mi chiedo se utilizzare l'overloading dell'operatore << ritornando un puntatore, e non un reference come vedo in quasi tutti i sorgenti C++, sia la scelta migliore e se la soluzione che ho trovato io è buona o se posso migliorare il codice.
esperti di C++ non fate morire il topic

ftp::ftpstream::ftpstream()
	{
	hInternet = NULL;
               hInternet = InternetOpen(NULL,INTERNET_OPEN_TYPE_DIRECT,NULL,NULL,0);

//bla bla bla
	}

ftp::ftpstream::ftpstream(ftpstream & copy)
	{
	is_this_temporary = true;
	this->hInternet = copy.hInternet;
	//e copia altro
	}

ftp::ftpstream::~ftpstream()
	{
	if(is_this_temporary == false)
	    {
	//bla bla bla		if(hInternet != NULL)
			InternetCloseHandle(hInternet);
		}
	}

[KrOW]

Scusa ma sei sicuro che

......
class ftpstream
{
......
friend ftpstream& operator<< ( ftpstream& stream, std::string& str );
};
ftpstream& operator<< ( ftpstream& stream, std::string& str );
......

non funziona???