Newsgroup: it.comp.lang.c++
Titolo: scaricamento oggetto dalla memoria

Mettiano il caso che io creo una classe e poi la uso nel seguente modo:
class a{/*...........*/}
int main(){
        a obj;
        obj.funzione(); //   <------------
        // altre funzioni
        return 0;
}
Dopo aver finito di usare l'oggetto alla funzione indicata, il compilatore 
distrugge l'oggetto , o aspetta che finisce il main?
Grazie. 
-- 
Abruzzo Silvio
studente, 16 anni
goku_...@libero.it
silvi...@aruba.it
^____^

 compilatore distrugge l'oggetto , o aspetta che finisce il main?
alla fine dello scope di visibilita', cioe' dopo il return;

distrugge l'oggetto , o aspetta che finisce il main?
Non so cosa dica lo standard ma ho sempre letto che gli oggetti
vengono distrutti alla fine dello scope, quindi dopo la fine del main,
ho fatto una semplice prova con g++ e VC++ e sembra proprio che sia
cosě:
struct A{
    ~A(){std::cout << "~A" << std::endl;}
    void f(){std::cout << "f" << std::endl;}
};
int main(){
    A a;
    a.f();
    std::cout << "fine main" << std::endl;
    return 0;
}
l'output č:
f
fine main
~A
--
Marco Barisione (ICQ 84277092)

 
Infatti è quello che immagginavo ache io, ma mettiamo che io ho oggetti 
abbastanza grandi, e verso la metà del main il compilatore vede che io non 
utilizzerò più l'oggetto, non è conveniente distruggere l'oggetto tra 
l'ultima istruzione in cui compare l'oggetto e l'istruzione subito 
successiva? Cio permetterebbe di liberare molta memoria.
Ciao e grazie dell'aiuto.


successiva? Cio permetterebbe di liberare molta memoria.
Non credo che il main (ne' altre funzioni) abbiano modo di
capire se utilizzi o meno un oggetto da un certo punto in
poi.  L'unico modo che hanno per stabilire se un oggetto
vada distrutto o meno e' vedere se lo scope in cui viene
utilizzato e' terminato.
--
Andrea Laforgia (mica uno qualunque...)

Ciao e grazie dell'aiuto.
Anche se ci fosse modo non potrebbe farlo se non previsto dallo
standard perché potrebbe avere degli effetti dannosi, ad esempio nelle
funzioni chiamate dopo potresti far affidamento a qualcosa fatto da
quella classe annche senza utilizzarla esplicitamente, un esempio
molto stupido:
class A{
     A{
         carica_librerie_gestione_immagini();
     }
     ~A{
         scarica_librerie_gestione_imagini();
     }
     void f(){
         cout << "ciao!" << endl;
};
int main(){
     A a;
     immagine im1 = "pippo.jpg";
     a.f();
     //ora non uso + a ma se il compilatore
     //lo deallocasse non potrei + usare le immagini
     //perché non sono più disponibili le librerie che
     //servono
     immagine im2 = "pippo.gif"; //<-- ERRORE!
     return 0;
}
Ok è un esempio stupido ma questo può succedere anche in casi reali
dandoti non pochi problemi.


 successiva? Cio permetterebbe di liberare molta memoria.
a parte il fatto che non sarebbe semplice per il compilatore capire sino a 
che punto e' utilizzato un oggetto, lo standard non prevede questa 
possibilita' ma richiede che il distruttore di un oggetto venga eseguito 
quando la variabile esce dallo scope. Nota che grazie a questa garanzia in 
c++ e' possibile utilizzare con profitto l'idioma RAII (resource 
acquisition is initialization), rendendo il codice molto piu' pultito e 
exception-safe.
In sostanza l'idea fondamentale del RAII e' di semplificare i meccanismi di 
gestione di una risorsa inserendo il codice che alloca tale risorsa nel 
costruttore e quello che la dealloca nel distruttore. Un tipico esempio 
sono gli stream di I/O:
void foo()
{
  std::ofstream of("bar.txt");
  // codice vario
}
Con questo codice siamo sicuri che al momento della distruzione di of il 
file verra' chiuso e memorizzato correttamente su disco. La cosa 
interessante e' che il distruttore viene richiamato anche se nel mezzo di 
"codice vario" viene sollevata una eccezione non intercettata da foo.
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

 "codice vario" viene sollevata una eccezione non intercettata da foo.
va mene, questo lo sapevo ma non sapevo che si chiamava cos'ě.
Ciao 


 Ciao e grazie dell'aiuto.
Fai un bel blocco nested:
int main()
{
   ....
     {
         OggettoMoltoPesante obj;
          obj.faiqualcosa();
          //qua' esce di scope, viene chiamato il distr.
     }
   ...
   return 0;
 }
Ciao,
Zello


  }
Bello, non avevo visto ancora una cosa del genere.
Ciao e grazie


 Co'sè l'exception-safe? e per pulito cosa intendi?
exception-safe significa "sicuro rispetto alle eccezioni"; in pratica il 
codice continua ad avere un comportamento non errato anche se si verificano 
delle eccezioni (immagino tu sappia cosa sono). Ad esempio:
void foo()
{
        int* p = new int;
        // codice vario
        delete p;
}
Non e' exception-safe, in quanto se all'interno di codice vario viene 
sollevata una eccezione non intercettata la memoria allocata per p non 
sara' mai liberata.
Non ho mai approfondito piu' di tanto l'argomento, cmq scrivere codice 
exception-safe al 100% credo sia una impresa...


 verificano delle eccezioni (immagino tu sappia cosa sono). 
Graize, ora ho capito


 exception-safe al 100% credo sia una impresa...
Se ti puo' interessare un piccolo tool che ti aiuti in questo dai un'occhiata a
http://www.cuj.com/experts/1812/alexandr.htm?topic=experts
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556