Discussion :

[mathieupicard]

Bonjour a tous,
Je termine ma première session en programmation c++ et je dois remettre un travail dont l'un des numéro me cause beaucoup de problème.

citation du travail pour mettre dans le contexte:" Écrire un programme qui utilise le mot-clé THIS dans la gestion d'une liste chaîné de 20 objets de même nature."

J'ai plancher pas mal sur la partie liste chaîné et grâce a de l'aide je suis arriver à faire le code suivant qui est une liste doublement chaîné du moins sa fonction. voici le code:

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
57
58
59
60
61
62
#include <iostream>
#include <stdlib.h>
 
using namespace std;
 
struct Element
{
    int valeur;
    Element* precedent;
    Element* suivant;
};
 
Element* premier = NULL;
Element* dernier = NULL;
 
void Ajouter(int valeur)
{
    //Créer l'élément.
    Element* element = new Element;
    //Vérifier s'il y a un premier élément dans la liste.
    if(dernier == NULL)
    {
        Element* dernier=element;
    }
    //L'élément créer devient l'élément précédent du premier élément de la listeactuel.
    if(premier!=NULL)
    {
        premier->precedent=element;
    }
    //L'élément est placé en début de liste, le premier élément devien le suivant de cette élément.
    element->suivant=premier;
    premier=element;
    //Le nouvelle élément est le premier de la liste donc, précédent est null.
    element->precedent=NULL;
 
    element->valeur=valeur;
}
 
void Afficher()
{
Element* element = premier;
while(element != NULL)
{
cout << element->valeur << "\t";
element = element->suivant;
}
cout << endl;
}
 
int main()
{
    cout << "Hello world!" << endl;
    Element* e;
 
    for(int i=1; i<=20; i++)
    {
        Ajouter(i);
    }
 
    Afficher();
    return 0;
}

Mon nouveau problème est que THIS est très simplement expliquer dans mon manuel du genre this est un pointeur sur objet et *this est l'objet lui-même. HA! oui y a pas vraiment plus que sa comme explication donc je vois pas pourquoi on l'utilise vraiment et comment je pourrais non plus l'inclure dans une fonction de mon code pour remplir les exigence de l'exercice. Sur le net, j'ai lu pas mal et je trouve jamais de texte qui en parle clairement comme on parle des variable ou tableau oû là le texte est très claire et les exemples aussi. Je ne demande pas à ce que l'on me termine mon TP, mais bien à ce qu'on m'ouvre l'esprit à comprendre ce que je ne vois pas ou comprend pas.

merci à ceux qui prendront le temps de aider

mathieu

[dalfab]

Bonjour,
L'exemple que tu donnes est essentiellement du code C même s'il peut compiler en C++.
Pour comprendre this, il faut d'abord créer un Objet. Les méthodes de cet objet pourront utiliser this.
Exemple :

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 MonObj
{
public:
   MonObj( int z ) { x = z; }
   int  x;
   void affiche();
};
void MonObj::affiche() {
    std::cout << this->x;   // affiche la valeur de x (1 s'il s'agit de var1, 2 s'il s'agit de var2)
    std::cout << x;         // le même x, pas besoin d'utiliser this
}
int main() {
   MonObj var1( 1 );
   MonObj var2( 2 );
   std::cout << var1.x;      // affiche 1
   var1.affiche();           // affiche 11
   var2.affiche();           // affiche 22
   std::cout << this->x;     // erreur, on est dans main() pas dans une méthode de MonObj
}

Tous les objets du type MonObj auront une variable appelée x, chacun la sienne. Pour un objet var1, on pourra faire var1.x pour accéder à x. A l'intérieur des méthodes de l'objet on pourra faire this->x, this désigne alors l'objet qui vient d'être appelé.

[Bousk]

Salut,
ta définition est correct, et à vrai dire y'a pas grand chose à en dire de plus... c'est juste ça : c'est l'objet lui-même. Ca te donne l'adresse de lui-même, pour le passer en paramètre typiquement.
Par exemple, pour l'exercice classique de la liste chaînée, tu peux avoir

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct Maillon {
  Maillon* prev;
  Maillon* next;
  Maillon(Maillon* _prev = nullptr)
    : prev(_prev)
    , next(nullptr)
  {}
  // this en paramètre
  Maillon* NewNext() { Maillon* n = new Maillon(this); return n; }
};
Maillon* maillon1 = new Maillon;
// maillon1 en paramètre
Maillon* maillon2 = new Maillon(maillon1);
Maillon* maillon3 = maillon2->NewNext(); // identique à maillon3 = new Maillon(maillon2);

