Probleme de Pointeur

Version imprimable

Bonjour à tous,

Je vous explique un peu ce que je fais avant d'expliquer ce qui ne vas pas.

Je dois creer deux classes, l'une pouvant stocker des "char" dans un tableau et pouvant pointer sur un objet du meme type de cette classe, appelons la Element, et une autre classe (on l'appelera lista) regroupant des Elements (l'objet). C'est donc une liste d' Elements. Le but final est de pouvoir lire un fichier avec des caracteres, de stocker chaque ligne dans un object Element (donc de mettre tous les symboles dans le tableau) et faire pointer le 1er objet vers le second, et le second vers le 3eme, etc.

Un objet de Lista representera donc, de maniere dérivée, toutes les lignes du fichiers.

Bon j'espere que vous avez compris, je vous montre le programme maintenant:

lista.h

Code:

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
 
#include <cstdlib>
#include <iostream>
#include <new>
 
 
using namespace std;
extern int size_table ;
 
class Element {         
      char *Table;
      int Dimension;
      Element *next ;
 
public :
 
#include <cstdlib>
#include <iostream>
#include <new>
 
 
using namespace std;
extern int size_table ;
 
class Element {         
      char *Table;
      int Dimension;
      Element *next ;
 
public :
 
       //  Constructeur
       Element(int=3);
 
       //  Destructeur
       ~Element();
 
       //  Constructeur de copie
       Element(const Element&);
 
       // permet d'initialiser le tableau d'un objet element (c'etait une fonction juste pour tester)
       void setElement(int,int);
 
       // permet d'acceder au pointeur next d'element depuis l'exterieur
       Element * return_next() { return next;}
 
       // Servira pour la lecture du fichier et l'ecriture egalement
       Element & operator=(char *) const;
       char* & operator=(const Element&) const;        
 
 
       // Affiche le contenu d'un objet Element
       friend  ostream &operator<<(ostream& o, Element&);
};
 
class Lista : public Element {         
      Element *Work;
 
public :
       // Constructeur
       Lista();
 
        //  Destructeur
       ~Lista();
 
       // Constructeur par copie
       Lista(const Lista&);  
 
};

lista.ccp

Code:

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
 
#include "Lista.h"
 
// Constructeur 
Element::Element(int a) {
    Table = new char[Dimension=a];
   	for (int i=0;i<Dimension;i++) {
		Table[i]=0;
	}
	next = NULL ;
}
 
// Constructeur par copie 
Element::Element(const Element & Elementcopy) {
       Dimension =Elementcopy.Dimension;
       Table= new (nothrow) char[Dimension];
 
       for(int i=0; i<Dimension; i++) {
             Table[i]= Elementcopy.Table[i] ;
       }
       next = Elementcopy.next ;
} 
 
// Servira a la lecture du fichier
Element & Element::operator=(char *Table_char) const {
        Element M(size_table);
        for(int i=0; i<M.Dimension; i++) {
                M.Table[i]=Table_char[i] ;
        }
        return M;        
}
 
// Servira a l'ecriture du fichier
char * & Element::operator=(const Element &M) const {
       char * return_Table = new char[M.Dimension];
       for(int i=0; i<M.Dimension; i++) {
                return_Table[i]=M.Table[i] ;
       }
       return return_Table;
}
 
// Destructeur
  Element::~Element() {
       delete[] Table; 
}
 
// Accede au contenu d'un object Element
 void  Element::setElement(int indice,int valeur) {
	Table[indice]=valeur;
 }
 
// Affiche un objet Element
  ostream & operator<<(ostream& o, Element &M) {
          int i;
 
          for(i=0; i<M.Dimension; i++){
                   o<<"\t";
                   o<<M.Table[i]<<"\t";
                   o<<endl;
          }
 
          o<<endl;   
          return o;
}
 
// Constructeur de lista     
Lista::Lista() {
    Work = NULL ;
}
 
// Constructeur par copie 
Lista::Lista(const Lista & Listacopy) {
    if (Listacopy.Work == NULL) cout << "Nothing to copy" << endl ;
    else {             
         Element *suivant;
         Work = Listacopy.Work;         
         suivant = (Listacopy.Work)->return_next();        
         while (suivant!= NULL) {
               Work = Work->return_next();
               Work = suivant;
               suivant = suivant->return_next();            
         }
 
    }
}    
 
// Destructeur par copie 
Lista::~Lista() {
       Element *n;
       Element *Suiv;       
       n = Work;
       while (n!= NULL) {
             Suiv = n->return_next();
             delete[] n; 
             n=Suiv;           
       }
 
       delete[] n; 
}

main.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
#include "Lista.h"
 
int size_table=0 ;
 
int main(int argc, char *argv[]) {
	Element M(4);   // Creation d'un Element
	Element Aut(2); // Creation autre Element
	Aut.setElement(0,6); // Initialisation
	Aut.setElement(1,6);
    M.return_next() =  &Aut ;  // Je veux faire pointer M.return_next() vers l'Element Aut
	if (M.return_next()==NULL) cout << "Marche Pas" <<endl ;
 
    system("PAUSE");
    return EXIT_SUCCESS;
}

Ok donc dans mon main, je voulais tester si ce que j'avais fais avant marchait donc j'ai creé deux objets Element, de dimension differente et je voulais faire pointer le voisin de M (qui est next) vers A.
Si je ne m'abuse, M->next étant un pointeur, je peux faire "pointer" ce pointeur vers l'Element Aut en utilisant la syntaxe :

Code:

M.return_next() = &Aut ;

Cependant j'obtiens une erreur de compilation du genre "non lvalue in assignement". Je comprend ce que ce message signifie mais je comprend absolument pourquoi je l'obtiens.

En esperant avoir été clair, je vous remercie de vos réponses!

PS: je rappelle que j'étais en train de tester le programme donc si vous voyez des erreurs que j'aurais faites dans les autres parties, c'est normal que je ne les ai pas encore vues (mais bon si vous en voyez, merci de me les signaler)

Nico

27/11/2008, 09h23
3DArchi
Bonjour,
- S'il ne s'agit pas d'un exercice de cours, alors il vaut mieux utiliser std::string et un conteneur (std::list ou std::vector).
- Un opérateur '=' en const, voilà quelque chose d'original!
- operator=: Comme te le dis le compilateur, retourner la référence d'un objet locale::aie:
- setElement: aucune vérification si indice est bien dans la plage autorisée
- return_next ne te permet en aucun cas de modifier la valeur de l'attribut next de l'instance à laquelle elle s'applique. La procédure habituelle est de faire un set_next! Ce que tu retourne, c'est la valeur de next et non une référence ou une adresse sur next permettant d'en modifier la valeur.
- Le constructeur par copie de Lista ne fonctionne pas.
- Dans le destructeur de Lista, delete[] c'est pour désalloué un tableau alloué par new XX[].
- La classe lista fait détruit les objets Element, alors qu'elle ne les a pas alloué et que la gestion de la copie n'est pas faite::aie:
27/11/2008, 16h10
Mikolay

Je te remercie de tes remarques tres constructives.

- C'est bien en exercice pour débutant, afin d'apprendre à programmer en C++

- Il est vrai que pour setElement je n'ai mis aucune sécurité mais cette fonction n'a été implentée que pour mes propres tests et sera effacée ulterieurement donc pas de panique:

- Concernant return_next, je ne comprend pas pourquoi je retournerais une valeur et non une adresse puisque je retourne une variable de type *Element, qui est un pointeur non?

Supposons que j'ai compris ce que je viens de mettre au dessus, et qu'en effet, je retourne bien une adresse, pour pouvoir faire pointer next sur qqch, je peux utiliser la fonction set_next qui ressemblerais à

Code:

void set_next(Element * a_pointer) { next = a_pointer;}

que j'utiliserai de cette facon

Code:

M.set_next(&Aut);

- Ensuite je ne comprend pas ta remarque sur "un operateur en const" . Aurais-je encore fait quelque chosie d'incensée? (ce qui m'etonnerais pas vu mon niveau de débutant).

- Ok compris concernant la fonction delete[]. Il me suffit de remplacer seulement les delete [] par des delete, qui (suivant ma logique) ferait un appel au destructeur de la classe Element.

- Ensuite, je ne vois pas pourquoi le constructeur de copie de Lista ne marche pas. Je l'ai pourtant fait au prealable sur une feuille pour voir les etapes de programmation et il me semble que ce soit la bonne méthode. Alors il est vrai que je dois maintenant (si j'ai bien compris la chose), utiliser set_next à la place de return_next pour pouvoir bien modifier mon pointeur, mais je pense que l'algorythme en lui même est bon.

