Newsgroup: it.comp.lang.c++
Titolo: Oggeti ed allocazione memoria

Salve a tutti.
E' la prima volta che scrivo in questo ng, mi chiamo Giueseppe, e sono 
studente di ing.Informatica.
Il mio dilemma è la gestione che il c++ fa della memoria per quanto riguarda 
gli oggetti.
Mi spiego:
class provola{
    public:
        provola(){cout<<"eccomi!"<<endl;}
        int pippo(){return 0;}
        void tizio(){};
        ~provola(){cout<<"NOOOO"<<endl;}
    private:
        int privato1;
        int privato2;
    };
Questo è un codice di una classe di prova...Adesso quando eseguo 
un'istruzione del tipo:
           provola x;
cosa succede?
Dov'è che il mio oggetto viene allocato?
In area Heap, stack, o dati statici?
Ho letto che un oggetto ha una "parte base" allocata in area dati statici 
heap o stack, ed un' "estensione" allocata in area heapIl compito del 
costruttore è quello di allocare l'estensione dell'oggetto e ad ogni modo 
inizializzarlo...Mentre il distruttore ha il compito di deallocare questa 
estensione.Invece, per quanto riguarda allocazione e deallocazione della 
parte base di un oggetto esse avvengono con gli stessi meccanismi riservati 
ad una variabile ordinaria.
Ma se questo è vero ed ho ben capito, la domanda che mi sorge in mente 
subito è:che cosa rappresenta questa estensione?Cosa c'è dentro?E a cosa 
serve?
Ringrazio anticipatamente tutti, e scusate per il po' di confusione che ho 
in testa!
Buona serata
Giuseppe 

 serve?
Mai sentito parlare di estensioni...
Andrea Sini

 con gli stessi meccanismi riservati ad una variabile ordinaria.
uhm... e' un modo complicato per spiegare una cosa semplice.
Le variabili automatiche (per es. le variabili locali nelle funzioni o
negli scope piu' interni) vengono allocate sullo stack: create quando
si "entra" nella funzione (o nello scope in generale) e distrutte
automaticamente quando se ne esce. Poiche' l'ingresso/uscita dagli
scope avviene in maniera fifo, la memoria necessaria per queste
variabili viene gestita efficientemente con una pila.
es:
int f() {
  // stack: [ ]
  int x;  // stack: [ x ]
  {
     int y; //  stack: [ x , y ]
  }
  // stack: [ x ]
  int z;
  // stack [ x, z ]
  ...
  // all'uscita, stack [ ]
}
Le variabili istanziate tramite new (ed esplicitamente cancellate con
la delete) vengono invece allocate sullo "heap", in questo caso
l'ordine di creazione e distruzione puo' essere arbitrario e la
struttura a pila non e' utilizzabile (quindi la memoria non viene usata
sequenzialmente ma "a saltare").
Ora, una classe puo avere dei membri dati "automatici" ed altri
allocati dinamicamente (con la new nel costruttore). Probabilmente
quello che hai letto si riferiva a questo.
I membri della "parte base" (strana terminologia, mai sentita) sono
quelli per cosi dire automatici e l' "estensione" sono i membri
allocati dinamicamente.
Per esempio considera la seguente classe:
classe Prova {
  int   num;
  int  *pun;
 public:
  Prova() { pun = new int; }
  ~Prova() { delete pun; }
};
se la classe e' istanziata come variabile automatica, viene presa dallo
stack la memoria necessaria a contenere i dati, in questo caso un
intero e un puntatore.
Poi viene chiamato il costruttore, che alloca dallo heap la memoria per
il secondo intero.
int f() {
  Prova p;
}
quando l'oggetto esce dallo scope, viene chiamato il distruttore che
libera la memoria allocata dallo heap, e infine viene liberata anche
quella dello stack (il puntatore allo stack ,cioe' torna al punto di
partenza).
Nota pero' che se p viene allocato dinamicamente entrambe le parti
vengono prese dallo heap:
int g() {
  Prova *p = new Prova();
  delete p;
}
in questo caso viene prima allocata la memoria per i dati (sempre un
int e un puntatore) e poi il costruttore alloca la memoria per il
secondo int.
Le delete libera entrambe (invocando prima il distruttore e liberando
poi il resto).
Saluti,
Fabio

 studente di ing.Informatica.
...Cut[]...
Prima di tutto,grazie ad entrambi per la pronta risposta.Effettivamete il 
libro che uso(da c++ a UML di C.Savy) č un po'(per essere generosi) scritto 
in maniera artificiosa.
Adesso comunque credo di aver capito:
per "parte base" si intende tutte le variabili(della classe) allocate 
staticamente nello stack
per "estensione" si intende utte le variabili(della classe) allocate 
dinamicamente nello heap.
il costruttore oltre a inizializzare le variabili si occupa anche 
dell'alocazione di memoria nell'area heap(estensione), mentre il distruttore 
si occupa della deallocazione della memoria allocata per l'estensione della 
classe.La parte base inoltre sarą allocata anch'essa in area heap nel caso 
si utilizzino gli operatori dinamici new e delete, ed allora anche per la 
parte base( e qui nutro ancora qualche dubbio) provvederą il costuttore ed 
il distruttore, per allocarla e deallocarla.
Spero di non aver detto troppe cavolate.
grazie ancora e buon week-wend a tutti!
Giuseppe 

 Spero di non aver detto troppe cavolate.
però anche io non ho mai sentito questa terminologia di BASE ed 
ESTENSIONI. Se consideri che un'istanza può risiedere 
completamente sparsa in pezzi dello heap, e non avere un solo 
byte sullo stack, la dicitura "base" pare fuorviante
ciao
cccp++mario


 classe.
Per la precisione: *tu* devi scrivere il costruttore e il distruttore in 
modo che si occupino *correttamente* dell'allocazione e della 
deallocazione della memoria che *tu* hai deciso di allocare per motivi
ben approfonditi in sede di progetto della classe stessa; di solito è 
meglio ricorrere a classi di libreria che implementino il paradigma 
Resource Acquisition Is Initialization (RAII) piuttosto che manipolare 
direttamente la memoria nelle classi applicative.
Per parecchi usi applicativi, std::vector e std::map vanno più che bene.
Barone Frankenstein

 in testa!
E' vero hai un poco di confusione in testa :-)
Ti ho risposto solo per dirti che ho anche io ho quel libro e non è
malaccio ma va affiancato ad un buon testo tipo Thinking in C++ oppure
allo Stroustrup.
A proposito di thinking in c++ ce ne è anche una versione in italiano
del primo volume (si perchè sono 2 volumi) se può esserti di aiuto.
Ciao
__
Niente e nessuno al mondo potrà
ferrmarmi dal ragionare.