[bacelar]

En plus du cas d'utilisation illustré par @Bousk, il reste le cas qui sert à résoudre une ambiguïté.
On utilise très peu "this" car il est implicitement utilisé par défaut.
Quand un nom "toto" est utilisé comme identifiant de variable, le compilateur cherche à voir s'il y a une variable locale ou un paramètre avec ce nom, si oui, il l'utilise, sinon, il regarde s'il existe un champ avec ce nom, si oui, il l'utilise, sinon, etc... (global tour ça tout ça).

Si un paramètre porte le même nom qu'un champ de l'objet, pour indiquer que l'on veut utiliser le champ et non le paramètre, il faut préfixer le nom de la variable par "this->".

Exemple :

Code :

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

1
2
3
4
5
6
7
8
class A
{
     int x;
 
public :
    A(int x):x(x){}
    setX(int x){this->x = x;}
}

[mathieupicard]

Pour commencer merci pour votre aide!

-J'ai fais quelques changement dans mon code. J'ai changer struct pour class avec quelques adaptations, sa marche mais je suis pas sur que ce soit politiquement correct.
-J'ai utiliser le this dans une méthode quoi que c'est plus pour répondre au exigence du travail. Je croix que ce mot va m'en faire baver pas pire car, si j'ai bien compris c'est juste plus lisible comme code mais pas essentiel.

Je vous montre ce que sa donne comme code:

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
#include <iostream>
#include <stdlib.h>
 
using namespace std;
 
class Element
{
    public:
        int Ajouter(int valeur);
        void Afficher();
        Element* Recherche(int valeur);
        void Supprimer(Element* element);
 
    private:
        int valeur;
        Element* precedent;
        Element* suivant;
};
//convertie la structure en class
/**struct Element
{
    int valeur;
    Element* precedent;
    Element* suivant;
};**/
 
Element* premier = NULL;
Element* dernier = NULL;
 
int Element::Ajouter(int valeur)
{
    //Créer l'élément.
    Element* element = new Element;
    //Vérifier s'il y a un premier élément dans la liste.
    if(dernier == NULL)
    {
        Element* dernier=element;
    }
    //L'élément créer devient l'élément précédent du premier élément de la listeactuel.
    if(premier!=NULL)
    {
        premier->precedent=element;
    }
    //L'élément est placé en début de liste, le premier élément devien le suivant de cette élément.
    element->suivant=premier;
    premier=element;
    //Le nouvelle élément est le premier de la liste donc, précédent est null.
    element->precedent=NULL;
 
    element->valeur=valeur;
    return this->valeur;
}
 
void Element::Afficher()
{
Element* element = premier;
while(element != NULL)
{
cout << element->valeur << "\t";
element = element->suivant;
}
cout << endl;
}
 
Element* Element::Recherche(int valeur)
{
    Element* element = premier;
    //On commence par le premier élément et tant qu'il y a un élément suivant on continue.
    //Jusqu'à ce qu'on trouver l'élément voulu.
    while(element !=NULL && element->valeur !=valeur)
    {
        element=element->suivant;
    }
    //on retourne l'élément trouvé.
    return element;
}
 
void Element::Supprimer(Element* element)
{
    Element* precedent = premier;
    //Si l'élément a suprimer est le premier.
    if(element == premier)
        {
            premier = NULL;
            delete element;
            return;
        }
    //Sinon  il faut trouver l'élément précédent pour changer son pointeur suivant
    while(precedent != NULL && precedent->suivant != element)
    {
         precedent = precedent->suivant;
    }
 
    if(precedent == NULL)
    {
        return;
    }
 
    precedent->suivant = element->suivant;
    delete element;
}
 
int main()
{
    cout << "Liste cha\x8cn\x82 " << endl;
    //Création de l'objet.
    Element a;
    Element* e;
 
    //Boucle pour obtenir 20 éléments.
    for(int i=1; i<=20; i++)
    {
        a.Ajouter(i);
    }
    //Afficher les éléments
    a.Afficher();
    //Choisir, trouver et supprimer un élément.
    cout<< "rechercher une valeur \x85 supprimer: ";
    int x;
    cin >> x;
    e = a.Recherche(x);
    a.Supprimer(e);
    cout << "Nouvelle liste cha\x8cn\x82" << endl;
    //Afficher les éléments
    a.Afficher();
 
    return 0;
}

