Newsgroup: it.comp.lang.c++
Titolo: Allocazione RAM

Sto studiando sul libro di Eckel e siccome non ho ancora raggiunto il 
capitolo dui template avrei bisogno di un chiarimento:
se scrivo il seguente codice:
vector<double> vettore;
for(int i;i<1000;i++)
    vettore.push_back(i);
ho un vettore di 1000 elementi double.
Quando lo voglio svoutare come faccio?
Se metto la seguente riga di codice:
vettore.clear();
la memoria attribuita al programma nel task manager non diminuisce: come 
mai? E'un problema di windows?
Per farla diminuire devo mettere la seguente riga di codice:
vettore.~vettore();
cioč il distruttore della classe.
Inoltre cosa cambia tra:
vector<double> vettore;
for(int i;i<1000;i++)
    vettore.push_back(i);
vettore.~vettore();
e
vector<double> *pvettore = new vector<double>;
for(int i; i<1000;i++)
    pvettore->push_back(i);
delete pvettore;
?
Da un punto di vista di allocazione della RAM per il task manager di windows 
sono uguali, cič mi segna un aumento della RAM allocata per il programma e 
poi un brusca diminuzione.
Inoltre entrambe le scritture sopra riportate lavora sullo heap, vero?
Grazie,
    Beppe.

 
No. Invocare in questo modo il distruttore su un oggetto automatico non è
lecito. Quando la variabile uscirà di scope il distruttore verrà invocato
nuovamente e gli effetti saranno (argh!) indefiniti. 
Il distruttore va invocato esplicitamente *soltanto* quando l'oggetto è
instanziato mediante placement new.
Max

 heap, vero?
Quando fai new, lavora sullo heap. Nell'interno, il vector se
serve solo di new, perche non sà a priori la sua durezza di
vita. I 2000 double son sempre sullo heap.
--
James Kanze                                           GABI Software
Conseils en informatique orientée objet/
                   Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, 
+33 (0)1 30 23 00 34

 Inoltre entrambe le scritture sopra riportate lavora sullo heap, vero?
No, l'oggetto vettore nel primo caso e' sullo stack, ma gli elementi che
contiene saranno probabilmente sullo heap.
Nel secondo caso invece, pvettore, il puntatore, e' sullo stack, ma
l'oggetto a cui punta, questa volta e' sullo heap e gli elementi che
contiene saranno probabilmente sullo heap.
Riassumendo, nel primo caso l'oggeto vector<double> e' sullo stack, nel
secondo caso nello heap.
Tornando al primo problema ed allo "swap trick":
<CODE>
#include<iostream>
#include<vector>
using namespace std;
void InformazioniSuVetInt(const vector<int> & v)
{
     cout  << "Numero elementi: " << v.size() 
           << " - Capacity: " << v.capacity() << endl;
}
int main()
{
     vector<int> v;
     int capacity = v.capacity();
     InformazioniSuVetInt(v);
     for(int i=0; i<1000; ++i)
     {
          v.push_back(i);
          if(capacity != v.capacity())
          {
               InformazioniSuVetInt(v);
               capacity = v.capacity();
          }
     }
     cout << "v.clear()" << endl;
     v.clear();
     InformazioniSuVetInt(v);
     cout << "Swap trick, Item 18 - Effective STL - Meyers:" << endl;
     vector<int>().swap(v);
     InformazioniSuVetInt(v);
}
</CODE>
<OUTPUT>
Numero elementi: 0 - Capacity: 0
Numero elementi: 1 - Capacity: 1
Numero elementi: 2 - Capacity: 2
Numero elementi: 3 - Capacity: 3
Numero elementi: 4 - Capacity: 4
Numero elementi: 5 - Capacity: 6
Numero elementi: 7 - Capacity: 9
Numero elementi: 10 - Capacity: 13
Numero elementi: 14 - Capacity: 19
Numero elementi: 20 - Capacity: 28
Numero elementi: 29 - Capacity: 42
Numero elementi: 43 - Capacity: 63
Numero elementi: 64 - Capacity: 94
Numero elementi: 95 - Capacity: 141
Numero elementi: 142 - Capacity: 211
Numero elementi: 212 - Capacity: 316
Numero elementi: 317 - Capacity: 474
Numero elementi: 475 - Capacity: 711
Numero elementi: 712 - Capacity: 1066
v.clear()
Numero elementi: 0 - Capacity: 1066
Swap trick, Item 18 - Effective STL - Meyers:
Numero elementi: 0 - Capacity: 0
Press any key to continue . . .
</OUTPUT>
Come puoi vedere man mano che gli elementi (uno alla volta) vengono
aggiunti, la capacity aumenta.
Quando inseriamo il 64o elemento la capacity passa da 63 a 94 e quando
inseriamo il 95 passa a 141.
Chiamando clear() il numero di elementi torna a 0, ma la capacity no!
Rimane a 1066.
Usando pero' lo swap trick di Meyers la capacity va a 0!
Lo swap trick di meyers si puo' chiamare al posto di v.clear(). In altre
parole ha due funzioni, quella di portare size a 0 e di ridurre la
capacity al minimo che l'implementazione consenta. Chiamare clear() poi
fare lo swap trick e' solo uno preco, ti basta fare lo swap trick.
Come con tutti i "trick" e "hack", e' indispensabile un bel commento
altrimenti scrivi e' come arabo!
vector<int> v;
...
... inseriamo 10000 elementi....
...
// Svuotiamo il vettore e riduciamo (possibilmente) a 0 anche la
capacity:
vector<int>().swap(v);     // vedi Item18 di Effective STL, Meyers 2001.
Ok, forse ho esagerato, ma l'importante e' non pretendere che colui che
legge il codice conosca quel trucco e capisca immediatamente cosa faccia
quella riga di codice!
Esiste anche una variante dello swap trick che cerca di eliminare la
capacity non utilizzata, ad esempio se hai 30 elementi e 500 di
capacity, cerca di portare la capacity a 30 (nota la parola cerca, non
e' garantito). Anche questo sta sul libro di Meyers, sempre item 18.
HTH,
Tommaso Galleri
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Grazie a tutti per le esaurienti risposte!
Scusate il ritardo ma mi si era bloccato il server delle news venerdě e poi 
sono stato via.