Discussion :

[Episode34]

Bonjour.
Etant d�butant en C++, je me retrouve confront� � plusieurs probl�mes qui me semblent insolubles .
Le mieux est que je vous propose ce que j'ai � programmer, ce que j'ai d�j� � ma disposition et ce que j'ai fait.
Peut-�tre pourrez-vous ainsi m'aider!

Il s'agit de g�rer des associations dont chacune contient des membres appartenant � des commissions.
Une association contient au moins un membre et au moins une commission.
Chaque membre doit appartenir au moins � une commission.
Chaque commission a au moins un membre.

Une commission est repr�sent�e par son intitul� (cha�ne de caract�res) et son effectif.
Un membre de l'association est repr�sent� par son nom et la liste des intitul�s des commisions auwquelles il appartient.

Une associaiton devrait �tre repr�sent�e par son nom, la liste de ses commissions et la liste de ses membres. Ces listes permattraient d'ajouter ou enlever facilement des membres et des commissions. Pour ce sujet, les choses sont un peu simplifi�es: il suffit de repr�senter chacun des ensembles commissions et [i]membres[i/] par un tableau dont la taille sera fix�e � l'ex�cution. Cette simplification r�duit le volume de code � �crire et facilite l'impl�mentation du cas �tudi�.

Il s'agit de d�finir les classes Membre.h (qui g�re les membres), Comm.h (qui g�re les commissions) et bien sur Asso.h (qui g�re le tout^^) ainsi que leur .cc associ�s...

Le programme doit soliciter les listes doublement cha�n�es, dont les fichier m'ont �t� fournis avec le sujet.
Le fichier CellString.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
16
17
18
19
20
21
22
#ifndef CellString_h
#define CellString_h
#include <string>
using namespace std; 
  class CellString
  {
  private:
    string val;
    CellString* suiv, *prec;
  public:
    CellString();
    CellString(string);
    virtual ~CellString();
    virtual string getVal()const;
    virtual void setVal(string);
    virtual CellString* getSuiv()const;
    virtual void setSuiv(CellString*);
    virtual CellString* getPrec()const;
    virtual void setPrec(CellString*);
  };
 
#endif

Le fichier CellString.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
#include <iostream> //pour que NULL soit un mot connu
using namespace std;
#include "CellString.h"
 
  CellString::CellString()                     {suiv=NULL;prec=NULL;}
 
  CellString::CellString(string v):val(v)      {suiv=NULL;prec=NULL;}
 
  CellString::~CellString(){}
 
  string CellString::getVal()const      {return val;}
  void CellString::setVal(string  v)     {val=v;}
  CellString* CellString::getSuiv()const      {return suiv;}
  void CellString::setSuiv(CellString* s)     {suiv=s;}
  CellString* CellString::getPrec()const      {return prec;}
  void CellString::setPrec(CellString* p)     {prec=p;}

le fichier ListeString.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
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
#ifndef ListeString_h
#define ListeString_h
 
#include "CellString.h"
class ListeString{
 
public:
// definition du type Place, synonyme de CellString* (pour commodite d'écriture)
  typedef CellString* Place;
 
private:
// attributs
  int nbElem;
  Place tete, queue;
 
public:
 
  ListeString();
  ListeString(const ListeString&);
  virtual ~ListeString();
 
private:
//methodes privees (inaccessibles à un utilisateur de la classe)
  virtual void setPremier(Place);
  virtual void setDernier(Place);
  virtual void setSuivant(Place p,Place nouvSuiv);
  virtual void setPrecedent(Place p, Place nouvPrec);
 
 
public:
//primitives 
  virtual Place premier()const;
  virtual Place dernier()const;
  virtual Place suivant(Place)const;
  virtual Place precedent(Place)const;
  virtual string valeur(Place)const;
 
//utilitaires 
  virtual bool estVide()const;
  virtual int longueur()const;
  virtual void vider();
 
//operations courantes liees uniquement a la structure de la liste
  virtual void ajoutApres(Place, string);
  virtual void ajoutAvant(Place, string);
  virtual void enleve(Place);
 
//operations courantes liees aussi a la nature des valeurs
  virtual void affiche()const;
  virtual void saisie();
  virtual void inserOrd(string);
  virtual void saisieOrd();
  virtual Place cherchVal(string)const; //cherche un elt de valeur donnee
 
 
//-------------------------------------------------
 // surcharge de l'opérateur d'affectation
 // pour que tout se passe bien quand on ecrit L2=L1;
 //(voir cours sur la surcharge d'operateurs)
  virtual ListeString& operator= (const ListeString&);
 
};
 
#endif

