Discussion :

[gooze]

Bonjour,

J'ai une question toute simple et assez basique. Quelle est la différence entre déclarer un variable avec l'opérateur new ou pas.

mon_type variable;

ou

mon_type* pt = new mon_type();

L'un alloue la mémoire dynamiquement et retourne un pointeur, mais concrêtement dans quel cas utiliser plus l'un que l'autre? Dans les deux cas le compilateur va voir le constructeur de la classe si je ne me trompe pas et l'utilisation de l'objet ne change pas vraiment dèrrière (à part utiliser -> ou . pour accéder les attributs).

Merci

[KorWipe]

La version avec new va créer l'objet dans la mémoire dynamique. Cela implique que :

• la création de l'objet est plus lente due à l'allocation dynamique (appel de l'opérateur new)
• c'est au programmeur de gérer la durée de vie de l'objet, en gros ne pas oublier le delete

La version sans new va créer l'objet sur la pile. Cela implique que:

• la mémoire est réservé automatiquement par le compilateur, donc pas de perte de temps d'allocation dans ce cas (attention au stack overflow tout de même !!)
• l'objet est automatiquement détruit dès lors que l'on sort du scope de la variable, le programmeur n'a rien à gérer pour cela

[ram-0000]

Un petit complément quand même, l'usage de l'allocation dynamique trouvera son sens quand on ne connait pas la quantité de mémoire à réserver lors de la compilation.

Exemple, un programme qui veut gérer les élèves d'une classe va demander au tout début le nombre d'élèves de cette classe. Comme ce nombre d'élèves n'est pas connu à la compilation mais demandé à l'utilisation, il faudra faire de l'allocation dynamique ou alors prévoir un tableau plus grand (500 ?) que ce qui est nécessaire et ce sera du gachis de ressources.

[gooze]

Super merci c'est beaucoup plus clair maintenant.

[Davidbrcz]

Exemple, un programme qui veut gérer les élèves d'une classe va demander au tout début le nombre d'élèves de cette classe. Comme ce nombre d'élèves n'est pas connu à la compilation mais demandé à l'utilisation, il faudra faire de l'allocation dynamique ou alors prévoir un tableau plus grand (500 ?) que ce qui est nécessaire et ce sera du gachis de ressources.

Sauf que cette gestion est faite implicitement par les outils que l'on se doit d'utiliser, tel std::vector

[koala01]

Il y a enfin un dernier cas de figure: l'utilisation d'objets polymorphes.

C'est à dire que tu veux faire passer un objet d'un type dérivé comme étant un objet du type de base.

Dans ce cas, tu déclares ton pointeur comme étant du type de base, mais tu l'alloue comme étant du type dérivé

Un petit code pour comprendre:

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
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class Base
{
    public:
        Base(){} // j'aurais pu ne pas le définir, vu qu'il ne fait rien ;)
        virtual ~Base(){} //obligatoire pour que la destruction d'une instance
                          // du type de base implique la destruction
                          // du type dérivé
        virtual void foo(); // comportement polymorphe
};
class Derivee : public Base
{
    public:
        Derivee(){} // comme pour le constructeur de Base
        virtual ~Derivee(){} // comme pour le destructeur de Base
        virtual void foo(); // comportement, connu de base, mais adapté à
                            // Derivee
};
int main()
{
    /* à titre didactique uniquement ;) */
    std::vector<Base*> tab; // un tableau d'objet que l'on fait tous passer
                           // pour des objets de type Base
    tab.push_back(new Derivee); //polymorphe
    tab.push_back(new Base); // comportement "de base"
    tab.push_back(new AutreDerivee); // qui hérite aussi de Base
    tab.push_back(new TroisiemeDerivee); // idem;
    /* appel des comportements adaptés au type réel */
    for(std::vector<Base*>::iterator it = tab.begin(); it!= tab.end();++it)
    {
        //la version appelée de foo() dépendra du type réel de l'objet et
        // sera donc celle de Derivee pour le premier élément
        // celle de Base pour le deuxième
        // celle de AutreDerivee pour le troisième
        // celle de TroisièmeDerivee pour le quatrième, et ainsi de suite
        // NOTA on ne peut invoquer que les méthodes qui sont déclarées
        // dans Base ;)
        (*it)->foo();
    }
    /*n'oublions pas de libérer correctement la mémoire */
    for(std::vector<Base*>::iterator it = tab.begin(); it!= tab.end();++it)
        delete (*it);
    return 0;
}