programmeur passant de C à C++, j'arrive pas à assimiler (this)
 
qq un pourrait-il m'expliquer de facon simple son role SVP ??

"this" représente le pointeur d'une instance de classe. On n'utilise ce terme que dans des fonctions membres ( aussi appelées méthodes) d'une classe. ( this n'a aucune signification dans une fonction n'appartenant à aucune classe).
 
Un des interets de "this", c'est par exemple  lorsque tu appelles une fonction quelconque dans ta classe et que tu as besoin de passer en parametre de cette fonction le pointeur sur une instance de ta classe , tu utilises alors "this".

je crois que je saisi le truc merci ... et je crois surtout que je vais devoir faire des exos dessus.
 
C'est assez frequent le This ??

Fréquent ? Non pas forcément dans le code mais il est forcément présent dans la tête du codeur puisque c'est l'objet intéressant quand on appelle une fonction membre non statique.

Pour schématiser (et simplifier beaucoup), une classe, c'est une structure C avec des fonctions (dites fonctions-membres, ou méthodes dans la terminologie objet).
 
De façon générale, les méthodes d'une classe sont là pour manipuler les objets (ou instances) de cette classe. Quand on appelle une méthode (on dit qu'on l'invoque), on appelle toujours une méthode sur une instance donnée.
Exemple, tu as une classe Date, dans laquelle une méthode "int annee()" est définie (dois-je préciser ce que cette méthode sans paramètre fait ? ).
 
Maintenant, dans ton programme principal, tu vas écrire :
    Date  aujourdhui;
 
    cout << "Nous sommes en l'an de grâce " << aujourdhui.annee();
Tu appliques la méthode annee() à l'objet aujourdhui.
 
Et la méthode annee(), comment elle fait pour retrouver l'objet sur lequel elle a été appliquée (cet objet appelé l'objet receveur), hein ?    
 
Ben avec this, précisément.
 
Note: Attention, this est un pointeur sur l'objet receveur. Donc tu accèdes à l'objet par *this, et à ses champs-membres (à ses attributs) par this-> .... Comme pour tout pointeur qui se respecte, quoi...  

Je sais que ce n'est pas une convention très courante, mais moi, dans mes programmes C++, j'ai l'habitude de toujours accéder aux attributs de ma classe en utilisant explicitement this.  
 
Ca permet de savoir tout de suite où a été déclaré l'identifiant qui suit, et de le différencier d'un seul coup d'oeil des variables locales et globales. Idem pour les appels de méthodes, ce qui permet de distinguer facilement les appels aux méthodes de la classe courante des appels à des fonctions C classiques.
 
Vous allez me dire pourquoi faire, tout ça : tout simplement pour pouvoir savoir où chercher quand il s'agit d'aller retrouver où est-ce que ce maudit identifiant a été déclaré et/ou défini... (et quand il s'agit de déboguer du code que quelqu'un d'autre a écrit, c'est méchamment utile...)

je crois saisir encore un peu plus la chose/
 
mais imaginons
 
 class date{
private:
int annee;
int mois;
int jour;
public:
int date::annee()
{
return annee;
}
}aujourdhui;
 
void main(void)
{
cout << aujourdhui.annee();
}
 
ca va bien me donner l'année mais je vois pas ou intervient this ici !!
 
 
j'suis bete ? ou ai je loupé un chapitre de mon bouquin ?

en fait le this est implicite et dans la pratique l'ajouter sert surtout à améliorer la lisibilité du programme (il prend tout son intéret pour le compilateur mais là n'est pas la question)
 
ex :
 
class Silly{
  int bob;
public :
  int getbob();
}
 
int Silly::getbob(){
  return bob; //equivalent à return this->bob
}
 
void main(){
  Silly s;
//...
  cout<<"bob ="<<s.getbob()<<"\n";  
//...
}
 
si implicitement this n'était pas passé à getbob
la fonction n'aurait aucun moyen d'accéder aux attributs de l'objet qui l'appelle
D:D:D:D:D:D:D:D:D:D:D:D:D

Je vais réécrire un poil ta classe, si tu permets :
 
class Date {  
    private:  
        int annee;  
        int mois;  
        int jour;  
 
    public:  
        int annee();
};  
 
int Date::annee()
{
    return this->annee;
}
 
void main(void)  
{
    Date aujourdhui;
 
    cout << aujourdhui.annee();  
}