- Je n'ai pas compris cette remarque : La classe lista fait détruit les objets Element, alors qu'elle ne les a pas alloué et que la gestion de la copie n'est pas faite

Tes remarques sont trés courtes mais ca m'a fait pas mal avancer et reflechir et j'éspere avoir su corriger ces erreurs.

Nico.

On reprend dans l'ordre:

Citation:

Envoyé par Mikolay

- Il est vrai que pour setElement je n'ai mis aucune sécurité mais cette fonction n'a été implentée que pour mes propres tests et sera effacée ulterieurement donc pas de panique:

C'est un bon réflexe que d'implémenter dès le début quelque chose de correct. L'expérience montre que ce qu'on a fait vite fait en disant 'je reviendrais dessus' ou 'je le virerais ensuite' devient quelque chose qu'on finit par utiliser sans être revenu dessus :aie:

Citation:

Envoyé par Mikolay

- Concernant return_next, je ne comprend pas pourquoi je retournerais une valeur et non une adresse puisque je retourne une variable de type *Element, qui est un pointeur non?

Element *next: quand tu retourne next, tu retourne l'adresse de l'élément. Donc tu peux modifier cet élément. Ce que tu veux modifier toi, c'est pas l'élément, mais l'adresse qui te donne l'élément. Donc tu aurais du utiliser &next, l'adresse de l'adresse. Parenthèse mise à part, utilise plutôt le set_next!

