liste chaînée, que faire des attributs?

**jane40** · 22/02/2009, 21h52

Bonjour,
Je souhaite utiliser une liste chaînée sur des départements (d'une université)
Avant même de chercher à utiliser des méthodes sur ma liste chaînée, j'ai des erreurs de compilation.
Le poblème est que je ne sais pas vraiment utiliser ces listes ...

J'utilise 4 fichiers :

Department.hh

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
 
class Department{
private:
	string departmentname;
	string departmentfaculty;	
	int numberofstudents;
	int numberofstaffs;
 
public:
	Department(string, string, int, int);
	string getDepartmentName();
	string getDepartmentFaculty();	
	int getNumberOfStudents();
	int getNumberOfStaffs();
 
//create the dynamic linked list
struct NodeDepart
{
	string departmentname;
	string departmentfaculty;	
	int numberofstudents;
	int numberofstaffs;
	NodeDepart* link;			
};
typedef NodeDepart* NodePointer;
 
NodePointer head;
NodePointer currPointer;
NodePointer newNodePointer;

Déjà ici, je pense pouvoir ne mettre que la définition de la structure et pas parler des attributs et méthodes et donc, je n'aurais pas besoin de fichier Department.cc (voir plus loin pourquoi je les mets quand même)

Department.cc

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
 
#include "Department.hh"
 
Department::Department(string nom, string faculte, int eleve, int personnel)
{
	departmentname=nom;
	departmentfaculty=faculte;	
	numberofstudents=eleve;
	numberofstaffs=personnel;
}
 
 
//getter for departmentname
string Department::getDepartmentName(){
	return departmentname;
}
 
//getter for departmentfaculty
string Department::getDepartmentFaculty(){
	return departmentfaculty;
}
 
//getter for numberofstudents	
int Department::getNumberOfStudents(){
	return numberofstudents;
}
 
//getter for numberofstaffs
int Department::getNumberOfStaffs(){
	return numberofstaffs;
}

Departmentlist.hh

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
 
class Departmentlist{
 
private :
	list<Department> mylistofdepartment;
	NodePointer head;
 
public:
	Departmentlist(const char*);
	Departmentlist();
	~Departmentlist();
	void printDepartmentNames() const;
	void printPropertiesOfParticularDepartment(string nomdepart);
	void searchParticularDepartmentName(string recherchedepart);
	void AddDepartment(string nomdepartment,string facultedepartment, int etudiantsnumber,int personnelnumber);
	void DeleteEvent(string departtodestroy);

Departmentlist.cc
Pour le moment, dans ce fichier, je ne fais que lire, dans mon fichier department.txt, ma liste de départements (en utilisant une simple liste). A cause de cette lecture, j'ai besoin de

Department personneajouter(var1,var2,var3,var4);

et donc d'un constructeur prenant 4 paramètres dans Department et donc j'ai besoin de la déclaration des attributs...

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
 
Departmentlist::Departmentlist(const char* fileName)
{
 
	ifstream fichier(fileName) ;
	cout <<"Here are the events contained in the text file event.txt :\n";
	string var1; 
	string var2;
	int var3;
	int var4;
	if ( fichier ) // ce test échoue si le fichier n'est pas ouvert
	{
        	// cette boucle s'arrête dès qu'une erreur de lecture survient
        	while( fichier >> var1 && fichier >> var2 && fichier >> var3 && fichier >>var4)
        	{
				Department personneajouter(var1,var2,var3,var4);
				mylistofdepartment.push_back(personneajouter);
        	}
			fichier.close();  
	}
	else  
	{
		cout << "Impossible d'ouvrir le fichier !" << endl;
	}
 
 
	for (list<Department>::iterator it = mylistofdepartment.begin (); it != mylistofdepartment.end (); ++it) 
	{
		cout << " Name : " << it->getDepartmentName();  
		cout << " Faculty : " << it->getDepartmentFaculty();
		cout<< " Students : " << it->getNumberOfStudents();
		cout<< " Staff: " << it->getNumberOfStaffs() <<endl;
	}
 
}

Department.hh

Voici l'erreur que j'obtiens avec ce code :

g++ -c -o Department.o Department.cc
g++ -c Department.cc -o department.o
g++ -c -o Departmentlist.o Departmentlist.cc
In file included from Departmentlist.cc:4:
Departmentlist.hh:17: erreur: ‘NodePointer’ does not name a type
make: *** [Departmentlist.o] Erreur 1

Pour ceux qui me liront jusqu'ici, savez-vous d'où vient cette erreur?
Et que dois-je faire avec mes attributs et méthodes de la classe Department?

Merci pour vos conseils

**poukill** · 22/02/2009, 23h45

Je comprend pas. Chez moi ce code compile parfaitement:

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
 
#include <iostream>
#include <string>
#include <list>
 
using namespace std;
 
class Department{
private:
	string departmentname;
	string departmentfaculty;	
	int numberofstudents;
	int numberofstaffs;
 
public:
	Department(string, string, int, int);
	string getDepartmentName();
	string getDepartmentFaculty();	
	int getNumberOfStudents();
	int getNumberOfStaffs();
};
 
//create the dynamic linked list
struct NodeDepart
{
	string departmentname;
	string departmentfaculty;	
	int numberofstudents;
	int numberofstaffs;
 
	NodeDepart* link;			
};
 
typedef NodeDepart* NodePointer;
 
 
class Departmentlist{
private :
	list<Department> mylistofdepartment;
	NodePointer head;
 
public:
	Departmentlist(const char*);
	Departmentlist();
	~Departmentlist();
	void printDepartmentNames() const;
	void printPropertiesOfParticularDepartment(string nomdepart);
	void searchParticularDepartmentName(string recherchedepart);
	void AddDepartment(string nomdepartment,string facultedepartment, int etudiantsnumber,int personnelnumber);
	void DeleteEvent(string departtodestroy);
};
 
int main()
{
	NodePointer head;
	NodePointer currPointer;
	NodePointer newNodePointer;
 
	return 0;
}

**jane40** · 23/02/2009, 11h23

Merci d'avoir testé. J'ai voulu tester ce fichier, seulement, j'utilise toujours des makefile et j'ai essayé en mettant une extension .cc et pas d'extension mais je ne suis pas arrivée à le tester.

Enfin, entre le code proposé et mon code, il y a cette différence:

NodePointer head;
NodePointer currPointer;
NodePointer newNodePointer;

Dans mon code, je mets ça dans Department.hh et pas dans mon main. Dans quel fichier dois-je le mettre? En le déplaçant, j'ai toujours la même erreur :

Departmentlist.hh:17: erreur: ‘NodePointer’ does not name a type

C'est ici :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class Departmentlist{
 
private :
	list<Department> mylistofdepartment;
	NodePointer head;  //////////  ici  ///////
 
public:
	Departmentlist(const char*);
	Departmentlist();

**3DArchi** · 23/02/2009, 14h30

Salut,
(Une question en passant) : pourquoi utiliser NodePointer alors que tu utilises visiblement std::list?

Pour répondre à ta question : tu as définis ton type dans la classe, il faut donc indiquer le chemin complet au compilateur : Department::NodePointer

P.S. :
tu devrais apprendre à utiliser const, certaines de tes méthodes en ont visiblement besoin,

**jane40** · 23/02/2009, 16h38

Merci pour la réponse, je vais tester ça

Envoyé par 3DArchi

Salut,
(Une question en passant) : pourquoi utiliser NodePointer alors que tu utilises visiblement std::list?

J'ai implémenté pour le même projet des classes similaires avec des listes, donc j'ai repris la base, mais je dois maintenant n'utiliser que les listes chaînées...et je souhaite voir mon affichage (même si ce n'est qu'avec des simples listes dans un premier temps)

Envoyé par 3DArchi

P.S. :
tu devrais apprendre à utiliser const, certaines de tes méthodes en ont visiblement besoin,

Je vais faire attention, mais pour le moment mes méthodes ressemblent à

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
 
/*void Departmentlist::printDepartmentNames() const{
	NodePointer Pointer = head;
	while (currPointer != head)
	{
		cout<<currPointer->departmentname<<endl;
		currPointer = currPointer->link;
	}
}*/
 
void Departmentlist::printPropertiesOfParticularDepartment(string nomdepart){
}
 
void Departmentlist::searchParticularDepartmentName(string recherchedepart){
}
 
void Departmentlist::AddDepartment(string nomdepartment,string facultedepartment,int etudiantsnumber,int personnelnumber){
}

Mais merci du conseil !

**koala01** · 23/02/2009, 17h38

Salut,

Dés que l'on parle de structures dynamiques (ce qui comprend les piles, file, (différentes sortes de) listes, et arbres binaires / quelconques), il faut avoir le réflèxe de travailler en trois points:

La liste elle-même
L'élément de la liste (Itrateur )
l'objet que tu dois gérer avec la liste

La différence entre l'élément de la liste et l'objet que la liste doit gérer tient dans le fait que l'élément (itérateur) de la liste doit n'avoir pour seule responsabilité que de permettre de passer d'un élément à un autre et de permettre la "récupération" des information de l'itérateur en cours.

La liste aura quant à elle la responsabilité de la gestion des éléments qu'elle contient, à savoir:

ajout (en début et/ou en fin)
l'insertion (entre deux éléments)
la suppression
la suppression de tous les éléments (RAZ de la liste)

Si ta liste doit gérer des objets de type départements qui prennent la forme de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Department{
private:
	string departmentname;
	string departmentfaculty;	
	int numberofstudents;
	int numberofstaffs;
 
public:
	Department(string, string, int, int);
	string getDepartmentName();
	string getDepartmentFaculty();	
	int getNumberOfStudents();
	int getNumberOfStaffs();
}; // attention, rajouté par moi car "passé à la trappe" dans ton code

alors, l'élément de la liste doit ressembler à

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 Element // j'aurais pu choisir de l'appeler Iterateur ;)
{
    public:
        Element(Departement const&);
        Departement /* const */ & data() /* const */
        {return dep;}
        Element* next(){return mnext;}
        /* éventuellement */
        Element* previous(){return mprev;}
        /* voir, car c'est peut etre plus facile d'utilisation */
        Element* operator++(){return mnext;}
        /* et éventuellement */
        Element* operator--(){return mprev}
    private:
        Departement dep;
        Element * mnext;
        /* éventuellement
        Element * mprev;
        */
};

(attention, je n'ai pas implémenté toutes les méthodes de Element

)

Et la liste devrait prendre une forme proche de

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
class Liste
{
    public:
        Liste();
        ~Liste(); /* à toi de voir quoi faire, mais il faudra veiller à
                   * libérer correctement la mémoire de tous les éléments ;)
                   */
        void pushFront(Departement const &); // ajout en début de liste
        void pushBack(Departement const &);  // ajout en fin de liste
        void insert(Element* afterIt, Departement const&); // insertion
        void erase(Departement const&); /* version basée sur le département
                                         * à supprimer (nécessite la
                                         * possibilité de comparer
                                         * l'égalité de deux  départements ;)
                                         */
        void erase(Element* ); // version basée sur l'élément à supprimer
        void clear(); // suppression de tous les éléments
        size_t size() const; // récupérer le nombre d'éléments de la liste
        Element* first(); // récupération du premier élément
        Element* end(); // récupération de ce qui suit le dernier élément
        /* éventuellement */
        Element* find(/* peut être une chaine pourrait-elle suffir?? */);
    private:
        Element* mfirst; // le premier élément
        Element* mlast;  // le dernier élément
        size_t msize;    // le nombre d'éléments
};

Tu as maintenant trois classes et structures qui ont chacune leur propres responsailité et leur usage.

Il ne te reste donc plus qu'à réfléchir, sur base des commentaires que j'ai choisi avec soin "judicieusement" placés à comment obtenir le comportement attendu de chacune des méthodes de ces classes

**Arzar** · 23/02/2009, 17h39

Edit : Ha ! Koala a eu le temps de faire tout un roman pendant que j'écrivais ce post...

Salut!
Juste une remarque à propos du code que tu nous as montré :

Code :

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

1
2
3
4
5
6
7
8
9
 
struct NodeDepart
{
   string departmentname;
   string departmentfaculty;	
   int numberofstudents;
   int numberofstaffs;
   NodeDepart* link;			
};

Ce n'est pas une très bonne idée de recopier les membres de département dans un nœud de la liste. Car cela veut dire qu'à partir de maintenant pour modifier la moindre donnée (par exemple le nombre d'élève) il faut se souvenir de le faire dans la classe Departement et dans la classe NodeDepart. En règle général il faut quand même essayer d'éparpiller le moins possible et surtout il faut respecter le principe : une classe, une responsabilité.

Par exemple, la classe Departement a pour responsabilité de stocker les données relatives au département et de proposer une interface pour lire et mettre à jour ces données. Il n' y a qu'elle, et elle seule, qui doit posséder des membres comme departmentname, departmentfaculty etc. La classe NodeDepart n'a pas à connaitre ce genre de détail. Sa responsabilité est de modéliser un maillon d'une liste chainée de Departement. Pas plus, pas moins.

Code :

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

1
2
3
4
5
struct NodeDepart
{
   Departement departement;
   NodeDepart* next;			
};

**jane40** · 23/02/2009, 20h20

Envoyé par Arzar

[B] Ce n'est pas une très bonne idée de recopier les membres de département dans un nœud de la liste. Car cela veut dire qu'à partir de maintenant pour modifier la moindre donnée (par exemple le nombre d'élève) il faut se souvenir de le faire dans la classe Departement et dans la classe NodeDepart. En règle général il faut quand même essayer d'éparpiller le moins possible et surtout il faut respecter le principe : une classe, une responsabilité.

Par exemple, la classe Departement a pour responsabilité de stocker les données relatives au département et de proposer une interface pour lire et mettre à jour ces données. Il n' y a qu'elle, et elle seule, qui doit posséder des membres comme departmentname, departmentfaculty etc. La classe NodeDepart n'a pas à connaitre ce genre de détail. Sa responsabilité est de modéliser un maillon d'une liste chainée de Departement. Pas plus, pas moins.

Code :

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

1
2
3
4
5
struct NodeDepart
{
   Departement departement;
   NodeDepart* next;			
};

Merci pour cette remarque, j'avais pas compris ça
je n'ai vu que des examples où le "node" ne comprend qu'un élément...je croyais pouvoir mettre tous les éléments comme j'ai fait!
c'est noté !
et donc je suppose que pour y accéder c'est quelque chose comme :

Code :

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

1
2
3
 
NodePointer newNodePointer = new NodeDepart;
newNodePointer->department-> departmentname

**jane40** · 23/02/2009, 20h29

Envoyé par koala01

Si ta liste doit gérer des objets de type départements qui prennent la forme de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Department{
private:
	string departmentname;
	string departmentfaculty;	
	int numberofstudents;
	int numberofstaffs;
 
public:
	Department(string, string, int, int);
	string getDepartmentName();
	string getDepartmentFaculty();	
	int getNumberOfStudents();
	int getNumberOfStaffs();
}; // attention, rajouté par moi car "passé à la trappe" dans ton code

alors, l'élément de la liste doit ressembler à

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 Element // j'aurais pu choisir de l'appeler Iterateur ;)
{
    public:
        Element(Departement const&);
        Departement /* const */ & data() /* const */
        {return dep;}
        Element* next(){return mnext;}
        /* éventuellement */
        Element* previous(){return mprev;}
        /* voir, car c'est peut etre plus facile d'utilisation */
        Element* operator++(){return mnext;}
        /* et éventuellement */
        Element* operator--(){return mprev}
    private:
        Departement dep;
        Element * mnext;
        /* éventuellement
        Element * mprev;
        */
};

(attention, je n'ai pas implémenté toutes les méthodes de Element

)

Et la liste devrait prendre une forme proche de

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
class Liste
{
    public:
        Liste();
        ~Liste(); /* à toi de voir quoi faire, mais il faudra veiller à
                   * libérer correctement la mémoire de tous les éléments ;)
                   */
        void pushFront(Departement const &); // ajout en début de liste
        void pushBack(Departement const &);  // ajout en fin de liste
        void insert(Element* afterIt, Departement const&); // insertion
        void erase(Departement const&); /* version basée sur le département
                                         * à supprimer (nécessite la
                                         * possibilité de comparer
                                         * l'égalité de deux  départements ;)
                                         */
        void erase(Element* ); // version basée sur l'élément à supprimer
        void clear(); // suppression de tous les éléments
        size_t size() const; // récupérer le nombre d'éléments de la liste
        Element* first(); // récupération du premier élément
        Element* end(); // récupération de ce qui suit le dernier élément
        /* éventuellement */
        Element* find(/* peut être une chaine pourrait-elle suffir?? */);
    private:
        Element* mfirst; // le premier élément
        Element* mlast;  // le dernier élément
        size_t msize;    // le nombre d'éléments
};

Tu as maintenant trois classes et structures qui ont chacune leur propres responsailité et leur usage.

Il ne te reste donc plus qu'à réfléchir, sur base des commentaires que j'ai choisi avec soin "judicieusement" placés à comment obtenir le comportement attendu de chacune des méthodes de ces classes

Merci beaucoup pour ces conseils, je vais me pencher dessus

Il me semblait que les méthodes push_bash/front et erase n'existaient pas avec les listes chaînées?

**koala01** · 23/02/2009, 22h40

Envoyé par jane40

Merci beaucoup pour ces conseils, je vais me pencher dessus

Il me semblait que les méthodes push_bash/front et erase n'existaient pas avec les listes chaînées?

Si si, elles existent

De toutes manières, même si tu décide de ne pas utiliser les mêmes noms de méthodes, il faut bien admettre qu'il existe trois possibilités pour ajouter un élément dans une liste:

à son début
à sa fin
entre deux éléments

et qu'il faut pouvoir en retirer et, le cas échéant, la vider entièrement

La liste de la STL va même plus loin en permettant de supprimer tous les éléments qui se trouvent entre deux éléments déterminés ou de supprimer le premier ou le dernier élément

Son interface est particulièrement complète au point qu'il est peut être plus facile de se baser sur cette page afin d'être exhaustif sur ses possibilités

**jane40** · 24/02/2009, 22h44

Je vais donc essayer d'utiliser ces méthodes, ça me simplifiera peut-être les choses!
merci

liste chaînée, que faire des attributs?

C++

Partager

Partager