Discussion :

[Panaméen]

Bonjour,

J'ai une classe , qui s'appelle B on va dire ...
Elle a un attribut de type char *toto ...

Dans une methode de la classe B, quon appelera test , je fais un alloc , pour allouer un espace de 10 caracteres par exemple.

suite a ca je stocke dans cette derniere "123456789" , ridicule je sais mais bon

puis fin de la methode ...

Ma question , ou et quand libere on la memoire ?

A la fin de ma methode test ? toto ne contiendra donc plus "123456789" ?
ou a la prochaine initialisation si la taille du char * change ?

[nikko34]

La réponse n'est pas simple du tout et dépend aussi de l'utilisation que tu veux faire de ta classe.

C'est pour cela qu'en C++ on utilise des std::string pour gérer les chaînes de caractères et non des char*.

Code :

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

1
2
3
4
5
 
class A
{
   std::string toto_;
};

et tout est libéré/alloué quand il le faut.

[koala01]

Salut,

Si tu te mets bel et bien dans le contexte d'une classe (ou d'une structure) qui dispose d'un champs qui est en réalité un pointeur sur quelque chose que tu alloues de manière dynamique (mais de préférence avec new, et non avec malloc), la libération de la mémoire doit se faire - en dehors des cas où la durée de vie du membre doit être indépendante de la durée de vie de l'élément qui le contient - dans le destructeur.

Cependant, il y a alors lieu de prendre quelques précautions, car tu pourrait en arriver à la situation suivante qui serait catastrophique:

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
17
18
19
class MaClass
{
    public:
        /* le constructeur */
        MaClass(size_t size):size(size)
        {
            member = new Type[size];
        }
        /* nous ne déclarons ni le constructeur de copie ni l'opérateur
         * d'affectation... Le résultat est que le compilateur en crée qui
         * prennent une implémentation par défaut dangeureuse
         */
        ~MaClass()
        {
            delete[] member;
        }
    private:
        Type* member;
}

utilisée dans le contexte suivant:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void foo()
{
    MaClass  mavar(10); //création "normale" de la variable
    /* ... quelques linges plus loin, dans un bloc, par exemple, dans un test */
    if (test)
    {
        MaClass c2 = mavar /* DANGER, tout semble aller bien mais */
    }    // c2 est détruit ici
   /* hors, l'adresse pointée par mavar.member est la meme que celle
    * pointee par c2.member
    */
 
} // BOUM... la mémoire allouée à maclass.member a été libérée
  // lorsque l'on a détruit c2...

Tu dois donc veiller, selon le cas, à

• rendre ta classe non copiable et non assignable (ce qui est sans doute la solution qu'il faut envisager en premier)
• veiller à ce que la copie et l'assignation fassent de manière à ce que member ne pointe pas deux fois sur la meme adresse (ce qui sous entend d'allouer de la mémoire pour le membre de l'objet "copie")
• utiliser un "compteur de références" capable de vérifier que la mémoire ne soit libérée que lorsque la dernière occurence de la variable est détruite
• utiliser un type de pointeur dit "intelligent" tel que, par exemple, le shared_ptr

[3DArchi]

Bonjour,
Tu peux regarder du côte de la FAQ ou encore ce tuto sur les pointeurs. Je pense que ces éléments pourront participer à ta réflexion sur la gestion des pointeurs.