Citation:

Envoyé par Mikolay

Supposons que j'ai compris ce que je viens de mettre au dessus, et qu'en effet, je retourne bien une adresse, pour pouvoir faire pointer next sur qqch, je peux utiliser la fonction set_next qui ressemblerais à

Code:

void set_next(Element * a_pointer) { next = a_pointer;}

que j'utiliserai de cette facon

Code:

M.set_next(&Aut);

Oui.

Citation:

Envoyé par Mikolay

- Ensuite je ne comprend pas ta remarque sur "un operateur en const" . Aurais-je encore fait quelque chosie d'incensée? (ce qui m'etonnerais pas vu mon niveau de débutant).

L'opérateur '=' est l'opérateur d'affectation. Il ne peut donc pas être const pour l'objet sur lequel il s'applique puisqu'il s'agit de lui donner une nouvelle valeur. Donc effectivement, c'est insensé.

Citation:

Envoyé par Mikolay

- Ok compris concernant la fonction delete[]. Il me suffit de remplacer seulement les delete [] par des delete, qui (suivant ma logique) ferait un appel au destructeur de la classe Element.

new -> delete pour 1 objet. new [] -> delete [] pour un tableau d'objet.

Citation:

Envoyé par Mikolay

- Ensuite, je ne vois pas pourquoi le constructeur de copie de Lista ne marche pas. Je l'ai pourtant fait au prealable sur une feuille pour voir les etapes de programmation et il me semble que ce soit la bonne méthode. Alors il est vrai que je dois maintenant (si j'ai bien compris la chose), utiliser set_next à la place de return_next pour pouvoir bien modifier mon pointeur, mais je pense que l'algorythme en lui même est bon.

Je pense que tu as confondu la copie de la valeur de l'élément courant et la copie de son adresse. Telle que tu l'as écrit, l'instance par copie a un objet Work qui pointe sur le dernier élément de la liste de Listacopy.

Citation:

Envoyé par Mikolay

- Je n'ai pas compris cette remarque : La classe lista fait détruit les objets Element, alors qu'elle ne les a pas alloué et que la gestion de la copie n'est pas faite

Dans le destructeur tu fais des delete sur Work, mais nulle part il y a des allocs. Je présumme que ta classe est incomplète. Il faut garder en mémoire que la libération doit être faite au même niveau que l'allocation.

Citation:

Envoyé par Mikolay

Tes remarques sont trés courtes mais ca m'a fait pas mal avancer et reflechir et j'éspere avoir su corriger ces erreurs.

Nico.

J'espère que tu as pu progresser.

Quelques conseils:
1/Quand on fait une liste, on sépare le contenu du chaînage: tu devrais avoir quelque chose comme ça:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class CElement { private: char *Table; int Dimension; .... }; class CChainonElement { private: CElement m_Element; CChainonElement *m_pSuivant; ... }; class CListeElement { private: CChainonElement *m_pPremier; };
L'héritage n'a pas vraiment de sens.
A mon avis, progresse par étape. Fais une classe CElement dans laquelle tu apprend à gérer le pointeur, son allocation, sa libération, sa copie, la gestion du constructeur par copie et de l'opérateur '='. Maîtriser ça, c'est résoudre beaucoup des problèmes que tu pourrais faire!
Ensuite, tu reproduis sur CChainonElement ;
Et enfin CListeElement.
J'ai l'impression que tu es parti sur tout en même temps et tu t'embrouilles un peu.

N'hésites pas à faire un tour du côté des tutos. Tu peux aussi poster du code qui marche pour avoir des conseils au fur à mesure de ton avancement.
Bon courage.

