Discussion :

[godskitchen]

Bonjour à tous,

En plein apprentissage du C++ j'en arrive au chapitre sur la gestion de la mémoire où l'on a introduit la classe allocator incluse dasn <memory>. On donne quelques fonctions de cette classe et j'ai du mal à comprendre la différence entre deux de ces fonctions.

voici à quoi ressemble une version simplifiée de cette classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
template<class T> class allocator {
public:
    // ...
    T* allocate(int n);            // allocate space for n objects of type T
    void deallocate(T* p, int n);  // deallocate n objects of type T starting at p
 
    void construct(T* p, const T& v); // construct a T with the value v in p
    void destroy(T* p);            // destroy the T in p
};

Quel est la différence entre deallocate et destroy au niveau de la mémoire ? D'après ce que je semble avoir compris, deallocate libère la mémoire pointé par p = et destroy libère les emplacements mémoire aux adresse où se trouve les pointeurs c'est à dire &p[i]. C'est bien ça ?

Merci d'avance

[Captain'Flam]

Difficile de répondre sans le code de la classe allocator, mais en tout cas :

allouer = réserver de la place sur le tas (heap) comme on peut le faire avec un vulgaire malloc (en C) => le système prend note que cette zone de mémoire t'appartient et n'y touchera pas tant que tu ne l'auras pas désallouée.

désallouer = rendre la place que l'on avait réservée => le système peut maintenant en faire ce qu'il veut (par exemple l'allouer à quelqu'un d'autre).

construire = appeler la constructeur d'un objet. Ce dernier n'est rien de plus qu'une fonction qui peut aller de ne-rien-faire à faire-des-tas-de-trucs-très-compliqués. Le constructeur ne peut (pratiquement) pas être appeler explicitement. C'est le compilateur qu'il la fait au moment de l'instanciation de ton objet.

détruire = appeler le destructeur d'un objet. Ce dernier est le pendant du constructeur. Il doit "nettoyer" l'objet avant que ce dernier ne disparaisse. par exemple, si ton objet a alloué de la mémoire, il faut la désallouer à ce moment là.

Le new est un opérateur C++ qui fait 2 choses : allocation + construction.
Par exemple : "std::string * s = new std::string ;" va allouer la place nécessaire à un objet de type std::string puis appeler son constructeur. Ce dernier va initialiser toutes les membres de ton s afin qu'il soit prêt à l'emploi.
"std::string s ;" ne fait pas d'allocation mais appelle seulement le constructeur.

[koala01]

Salut,

La différence est subtile en C++ parce que new (respectivement delete) a le double effet d'allouer l'espace mémoire nécessaire (respectivement de la libérer) pour stocker l'objet et de l'initialiser grâce à appel au constructeur(respectivement grace à un appel au destructeur).

Si tu ne fais pas appel à new, par exemple avec le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int main()
{
    MyClass obj(arg1,arg2);
}

l'objet est construit (sur ce que l'on appelle la pile) et existera "tant que l'on n'aura pas quitté la portée dans laquelle il est construit", mais tu n'auras pas forcément d'allocation de mémoire (au sens où on l'entend généralement), car la construction de ces membres peut ne pas nécessiter d'allocation de mémoire.

De même, lorsque tu quitte la portée dans laquelle obj est construit (comprend : lorsque tu arrive à l'accolade fermante correspondant à celle représentant le bloc dans lequel l'objet est construit), l'appel implicite au destructeur ne provoquera pas forcément de libération de mémoire (vu qu'il y a normalement symétrie entre le travail du constructeur et du destructeur).

Enfin, lorsque l'on parle d'allocation de la mémoire c'est essentiellement pour deux raisons possibles:

1. Soit, c'est parce que l'on souhaites prendre le contrôle de la durée de vie de l'objet (vu qu'un objet créé par new ne sera détruit (et la mémoire qu'il utilise libérée) que lorsque l'on appellera explicitement delete sur le pointeur "pointant" vers l'objet)
2. soit, c'est parce que l'on souhaite pouvoir utiliser le polymorphisme et que l'on ne sait pas, à un instant T, quel sera le type exact de l'objet.

[godskitchen]

[*]soit, c'est parce que l'on souhaite pouvoir utiliser le polymorphisme et que l'on ne sait pas, à un instant T, quel sera le type exact de l'objet.[/LIST]

C'est précisément dans ce contexte que j'ai abordé ce problème. Précisément, dans le livre sur lequel j'apprend on essaye de reconstruire le conteneur vector de la STL. Pour cela on définit plusieurs fonctions dont une qui a la charge de réserver de la mémoire lorsqu'on en a besoin. Ma définition de classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
template<class T, class A = allocator<T> > class vector {
    A alloc;    // use allocate to handle memory for elements
    int sz;     // the size
    T* elem;    // a pointer to the elements
    int space;  // size+free_space
public:
    vector() : sz(0), elem(0), space(0) { }    
    vector(int s);
    vector(const vector&);            // copy constructor
    vector& operator=(const vector&); // copy assignment
    ~vector() { delete[ ] elem; }     // destructor
 
    void resize(int newsize, T def = T()); // growth
    void push_back(const T& d);
    void reserve(int newalloc);
};

Ma fonction reserve :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
template<class T, class A> 
void vector<T,A>::reserve(int newalloc)
{
    if (newalloc<=space) return;     // never decrease allocation
    T* p = alloc.allocate(newalloc); // allocate new space
    for (int i=0; i<sz; ++i) alloc.construct(&p[i],elem[i]); // copy
    for (int i=0; i<sz; ++i) alloc.destroy(&elem[i]);        // destroy
    alloc.deallocate(elem,space);    // deallocate old space
    elem = p;
    space = newalloc;    
}

Et c'est précisément ces 3 lignes là qui me pose problème :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
for (int i=0; i<sz; ++i) alloc.destroy(&elem[i]);        // destroy
alloc.deallocate(elem,space);    // deallocate old space
elem = p;

Après chaque ligne, que se passe-t-il précisément dans la mémoire ? Et comment se fait il que nous puissions encore manipuler elem après l'avoir détruit ?

[koala01]

Non, le cas présent représente une troisième raison "classique" (que l'on évite au maximum grace, entre autres, aux classes fournies par la STL, pour de simples histoires de sécurité et de facilité) : parce que l'on ne connait pas, au moment où l'on écrit le code, le nombre exact d'objet que l'on devra gérer

L'idée ici est de se dire que l'on va devoir gérer "un nombre inconnu" d'objets (de type connu, même si c'est un type générique, et donc dont la taille est aussi connue ) et qu'il faut s'assurer de "ne rien perdre" (que ce soit en espace mémoire ou en terme d'éléments stockés dans la classe) lorsque l'on va devoir augmenter la taille du vecteur.

On commence donc par allouer un espace mémoire suffisant pour pouvoir représenter "newalloc" élément.

Puis on passe en revue tous les éléments déjà présent dans le vecteur et on les copie à leur nouvelle place (de l'invocation de construct dans la boucle for)
Pour etre sur que les éléments qui se trouvent dans "l'ancien espace que l'on a utilisé", soient correctement détruit (et que l'espace mémoire nécessaire à leur maintient en mémoire soit correctement libéré), on invoque ensuite destroy sur chacun d'eux (c'est le but de la boucle en question )

On termine en prenant "newalloc" et "p" comme nouvelles valeur de référence

Si tu as ne serait-ce qu'un tout petit peu travaillé en C, c'est un fonctionnement dont tu es sans doute coutumier (à coup de malloc et de free + copie de valeurs )

[godskitchen]

Je te remercie. Tout devient clair à présent. Et non je n'ai pas trop travaillé en C. Je connais les bases, mais je n'ai pas beaucoup pratiqué.

Merci !