Newsgroup: it.comp.lang.c++
Titolo: ClassName* operator+=(const ClassName* c); ( o giu' di li )

Ciao a tutti.
Data una classe PluginResult, io vorrei fare
PluginResult *p1 = new PluginResult();
PluginResult *p2 = new PluginResult();
p1+=p2;
Non è possibile?
Io ho implementato:
inline PluginResult& operator+=(const PluginResult& p);
che va bene per due istanze statiche.
Come fare per i puntatori?
Non ho trovato neanche un esempio di implementazione in giro.
Prendiamo anche le QT ;
    QString *asd = new QString("asd");
    QString *qwe = new QString("qwe");
Io non posso fare:
    asd += qwe;
Ma me la cavo lo stesso con:
    *asd += *qwe;
... e funziona.
Immagino che non ci sia il modo... ma nn capisco perchè.
Cosa mi sto perdendo di basilare?
Mi date qualche hint o link perfavore?
Grazie
Saluti.

    *asd += *qwe;
Che vuol dire "me la cavo lo stesso"? Detta cosě sembra che consideri
quest'ultima operazione un palliativo piuttosto accettabile per la
prima. Ovviamente cosě non č. Quest'ultima puň avere un senso, la
prima no.
Forse non ho capito bene il punto.

 Forse non ho capito bene il punto.
hai capito bene.
e ti sei spiegato perfettamente.
e io mi sono scordato l'aritmetica dei puntatori.
ora devo rimuginarci un po su.
grazie
Mario

 Saluti.
Un "operator function", come per esempio per sovraccaricare +=, può
essere:
* Una funzione membro non statica - ovviamente non è possibile in
questo caso (i due parametri sono puntatori e  non classi);
* Altrimenti una funzione non membro con almeno un parametro di tipo
classe, un riferimento ad una classe, un enumeratore o un riferimento
ad un enumeratore (per esempio, con un parametro di tipo  QString& e
l'altro di tipo QString*).
Dunque non è possibile sovraccaricare l' operator +=( QString*,
QString* ).
Detto ciò', sovrascrivere le operazioni aritmetiche dei puntatori
potrebbe aver senso?
Saluti.

 Come fare per i puntatori?
Non puoi, perché i puntatori sono un tipo predefinito. Però se quello 
che vuoi è utilizzare i puntatori come se fossero degli oggetti allora 
puoi definire un oggetto che si comporta come se fosse un puntatore.
Invece che
PluginResult *p1 = new PluginResult();
dovresti fare:
PluginResultPtr p1 = new PluginResult();
dove PluginResultPtr è una classe che può essere costruita con un 
puntatore a PluginResult, implementa operator-> per funzionare come un 
puntatore, e implementa operator+= per risolvere il tuo problema.
E.

 Come fare per i puntatori?
Altri ti hanno gia' spiegato dov'e' il problema dal punto di vista
tecnico. Vorrei aggiungere qualche considerazione di carattere
concettuale. Di solito in C++ quando si definisce una classe che
rappresenta un valore la si usa direttamente e non allocandone le
istanze in modo dinamico. Addirittura un punto di vista comune e' che
le istanze di questo tipo di classi dvrebbero essere immutabili e
qualsiasi operazione su di esse dovrebbe di fatto sostituire l'istanza
con una nuova.
Per contro di solito le classi le cui istanze vengono allocate
dinamicamente rappresentano entita', ovvero oggetti per i quali ha
senso il concetto di identita'. Cosi' voler usare una classe tramite
puntatori ed allo stesso tempo definire per essa operatori aritmetici
e' un po' una contraddizione, spesso causata dal voler trasferire in C+
+ il modo di lavorare di altri linguaggi, Java in primis.
Ciao,
Nicola

 nuova.
io devo portarmi in giro questi valori. Non vorrei copiarli qua e la ogni 
volta.
In c avrei usato una malloc di una union.. o una struct con un void* che 
puntava alle proprietà nuove (quelle che in c++ aggiungo derivando).
Qui?
Non dovrei usare il += ? dovrei invece usare una funzione pluginResult.add
(pluginResult) ?
Grazie.
Ciao.

 casi nn si sa bene quando
... quando le varie classi andranno ad elaborare i vari risultati.
E quindi vano lasciati disponibili per un tot di tempo.
Quindi se fossero statici andrebbero copiati.

 (pluginResult) ?
a += b;    // Same as a.operator+=(b)
;-)

 (pluginResult) ?
Penso che userei una funzione piuttosto che un operatore, ma non fa
una gran differenza.
Ciao,
Nicola

 la memoria, ma questo comunque non sposta gli aspetti concettuali.
ecco.
questo mi manca
/me va a leggere
grazie molte.
post utile!
Mario