J'ai compris pas mal de truc et je vais essayer de bien les programmer. C'est vrai que j'ai fais un peu tout et que je me suis légérement embrouillé. Je vais reprendre étape par étape.

Même si tu as raison concernant la séparation du contenu du chaînage avec le reste, cela reste un exercice assez scolaire et les étapes de programmation m'imposait de creer deux classes : Element et Lista.

Je vais avancer et je te riens au courant.

Merci beaucoup de ton aide et de ta patience, qui sont ici trés efficaces.

Nico
--------------------------------------------------------------------
Deuxieme MAJ

Bon alors j'ai essayé de modifier ce que j'avais compris et voila ce que ca donne :

- Constructeur par copie de Lista
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Lista::Lista(const Lista & Listacopy) { if (Listacopy.Work == NULL) cout << "Nothing to copy" << endl ; else { Element *suivant, *n; Work = Listacopy.Work; n = Work; suivant = (Listacopy.Work)->return_next(); while (suivant!= NULL) {; n= n->return_next() ; n = suivant; suivant = suivant->return_next() ; } } }
Je crois que maintenant cela marche car je ne modifie plus Work mais bien un objet Element parcourant ListaCopy

-

Citation:

Dans le destructeur tu fais des delete sur Work, mais nulle part il y a des allocs. Je présumme que ta classe est incomplète. Il faut garder en mémoire que la libération doit être faite au même niveau que l'allocation.

Je suis completement d'accord ,je libere seulement ce que je crée.
Lista est supposé etre une liste d'objet Element
donc pour detruire cette liste, je detruits chacun des
objets Element.

Encore un truc que j'ai du mal à comprendre alors si ca me semble bon...

- Sinon pour mes opérateurs =:, j'ai bien sur enlevé le type const

J'ai revu procédrure par procédure et je pense que dans l'ensemble (sauf bug ci dessous), je ne les ai pas baclées et que le programme devrait maintenant marcher.
J'ai fait un test avec set_next, et cela marche impécable.

Merci encore une fois, tu m'es d'une grande aide et ce sans en rajouter.

Nico

Salut,
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Lista::Lista(const Lista & Listacopy) { if (Listacopy.Work == NULL) cout << "Nothing to copy" << endl ; else { Element *suivant, *n; Work = Listacopy.Work; n = Work; suivant = (Listacopy.Work)->return_next(); while (suivant!= NULL) {; n= n->return_next() ; n = suivant; suivant = suivant->return_next() ; } } }
Ce code ne fait rien ou presque. Disons, que la boucle est inutile telle que tu l'as écrite. Normalement, un constructeur de copie devrait ressembler à ça:
Code:

1 2 3 4 5 6 7 8 9 Lista::Lista(const Lista & Listacopy) Si Listacopy est vide alors this est vide Sinon Parcourir tous les éléments de la liste Listacopy: Copier l'élément courant de Listacopy. Rajouter cette copie à this. Fin parcours.
Ce n'est pas ce que ton code fait!
P.S.: il y a une autre façon qui est de récupérer la même liste et de gérer au niveau des pointeurs un compteur de référence, mais je pense que pour l'instant c'est prématuré par rapport à ce que tu veux faire.

28/11/2008, 15h14
Mikolay

Ouais en fait je crois que je dois trop me baser sur mes connaissances en C et oublie d'utiliser les nouveautés en C++. Je vais relire des tutoriaux et reprogrammerait ensuite en espérant ne pas faire de nouvelles boulettes!

