Newsgroup: it.comp.lang.c++
Titolo: Oggetti con puntatore agli stessi dati

Salve a tutti,
ho una classe con dati del tipo:
int myInt;
myPtr_t * myPtr;
L'intero lo uso per gli operatori relazionali (per poter mettere
questi oggetti in certi container), il puntatore punta ai miei veri
dati. La classe rappresenta un pacchetto dati che devo spedire verso
un mio dispositivo seriale.
Dichiaro un oggetto di questo tipo, e lo metto in una coda (in attesa
di essere spedito). Poi lo estraggo, lo spedisco, e lo metto in un set
(in attesa di sapere se l'invio ha avuto successo o no). Da qui
potrebbe tornare nella coda (l'invio non ha avuto successo, riprovero'
in seguito), o potrebbe essere distrutto (l'invio ha avuto successo).
Ora: in tutto questo andirivieni di spostamenti tra un container e
l'altro non ha alcun senso fare una deep copy. Quello che vorrei e'
che quando sposto l'oggetto da un container all'altro venga fatta una
"shallow copy" (copio l'intero e il puntatore, il pointee non cambia),
e solo alla fine, quando voglio distruggere l'oggetto, venga liberata
la memoria del pointee.
BTW, il pointee e' puntato sempre e solo da un puntatore, anche se si
sposta tra i container (c'e' solo un pacchetto, che si muove tra i
container).
Come si fa a fare questa cosa?
Thx,
Pleg

 Come si fa a fare questa cosa?
Da come descrivi la cosa dovresti poter usare un auto_ptr come tipo di 
myPtr:
int myInt;
auto_ptr<myObject> myPtr;
ma per sicurezza (e eventuali sviluppi successivi) sarebbe meglio 
utilizzare uno smart pointer.
E.

 Come si fa a fare questa cosa?
 std::tr1::shared_ptr (richiede GCC >= 4.3 o VS2008 SP1 )
 boost::shared_ptr    (richiede Boost)
M

Grazie a entrambi!
Pleg

>  boost::shared_ptr    (richiede Boost)
Guardando questo sono incappato nell'esempio
http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/example/shared_ptr_example.cpp
che ha una cosa che cercavo da tempo e non avevo mai trovato: un
secondo argomento per std::set per definire una specie di funzione
callback per dire come confrontare i dati che metto nel set.
Ma non e' una funzione: e' uno struct che ridefinisce un operatore.
Nella mia mente rimane una funzione callback. Com'e' che funziona la
cosa?
Thx,
Pleg

 Guardando questo sono incappato nell'esempiohttp://
www.boost.org/doc/libs/1_39_0/libs/smart_ptr/example/shared_pt.
..


[cut]
Grazie!
Pleg

 una sommatoria lungo gli elementi di un array.
Attenzione a questo: in molti casi nella libreria standard si richiede
che non rimanga stato salvato (per lasciare piu' liberta' alle policy
interne di copia etc etc etc).
-- 
-riko

 -riko
Ciao,
potresti fare un esempio pratico?
Sullo Stroustrup, terza edizione, § 18.4 - "Oggetti funzione", trovo:
«Una funzione non è logicamente sufficiente ad esprimere quello che si
vuole: infatti spesso la funzione chiamata per ogni elemento deve
mantenere dei dati fra un'invocazione e l'altra e deve restituire il
risultato di numerose esecuzioni. Una funzione membro di una classe è
dunque più a data a questo scopo grazie al fatto che l'oggetto può
memorizzare dei dati e in aggiunta può fornire funzioni di
inizializzazione e di estrazione per quei dati.»
Trovo strano un comportamento delle STL come quello che suggerisci tu,
ma tutto può essere :-p.
Matteo

 potresti fare un esempio pratico?
Alcuni esempi e note.
In primo luogo gli oggetti funzione sono sempre passati per copia (a
meno di specificare altrimenti). Questo suggerisce sicuramente di
tenerli piccoli e con copia veloce. Non farlo rallenta il codice.
Di fatto questo non impedisce di memorizzare valori, ma suggerisce di
non memorizzare roba grossa.
Il vero problema sorge quando hai a che fare con un oggetto funzione che
funge da predicato. Il punto e' che di fatto non hai molta idea della
politica di copia/creazione dentro l'algoritmo standard. Se dentro il
tuo algoritmo l'oggetto funzione e' passato a piu' di un algoritmo
standard, potresti trovarti con problemi.
Questo e' certamente vero nel caso di predicati, come dicevo. 
Come nota a margine, vista la natura prettamente funzionale (come
struttura) della STL (e sicuramente della parte che riguarda algoritmi e
oggetti funzione) io amo comunque tenere uno stile marcatamente
funzionale nella scrittura del codice. Questo e' ovviamente un gusto mio
e non detta legge. Quella dei predicati e' invece una cosa
imprescindibile: tipicamente si vuole anche constare operator().
-- 
-riko