Discussion :

[gilloddon]

Bonjour,


Petite question spécifique au C++ et aux pointeurs. Je viens de m'apercevoir qu'un point n'était pas très clair dans ma tête.

Une de mes classes a en attribut plusieurs objets les initialise dans son constructeur, puis s'en sert dans d'autres méthodes.
Cette classe est la seule à se servir de ces objets en attribut, elle ne les passe jamais en paramètre à l'extérieur.

Actuellement, ces attributs était des pointeurs, mais si je ne devrais pas plutôt garder une valeur.
Du coup, est-ce que c'est mieux/moins bien de garder une valeur plutôt qu'un pointeur ? Qu'est-ce que ça change ?

Dans le destructeur, il faut que je fasse un delete sur le pointeur, mais sur une valeur, est-ce qu'il faut que je le fasse aussi ?


Merci d'avance.

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
 
    class CustomClass
    {
        public:
            CustomClass();
            virtual ~CustomClass();
 
            void operation();
 
            AnObject withoutPointer;
            AnObject *withPointer;
 
 
    CustomClass::CustomClass()
    {
        this->withoutPointer = AnObject();
        this->withPointer = new AnObject();
    }
 
    void CustomClass::operation()
    {
        this->withoutPointer.aMethod();
        this->withPointer->aMethod();
    }

[JolyLoic]

Si tu hésite entre pointeur et pas pointeur, prend la solution pas pointeur. En simplifiant un peu :

Avantages de référencement direct :
- Plus simple (pas besoin de détruire dans le destructeur, éventuellement pas besoin d'indiquer comment construire dans le constructeur),
- Plus performant (la mémoire est moins fragmentée, donc meilleure utilisation du cache).

Les pointeurs en donnée membre sont utiles si tu veux :
- Faire référence à un objet que tu ne possèdes pas (shared_ptr si la propriété est partagée, T* si la propriété est gérée par ailleurs),
- Ne pas connaître le type exact de l'objet possédé (unique_ptr sur une classe de base, mais qui pointe en fait sur une classe dérivée).

[gilloddon]

Merci pour ta réponse, qui est en plus très intéressante.

Quelques questions par rapport à tes remarques :
- A quoi correspond ton "T*" ?
- Pour toi, quelle est la différence entre "propriété partagée" et "propriété gérée ailleurs" ?



Du coup, mon exemple ci-dessous te semble correct ?
Ma classe CloudModule a un attribut FileManager, instancie un objet FileManager et l'utilise (le tout sans pointeur).
FileManager a besoin d'utiliser des méthodes et des attributs de la classe CloudModule, donc il a une référence de CloudModule : FileManager::setModule(CloudModule const &);

Vu que FileManager a besoin de certains attributs de CloudModule, c'est mieux si j'utilise une de tes solutions (T* ou shared_ptr) ou que je fasse un getter dans CloudModule pour que FileManager l'utilise ?

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
44
45
46
47
48
49
50
51
52
53
54
55
56
 
 
class FileManager
{
    public:
        FileManager();
        virtual ~FileManager();
        void setModule(CloudModule const &);
 
    protected:
        CloudModule const *module;
};
 
 
 
FileManager::FileManager()
{
 
}
 
FileManager::~FileManager()
{
 
}
 
void FileManager::setModule(CloudModule const & aModule)
{
    this->module = &aModule;
}
 
 
/* *************** */
 
class CloudModule
{
    public:
        CloudModule();
        virtual ~CloudModule();
 
    private:
        FileManager fileManager;
};
 
 
 
CloudModule::CloudModule()
{
    this->fileManager = FileManager();
 
    this->fileManager.setModule(*this);
}
 
CloudModule::~CloudModule()
{
 
}

[JolyLoic]

Par T*, je voulais dire un simple pointeur, par opposition à un pointeur intelligent comme shared_ptr ou unique_ptr.

Exemple de propriété partagée : chaque objet graphique possède une texture. Cette texture doit être détruite dès que plus aucun objet ne l'utilise. Mais on ne sais pas (et on n'a pas envie de savoir) quand ça arrivera. La propriété de cette texture est partagée entre tous les objets la possédant.
Exemple de propriété unique, mais gérée ailleurs : Chaque objet graphique fait référence à une texture, mais ne la possède pas. Il y a ailleurs dans le programme quelque-chose qui gère la durée de vie de ces textures, qui les possède. Par exemple, un gestionnaire de texture qui est chargé de toutes les détruire selon une stratégie qui est la sienne (par exemple, à chaque changement de niveau, quand le joueur est à une certaine distance d'un point...).

Je n'ai pas trop compris que que tu appelait un getter dans "CloudModule".

[gilloddon]

Je n'ai pas trop compris que que tu appelait un getter dans "CloudModule".

En gros, faire un getter pour chaque attribut dans la classe CloudModule devant servir dans la classe FileManager.
Je pense que je serais obligé de toute façon vu que je ne vais mettre les attributs de CloudModule en visibilité public.
Il faudra que je fasse des méthodes pour récupérer une référence ou un pointeur pour chaque attribut de la classe CloudModule, dans CloudModule.

[acx01b]

Si tu hésite entre pointeur et pas pointeur, prends la solution pas pointeur.

C'est le contraire de ce que fait Java et C# et javascript et tous les langages !!!!!!

Si tu hésites, programme les deux car ça veut dire que tu as besoin d'entrainement avec les structures de données en C/C++.

[JolyLoic]

C'est le contraire de ce que fait Java et C# et javascript et tous les langages !!!!!!

Certes (en première approximation, par exemple, c# possède des struct qui ne sont pas faits de la même manière). Et c'est pour ça que ces langages ne sont pas sélectionnés quand on recherche des performances.

[gilloddon]

Oui, c'est vrai qu'il faut que je manipule un peu plus les pointeurs pour mieux les maîtriser (je fais beaucoup plus de Java, C#, Objective-C que de C/C++). J'essaye tout de même d'utiliser aussi les références quand ça me semble plus logique, ça évite parfois les problèmes.


Merci pour vos réponses en tout cas.

[ternel]

Si tu as fais du java, justement, à chaque fois que tu donnes un objet en paramètre en java, c'est un pointeur (au sens C++):
il peut y avoir un null, l'objet passé est manipulé par son adresse (on dit par référence, en java comme en C)

[foetus]

Si tu as fais du java, justement, à chaque fois que tu donnes un objet en paramètre en java, c'est un pointeur (au sens C++):
il peut y avoir un null, l'objet passé est manipulé par son adresse (on dit par référence, en java comme en C)

En C, on manipule que pointeurs. Et donc le passage de paramètres c'est via pointeurs. En opposition au passage par copie.

Alors qu'en C++, il y a la notion de référence: le développeur manipule la variable, mais c'est le pointeur qui est utilisé "en interne"
Avec une contrainte forte: une référence ne peut pas être NULL (tout est fait pour, soit dit en passant)

[ternel]

On ne manipule pas que des pointeurs, il y a aussi le passage par valeur (ou copie), utilisé de base.
Si on tient à être pointilleux, les pointeurs (adresses) sont passés par copie, de même que les références.

Une nouvelle référence est initialisée avec le paramètre, devenant un alias de ce dernier.

[oodini]

C'est le contraire de ce que fait Java et C# et javascript et tous les langages !!!!!!

Ces langages n'ont pas pour les pointeurs la syntaxe lourde du C++, et disposent d'un ramasse-miettes.