56 lines (46 loc) · 1.95 KB

Allocation dynamique

Il est possible de gérer l’allocation de mémoire pour les variables, avec une portée qui dépasse le bloc.
C’est au programmeur de gérer la désallocation
Les opérateurs pour le faire sont:
- new
- new[]
- delete
- delete[]

Cela permet de :

Créer de très grosses variables
Créer une fonction qui retourne un objet sans le recopier

class Image {...};
Image & fabriqueImage (...) {
    // retourne une image par référence pour ne pas la copier 
    Image resultat;
    ... // traitements
    return resultat; /* ERREUR retourner une référence sur une variable locale qui meurt a la fin de la fonction */
}
// Solution : allocation dynamique

class Image {...};
    Image * fabriqueImage (...) {
        // retourne une image par pointeur pour ne pas la copier 
        Image * ptrImage = new Image;
        ... // traitements
        return ptrImage; /*OK , la mémoire allouée n’est pas libérée à la fin
            de la fonction, l’image n’est pas perdue */
    }
    Image * uneImage = fabriqueImage ();

Attention, dans cet exemple, la désallocation de la mémoire n’est pas gérée.
La solution d’utiliser des pointeurs doit amener à être vigilant aux fuites mémoires. Le mieux est d’utiliser des pointeurs partagés (ou “shared pointers”) qui gèrent automatiquement la désallocation de la mémoire (cf. Boost et TR1)
On peut stocker plusieurs objets sous forme de tableau, dont la taille sera connu qu’à l’exécution

int n = 50;
double * tableau = new double [n]; // la taille peut être définie a l’exécution 
for (unsigned int i = 0; i<n; ++i){ 
    tableau [i]=i; // on manipule le tableau
}
delete [] tableau ; // on libère la mémoire

Ne pas oublier les crochets pour désallouer un tableau
En général, il vaut mieux utiliser les conteneurs de la STL (comme Vector) pour les tailles variables