J'ai essayé de créer un ficher class (si je dit sa de la bonne manière) Element.h mais, je ne sais pas ou aller mettre ces deux ... de ligne de code :

Code :

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

1
2
3
 
Element* premier = NULL;
Element* dernier = NULL;

J'aime bien apprendre, alors hésité pas pour critiquer ou me donner des conseils sur mon travail.

[bacelar]

J'ai l'impression que vous mettez la charrue avant les bœufs.

Vous vous fixez sur le mot-clés "this" mais vous n'avez toujours pas les bases de la POO (Programmation Orientée Objet).
Avec de bonne base en POO, le concept derrière "this" vous serait plus évident.

Votre code montre que vous ne maitrisez pas du tout la POO.
Sinon, vous n'auriez pas fait des fonctions "Ajouter", "Recherche", 'Supprimer" des fonctions d'instance de la classe "Element".
Quel que soit les détails d'implémentation, l'interface de la classe doit être logique.
On ne demande pas à un élément d'ajouter un autre élément, ni d'en rechercher un autre ou de s'autodétruire.
Il faut séparer la classe Element de la gestion de list.

En C++, il y la STL, qui offre une classe paramétrée list<T>.
En séparant les 2 aspects, Element n'est qu'un int.
Donc, vous n'avez pas besoin de faire une classe mais juste utiliser la classe list<T>, qui vous offrira une interface d'utilisation bien plus cohérente que celle que vous avez conçue.

si j'ai bien compris c'est juste plus lisible comme code mais pas essentiel.

C'est totalement faux. On ne l'utilise surtout pas pour la lisibilité mais uniquement quand c'est nécessaire.
- Pour passer l'objet en paramètre d'une fonction/méthode d'un autre objet ou d'une fonction libre.
- Pour accéder à un champ de l'objet quand une variable locale ou un paramètre ont le même nom.

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
 
#include <iostream>
#include <stdlib.h>
#include <list>
 
int main()
{
    std::cout << "Liste cha\x8cn\x82 " << endl;
 
    //Création de l'objet.
    std::list<int> a(20);
 
    //initialisation des int
    std::iota(a.begin(), a.end(), 1);
 
    //afficher la liste
    for(auto n: a) std::cout << n << '\t';
 
    //Choisir, trouver et supprimer un élément.
    std::cout<< "rechercher une valeur \x85 supprimer: ";
    int x;
    std::cin >> x;
 
    a.remove(x);
 
    std::cout << "Nouvelle liste cha\x8cn\x82" << endl;
 
    //Afficher les éléments
    for(auto n: a) std::cout << n << '\t';
 
    return 0;
}

[mathieupicard]

J'ai commencé y a 10 semaine le cours sur le c++ à l'université par cours a distance. Le code :

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
struct Element
{
    int valeur;
    Element* precedent;
    Element* suivant;
};
 
Element* premier = NULL;
Element* dernier = NULL;
 
void Ajouter(int valeur)
{
    //Créer l'élément.
    Element* element = new Element;
    //Vérifier s'il y a un premier élément dans la liste.
    if(dernier == NULL)
    {
        Element* dernier=element;
    }
    //L'élément créer devient l'élément précédent du premier élément de la listeactuel.
    if(premier!=NULL)
    {
        premier->precedent=element;
    }
    //L'élément est placé en début de liste, le premier élément devien le suivant de cette élément.
    element->suivant=premier;
    premier=element;
    //Le nouvelle élément est le premier de la liste donc, précédent est null.
    element->precedent=NULL;
 
    element->valeur=valeur;
}

M'a été fournie par le charger de cours et j'ai fais avec sa. Tu me fais réaliser que j'ai mal compris le concept POO, va devoir plancher la dessus alors.

merci pour le commentaire et l'aide

[bacelar]

le charger de cours et j'ai fais avec sa

Non, sans déconner, c'est une blague ???

Ce code montre une complète ignorance du concept objet.

Pour moi, c'est de la transcription "petit nègre" C++, d'un truc fait à l'arrache en C.

Et C++ n'a plus grand chose à voir avec le C depuis fort longtemps.