>en fait le this est implicite et dans la pratique l'ajouter  
>sert surtout à améliorer la lisibilité du programme (il > prend tout son intéret pour le compilateur mais là n'est pas
> la question)  
 
hum... pas du tout d'accord avec toi...
 
Le 'this' n'est pas fait que pour le compilateur. Regarde par exemple comment est écrit le constructeur de recopie d'une classe...
Ya évidement plein d'autres cas ou tu ne peux pas t'en passer (je pense notament a un objet O1 qui va créer un autre objet o2, et qui doit lui passer un pointeur a la construction pour que cet objet o2 puisse par la suite appeler une méthode publique de O1).
 
Donc même si c'est vrai qu'on peut souvent se passer de 'this' dans le code, il n'est pas fait que pour le compilo, loin s'en faut...

j'ai dit : "l'ajouter sert SURTOUT à améliorer la lisibilité du programme " mais je n'ai pas dit qu'il ne servait qu'à ça, son utilisation est très rarement obligatoire c tout, mais je n'ai pas dit qu'elle nétait jamais obligatoire !!!!!
 
:hot::hot::hot::hot::hot::hot:

cimer !!!! j'viens de comprendre MERCI à tous !!!!              

Sinon un des coup classique d'utilisation de this c'est dans les listes chainées d'objets.
chaque objet liste a un pointeur sur un objet et un pointeur sur un objet liste éventuelle.
 
class liste
{
public:
  //proprietes
  liste *next;
  void *obj;
  //constructeurs
  liste(void *o):next(NULL),obj(o){}
  //methodes
  liste *addItem(void *o)
  {
    liste *newLst=new liste(o);
    newLst->next=this;
    return newLst;
  }
};
 
Sinon en ce moment je m'en sert dans mes algo de collision pour un p'tit jeux. la balle détecte la collision mais la réaction est différente suivant l'objet rencontré donc chaque methode de gestion des collisions recoit un pointeur sur la balle.
La balle detecte la collision avec un objet et passe le pointeur this a l'objet qu'elle a rencontré pour le traitement.

Beurk des "void *", c'est pas c++ ça, les templates c'est pas pour les chiens
Et pis il y a les listes de la STL.

Roswell :
 
okok, ... juste une chose, ici ton this represente quelle liste .. celle qui vient juste d'etre cree (new liste(o) ) ou celle qui a appelé addItem ???

hum : je dirais que this pointe vers la liste qui lance addItem et que celle-ci est copié dans la nouvelle liste...
 
c'est ça ?
 
un peu comme un arbre (ou liste)
     A
    / \
   B   D
  / \ / \
 C
/ \

la viper> Attention à ne pas tout confondre. Une liste est une structure à une dimension :
   A -- B -- C -- D
Chaque noeud a un seul noeud suivant (une seule cellule suivante, si vous préférez le terme de cellule. Ou éventuellement zéro, quand c'est le dernier noeud de la liste).
 
Ce que tu as dessiné est un arbre (tu as remarqué qu'il était à 2 dimensions....). En l'occurrence, ici, c'est un arbre binaire, c'est-à-dire que chaque noeud a deux noeud suivants (en général, on parle d'ailleurs plutôt de 2 noeud fils ou 2 cellules filles, car on s'y retrouve plus facilement).
 
Donc:
    class List {  
       List*  next;  
       void*  obj;  
        ...
    }
ça, c'est une liste.
 
    class BinaryTree {  
       BinaryTree*  left;  
       BinaryTree*  right;  
       void*        obj;  
        ...
    }
Et ça, c'est un arbre binaire.

Verdoux a écrit a écrit : Beurk des "void *", c'est pas c++ ça, les templates c'est pas pour les chiens Et pis il y a les listes de la STL.

Ouaip. Sauf que même si c'est souvent une bonne idée de ne pas réinventer la roue, il y a des structures de données qu'il fait toujours bon savoir (ré-)implémenter...  

la viper>
le this désigne l'objet liste qui a appelé addItem.
Cet objet n'est pas vraiment une liste c'est plutot comme l'a dit BifaceMcLeOD une cellule qui à un pointeur sur un objet et un pointeur vers éventuellement une autre cellule.
 
Mais comme on garde le pointeur (addItem renvoie liste *) sur la premiere cellule, on peut bien récuperer tout les autres cellules qui forment ta liste.

oki doky !
 
merci à tous ...
 
au plaisir de vous relire dans un autre topic