besoin d'aide pour un programme gérant des associations.

Bonjour.
Etant débutant en C++, je me retrouve confronté à plusieurs problèmes qui me semblent insolubles :cry: .
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:

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:

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:

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:

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:

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:

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:

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:

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:

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.