Le code que je vous ai fourni est bien plus simple et fait exactement la même chose (dans les intentions, parce que le code fourni est trop complexe inutilement pour que je m'esquinte les yeux avec).

J'ai séparé la gestion de la liste d'objet du reste.
Et comme il s'agit d'une gestion de liste standard, j'ai pu utiliser une classe standard : "std::list<T>".
Pour la valeur, c'est un simple int => "std::list<int>".

Une transcription C++ de cette horreur, (j'ai converti l'utilisation des 2 variables globales bien moisies par l'utilisation d'un champs statique de classe, c'est pas top mais comme on n'a pas les axes de conceptions on fait dans le simple) :

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
 
struct Element
{
    int valeur;
    Element(int valeur):valeur(valeur){};
 
    static std::list<Element> ListeDesElements;
};
 
std::list<Element> Element::ListeDesElements = std::list<Element>();
 
void Ajouter(int valeur)
{
    Element::ListeDesElements.push_back(Element(valeur));
}

Ce code est un peu comme le précédent mais sans faire sauter la classe Element (qui sert pas à grand-chose quand même.

Ligne 5 de ce code, il y a un constructeur : "Element(int valeur):valeur(valeur){};"
J'utilise ce qu'on appelle une liste d'initialisation : ":valeur(valeur)".
C'est la méthode à privilégier.

Mais je te propose un petit exercice : changer le constructeur mais sans utiliser la liste d'initialisation :

Code :

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

1
2
3
4
5
 
Element(int valeur)
{
   ...
};

Comment écrire le code pour initialiser le champ valeur de l'objet dans ce constructeur ?
Indice : "this->" est ton ami.

[mathieupicard]

Je crois que j’ai bien compris l’exercice que tu m’as proposé. Je comprends mieux ce que tu veux m’expliquer sur le « this », je pense bien. L’objet du code sert pas à grand-chose, je sais.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#include <iostream>
#include "A.h"
 
using namespace std;
 
int main()
{
    A a(5);
    a.Afficher();
    return 0;
}

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
 
#ifndef A_H
#define A_H
 
 
class A
{
    public:
        A(int valeur);
        void Afficher()const;
    private:
        int valeur;
};
 
#endif // A_H

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
 
#include <iostream>
#include "A.h"
 
using namespace std;
 
A::A(int valeur)
{
    this->valeur=valeur;
}
 
void A::Afficher()const
{
    cout << "valeur: " << valeur << endl;
}

[bacelar]

Exercice parfaitement exécuté.
En espérant que les cours de conception objet suivront, dans ton cursus.

[ternel]

Cela dit, il y a une raison à utiliser la liste d'initialisation:

Code :

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

A::A(int valeur) : valeur(valeur) {}

La raison est que l'affectation dans le corps n'est pas toujours possible, et surtout survient après la construction de chaque membre.

Sans passer par la liste d'initialisation, le membre valeur est d'abord initialisé par défaut (c'est à dire pas du tout pour un int), puis affecté avec la valeur du parametre valeur.
Si cela n'a pas d'impact pour un entier, c'est beaucoup plus génant pour un certain nombre de classes, comme un vector, un array ou un pointeur.
C'est encore plus flagrant avec des types non modifiables, ou n'ayant aucun constructeur par défaut (comme les références ou certaines classes).

PS: j'insiste, car c'est vraiment important.

[bacelar]

PS: j'insiste, car c'est vraiment important.

Je suis tout à fait d'accord avec toi.

Ici, c'est un exercice sur l'utilisation de "this" pour résoudre les problèmes d’ambiguïté.

La liste d'initialisation est la méthode à suivre avec les constructeurs.

Mais, à la tête des exemples de code sortie par son encadrant, on est encore loin de ces considérations, malheureusement.

[mathieupicard]

Gros merci pour votre aides et vos explications. Oui, je devrais revoir le concept objet dans mon cours d'introduction à Java, mais j'ai trouve de la documentation sur le sujet sur ce site et je vais la lire.

[ternel]

Attention, la manière de travailler avec les objets est différente en C++ et en Java.
En C++, tu peux les manipuler par valeur, tu disposes d'un destructeur dont tu sais exactement quand il sera appelé.
En Java, au contraire, tout objet est manipulé en référence, toute méthode est "virtuelle".

Dans les deux langages, certaines pratiques de l'autre sont impossibles ou déconseillées. (je pense à RAII, par exemple)