Le fichier ListeString.cc ( Je l'ai compl�t� moi-m�me avec les m�thodes saisie, affiche, cherchVal, inserOrd et saisieOrd, et celles-ci restent � v�rifier...)

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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
#include <iostream>
using namespace std;
#include "ListeString.h"
 
// Constructeur sans paramètres
ListeString:: ListeString()      {nbElem = 0;tete = NULL;queue = NULL;}
 
// Constructeur par copie
ListeString::ListeString( const ListeString& L)
{nbElem = 0; tete=queue=NULL; Place p = L.premier();
  while (p != NULL)
      {ajoutApres(dernier(), L.valeur(p));p = L.suivant(p);}
}
 
// Destructeur
ListeString::~ListeString()
{Place p = premier(); Place q;
  while (p != NULL) {q = p; p = suivant(p);delete q;}
}
 
//--------------------methodes privees-------------------
//accesseurs de modification de tete et queue : on ne veut pas
//qu'un utilisateur y ait accès
void ListeString::setPremier(Place p) {tete=p;};
void ListeString::setDernier(Place p) {queue=p;}
 
//-----utilisées pour limiter les appels aux méthodes de CellString dans les
//-----méthodes publiques de ListeString
void ListeString::setSuivant(Place p, Place nouvSuiv)
{p->setSuiv(nouvSuiv);}
void ListeString::setPrecedent(Place p, Place nouvPrec)
{p->setPrec(nouvPrec);}
 
 
//-----------------methodes publiques---------------------
//-----primitives
ListeString::Place ListeString::premier()const           {return tete;}
ListeString::Place ListeString::dernier() const          {return queue;}
ListeString::Place ListeString::suivant(Place p)const    {return
p->getSuiv();}
ListeString::Place ListeString::precedent(Place p)const  {return
p->getPrec();}
string ListeString::valeur(Place p)const           {return p->getVal();}
 
//-----utilitaires
bool ListeString::estVide()const  {return (tete == NULL);}
int ListeString::longueur()const  {return nbElem;}
 
//------operations courantes liees uniquement a la structure de la liste
 
//les chiffres en commentaires se referent aux dessins faits en cours
void ListeString::ajoutApres(Place p, string v)
{CellString * pCell= new CellString(v);
  if (estVide())
    {setPremier(pCell);setDernier(pCell);}
   else
    {setPrecedent(pCell,p);  //1
    if (p==dernier())   {setSuivant(p,pCell);setDernier(pCell);} //{2;3}
    else
     {setSuivant(pCell,suivant(p));  //2
      setPrecedent(suivant(p),pCell);  //3
      setSuivant(p,pCell);} //4
    }
  nbElem++;
}
 
void ListeString::ajoutAvant(Place p, string v)
{CellString * pCell = new CellString(v);
  if (estVide())
    {setPremier(pCell);setDernier(pCell);}
   else
   {setSuivant(pCell,p);  //1
    if (p==premier()) {setPrecedent(p,pCell);setPremier(pCell);} //{2;3}
    else
     {setPrecedent(pCell,precedent(p));  //2
      setSuivant(precedent(p),pCell);  //3
      setPrecedent(p,pCell);}//4
    }
  nbElem++;
}
 
void ListeString::enleve(Place p)
// rend un element qu'on peut eventuellement replacer dans une autre liste
{if (nbElem==1)
   {setPremier(NULL);setDernier(NULL);}
  else
    if (p==premier())
     {setPremier(suivant(premier()));setPrecedent(premier(),NULL); //{1;2}
      setSuivant(p,NULL);} //3
    else if (p==dernier())
     {setDernier(precedent(dernier()));setSuivant(dernier(),NULL); //{1;2}
      setPrecedent(p,NULL);}   //3
    else   //cas general
     {setSuivant(precedent(p),suivant(p));  //1
      setPrecedent(suivant(p),precedent(p));  //2
      setSuivant(p,NULL); setPrecedent(p,NULL); // {3;4}
     }
  nbElem--;
}
 
void ListeString::vider()
{Place p = premier();Place q;
  while (p != NULL) {q = p; p = suivant(p);delete q;}
  setPremier(NULL);setDernier(NULL);nbElem = 0;
}
 
//---------------------------------------------
// surcharge de l'opérateur d'affectation
ListeString& ListeString::operator= (const ListeString& L)
{if (this != &L)  //eliminer le cas L = L;
   {vider(); Place p = L.premier();
    while (p != NULL){ajoutApres(queue, L.valeur(p));p = L.suivant(p);}
   }
  return *this;
}
 
//---------------------------------------------
//----operations liees a la structure de la liste et a la nature des valeurs
void ListeString::affiche()const
{count<<"Affichage de la liste"<<endl;
Place p = premier();
  while (p != NULL){
	  cout<<valeur(p)<<endl;
	  p = suivant(p);
  }
}
 
void ListeString::saisie()
{
	string tmp;
	cout<<"Saisir une chaine:"<<endl;
	cin>>tmp;
	inserOrd(tmp);
}
 
void ListeString::inserOrd (string v)
// insertion dans une liste ordonnee
//si la liste est vide, cree son premier element
{if(permier() == NULL){
		setPremier(new Place(tmp));
		setDernier(new Place(tmp));
		nbElem++;
	}
	else ajouteApres(dernier(),tmp);}
 
void ListeString::saisieOrd()
{string tmp;
	cout<<"Saisir une chaine:"<<endl;
	cin>>tmp;
	inserOrd(tmp);
}
 
ListeString::Place ListeString::cherchVal(string v) const
//cherche un element de valeur donnee (le premier s'il y en a plusieurs)
{
	 if(longueur()>0){
		 Place tmp = premier();
		 while(tmp != NULL && strcmp(valeur(tmp),v) != 0) tmp = suivant(tmp);
		 return tmp;
	 }
	 return NULL;
}

Voici le fichier Comm.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
16
17
18
19
20
21
22
23
24
25
26
27
28
#ifndef Comm_h
#define Comm_h
 
#include <string>
using namespace std;
 
class Comm
{
 private:
   string intit;   
   int effectif;
 
 
 public:
  Comm();
  Comm( string, int);
  ~Comm();
  int getEffectif()const;
  string getIntit()const;
 
  void setEffectif(int);
  void setIntit(string);
 
  void saisie();
  void affiche()const;
 
};
#endif

Et le fichier Comm.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
#include <iostream>
#include <iomanip>
 
#include "Comm.h"
using namespace std;
 
  Comm::Comm(){}
  Comm::Comm( string n,int e)
    {intit=n;effectif=e;}
  Comm::~Comm(){}
  int Comm::getEffectif()const{return effectif;}
  string Comm::getIntit()const{return intit;}
 
  void Comm::setEffectif(int e){effectif=e;}
  void Comm::setIntit(string n){intit=n;}
 
  void Comm::saisie(){cin>>intit>>effectif;}
  void Comm::affiche()const
     {cout<<getIntit();
     for (int i=1;i<15 - getIntit().length();i++)
       {cout<<" ";}
      cout<<" : " <<setw(3)<<getEffectif()<<endl;
     }

A partir de l�, les impl�mentations suivantes sont mon oeuvre (lol) et peuvent �tre compl�tement fausses, alors n'h�sitez donc pas � tout modifier, ainsi qu'� ajouter des m�thodes dont vous aurez besoin!

Voici donc l'�bauche de mon fichier Membre.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
16
17
18
19
20
21
22
23
24
25
26
#ifndef Membre_h
#define Membre_h
 
#include <string>
#include "ListeString.h"
using namespace std;
 
class Membre
{
private:
   string nomMembre;
   ListeString appart;
   int indMem;
 
public:
  Membre();
  Membre(string);
  Membre(string, ListeString);
  ~Membre();
 
  int getIndMem()const;
  string getNomMembre()const;
  ListeString getAppart()const;
 
};
#endif

Ainsi que celle du fichier Membre.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
#include <iostream>
#include <iomanip>
#include <string>
#include "Membre.h"
#include "ListeString.h"
using namespace std;
 
  Membre::Membre(){}
  Membre::Membre(string n)
    {nomMembre=n;}
	Membre::Membre(string n,ListeString l){
		nomMembre = n;
		appart = l;
	}
	 Membre::~Membre(){}
 
  int Membre::getIndMem()const {return indMem;}
  string Membre::getNomMembre()const {return nomMembre;}
  ListeString Membre:: getAppart()const {return appart};

Puis viens la classe Asso.
Voici les instructions pour la cr�er.

Les attributs de la classe Asso sont les suivants:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
string nom; // nom de l'association.
int nbMb; // nombre de membres.
Membre* mb; // liste des membres.
int nbCom; // nombre de commissions.
Comm* cm; // liste des commissions.

il faut cr�er les m�thodes habituelles de construction, de d�struction et d'acc�s, mais aussi (et surtout) les m�thodes suivantes:

• existeComm, qui �tant donn� une cha�ne de caract�res, permet de savoir si cette cha�ne est l'intitul� d'une commission existante, et si oui renvoie son indice dans le tableau des commissions, -1 sinon.
  
  existeMembre, qui �tant donn� une cha�ne de caract�res, permet de savoir si cette cha�ne est le nom d'un membre existant, et si oui renvoie son indice dans le tableau des membres, -1 sinon.
  
  membresComm, qui �tant donn� l'intitul� d'une commission existante, renvoie la liste (la cr�e donc) des noms des membres qui appartiennent � cette commission.
  
  quitte qui �tant donn� deux cha�nes de caract�re m et c quelconques, permet que le membre de nom m quitte la commission d'intitul� c quand cela est possible, c'est-�-dire si m n'est pas le dernier membre de la commission c. Si c'est le cas, la m�thode doit supprimer la commission c, et si cette commission est �galement la derni�re de l'association, alors celle-ci doit �tre �galement supprim�e.
  Dans tous les cas, le sujet exige que la m�thode retourne un r�sultat qui permet de savoir exactement ce qu'il s'est pass�.

Voil�. Je sais c'est tr�s long mais finalement il n'y a pas tant que �a � impl�menter. N�anmoins �a reste difficile alors vraiment si vous pouviez m'aider �a serait vraiment me rendre un grand service. Merci d'avance.