Bon, apres relecture de tutoriaux, me rend compte que j'ai fais un peu tout ca trop vite mais la je m'en rend vraiment compte (et certaine remarque comme

Citation:

Dans le destructeur tu fais des delete sur Work, mais nulle part il y a des allocs. Je présumme que ta classe est incomplète. Il faut garder en mémoire que la libération doit être faite au même niveau que l'allocation.

deviennet claires

Cependant j'ai encore quelques doutes: Par exemple le constructeur de la classe lista est bon, pas vrai? Il doit juste pointer sur le premier élement Element, ou il faut que je recreer un objet Element et qu'ensuite je face pointer Work sur ce dernier ?

De même pour le constructeur de la classe Element, je viens de changé le prototype à

Code:

Element( Element* = NULL,int=3);

et dois je recreer un objet Element (on l'appelera initnext ici) similaire a initnext et ensuite faire pointer Work vers ce dernier?

Je m'embrouille un peu beaucouip je sais mais une fois ca au clair, je pourrais vraiment avancer!

Merci de votre aide

Nico

Bon quand tu manipules des pointeurs (et c'est ce que tu fais dans ta liste), tu as deux choix:
1/ Lorsque tu copies un élément, tu le copies par valeur:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 class B {}; class A { private: B *m_pMonElement; public: A():m_pMonElement(NULL){} A(A const &_p_copie) { if(_p_copie.m_pMonElement!=NULL){ // en théorie, il faudrait gérer l'échec de construction m_pMonElement = new B(*_p_copie.m_pMonElement); } else{ m_pMonElement = NULL; } } // Et penser à surcharger l'opérateur = pour avoir le même comportement virtual ~A(){delete m_pMonElement;} };
2/ Tu le copies par adresse, en gros tu fais this->m_pMonElement = _p_copie.m_pMonElement. Mais, là il faut utiliser un pointeur intelligent.

Dans le premier cas, comme on fait une copie, une modification sur le premier n'entraînera pas une modification dans le second.
Dans le second cas, oui.
Mais, pour débuter, je te conseil le premier cas, ça te permettra d'aborder les problèmes liés aux pointeurs.
Je reprend ce que je t'ai dis plus haut. Commence par faire une classe Element complète et qui gère correctement son membre pointeur. Ensuite, tu la proposes, on en rediscute (la semaine prochaine pour moi), et après tu continues sur ta liste. 'Element' te permettra déjà de comprendre ces histoires de pointeurs et les problèmes liés.
Bon courage.

Merci encore de réponse.

Je sais que tu essayes de m'aider en me facilitant la tache. Comme je les souligné plus haut, cet exercice est malhreusement scolaire et je "n'ai pas le droit" de creer d'autres classe autre que Element et Lista.
Donc ne m'en veut pas, je ne fait que suivre les instructions (qui peuvent etre illogiques, je sais)

Quoiqu'il en soit j'ai continué à corriger des choses:
Code:

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 // Constructeur par copie Lista::Lista(const Lista & Listacopy) { if (Listacopy.Work == NULL) cout << "Nothing to copy" << endl ; else { Element *suivant, *n; Work = new Element(*(Listacopy.Work)); n = Work; suivant = (Listacopy.Work)->return_next(); while (suivant!= NULL) { n->set_next(new Element(*(suivant))); n = n->return_next() ; suivant = suivant->return_next() ; } } } // Destructeur par copie Lista::~Lista() { Element *n; Element *Suiv; n = Work; while (n!= NULL) { Suiv = n->return_next(); delete n; n=Suiv; } }
Je pense que maintenant je recopie bien tous les objets Element de ma liste, suis-je dans le bon??

Nico

30/11/2008, 11h12
3DArchi

:yaisse2:
Ca correspond à la première solution, la copie est par valeur.

Youpi :D, de toute façon je ne connaissais même pas l'autre solution mais ca viendra :)

En tous cas vraiment merci beaucoup :)

Sinon pour le constructeur de Element, je pense que je procede bien en raisonnant ainsi (j'avais un doute pour la définition du pointeur next). Je dois juste construire mon objet Element et rien d'autre, ce qui fait que je fais pointer next que sur ce qui m'est donné en parametre. (Par analogie, Element est un wagon, ma liste est un train, je ne construit qu'un wagon et non tous le train), ce qui donne
Code:

1 2 3 4 5 6 7 8 9 Element::Element(Element *initnext, int a ) { Table = new char[Dimension=a]; for (int i=0;i<Dimension;i++) { Table[i]=0; } if (initnext != NULL) next = initnext; else next = NULL; }
Par contre on m'a fait une remarque en me disant que l'instruction
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #include "lista.h" int main() { Lista list; list.setElement(0,'a'); list.setElement(1,'b'); list.setElement(2,'c'); return 0; }
qui compile bien mais ca qui me parait absolument pas logique. Le fait de créer un objet de la classe Lista me crée un pointeur de type Element pointant sur...rien au départ. Comment pourrais-je attribuer des valeurs à "rien"? Je comprends pas vraiment...
Le truc c'est que je ne vois pas d'où cela peut venir...

c'est compliqué le C ++ dis donc :roll: mais ça à l'air tellement puissant comme language qu'il est bon de le connaître :mouarf:

01/12/2008, 09h11
3DArchi

Citation:

Envoyé par Mikolay

qui compile bien mais ca qui me parait absolument pas logique. Le fait de créer un objet de la classe Lista me crée un pointeur de type Element pointant sur...rien au départ. Comment pourrais-je attribuer des valeurs à "rien"? Je comprends pas vraiment...
Le truc c'est que je ne vois pas d'où cela peut venir...

Je ne comprend pas trop ce que tu veux dire.