Discussion :

[Core8]

Bonjour à tous,

J'ai toujours été habitué à mettre les this même quand ce n'est pas nécessaire. Dans le code suivant je voudrais savoir si le fait de laisser le this à un quelqueconque désavantage ou non.

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
class mere {
	...
	void affiche(...){
		...
	}
};
 
class fille : public mere {
	...
	void methode(...){
		this->affiche(...);
	}
	...
};
 
int main(){
	Fille f(...);
	f.methode(...);
	return 0;
}

C'est un exemple qui n'est pas forcément logique, c'est juste pour montrer si dans un cas similaire le this est utile.

Merci d'avance

[Laurent Gomila]

Dans ce cas-là ça ne fait strictement aucune différence.

[Core8]

Merci Laurent Gomila de ta réponse donc je vais les laisser.

[koala01]

Salut,

Le pointeur this n'est, en définitive, qu'un pointeur... sur l'instance de l'objet en cours d'utilisation...

Une sorte de "rappel" de l'objet qui travaille, si tu préfères

Hormis le fait de permettre aux éditeurs un tant soit peu corrects de retrouver les différents membre de la classe en cours, quand il s'agit d'utiliser un membre ou une fonction membre de la classe elle-meme, l'utilisation de this-> ne présente, comme l'a dit Laurent, que peu d'intérêt...

Par contre, il existe quantité de fonctions qui nécessitent d'avoir un pointeur (ou une référence) sur une instance d'objet bien précise comme argument...

C'est dans ces cas là que le pointeur this trouve toute son utilité, sous la forme de

Code :

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

1
2
3
UneFonctionHorsClasse(this);
// OU---OU---OU sous forme de référence
UneFonctionHorsClasse(*this);

Un exemple raisonnable est la création d'une arborescence dont chaque noeud voudrait avoir un rappel du noeud parent:

Code C++ :

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
class Noeud
{
    public:
        Noeud(Noeud* parent=NULL);//ne vaut NULL que dans un cas: c'est la
                                 //racine ;)
        ~Noeud();
        Noeud* CreateChild();
        Noeud* Parent();
        //autres méthodes qui vont bien
    private: 
        Noeud *m_parent;
        std::vector<Noeud*> m_children;
        //autres membres et méthodes qui vont bien
};
/* constructeur :
   @in: pointeur sur le noeud parent */
Noeud::Noeud(Noeud* parent):m_parent(parent)
{
}
/* destructeur */
Noeud::~Noeud()
{
    for(unsigned int i=0;i<m_children.size();i++)
        delete m_children[i];
    m_children.clear();
    m_parent=NULL;
}
/* Création d'un noeud enfant...
    C'est ici que this entre en jeu
    @out: pointeur sur le noeud créé
 */
Noeud* Noeud::CreateChild()
{
    //crée un nouvel objet de type noeud en fournissant this comme parent
    Noeud *nouveau=new Noeud(this);
    //ajoute le nouveau noeud à la liste des enfants
    m_children.push_back(nouveau);
    return nouveau;
}
/* Permet de retrouver le parent
    @out NULL si on est en racine d'arbre
         pointeur sur le parent autrement 
*/
Noeud* Noeud::Parent()
{
    return m_parent;
}

[JolyLoic]

Hormis le fait de permettre aux éditeurs un tant soit peu corrects de retrouver les différents membre de la classe en cours, quand il s'agit d'utiliser un membre ou une fonction membre de la classe elle-meme, l'utilisation de this-> ne présente, comme l'a dit Laurent, que peu d'intérêt...

Il y a des cas où l'écriture this-> est obligatoire (d'où je pense la précision "Dans ce cas-là" de Laurent). C'est en particulier une façon de rendre dans un template un nom dépendant de l'argument template.