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