Discussion :

[elmouvic]

bonjour tout le monde
voila j'ai une class "listposte" et je veux la créer sous forme d'un arbre.
remarque: cette class est une class des postes vide! pour faire une affectation des individus a ces postes
alors j'aimerai bien savoir comment le faire; et comment elle devient ma class ( je parle de la syntaxe ou l'integration d'une bibliothéque des arbre s'il existe.....)
cordialement

[GeantVert13]

Bonjour,

Tu as fait quelque chose déjà ? Si on part de rien, ça va être dur de t'aider...

[PilloBuenaGente]

Bonjour, si c'est pour un arbre tu peux stocker une liste de classe dans une autre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class Employe {
public:
        Employe(){}
};
 
class Patron {
public:
        Parton(){}
private:
        Employe listeEmploye[ 10 ];
};

Je ne sais pas si c'est la meilleur solution cependant elle est simple à gérer.

Si tu parlais de les représenter, koala01 nous avait donné le lien de ce site :http://www.graphviz.org/Home.php

[elmouvic]

Bonjour,

Tu as fait quelque chose déjà ? Si on part de rien, ça va être dur de t'aider...

enfin j'ai un grand travail
j'ai commencé par faire des class "personne" et "poste" "listpersonne" et "listposte".
mon travail consiste a faire une affectation des individus a ces poste là!
j'ai modéliser mon probleme et je coince dans listpost qui est une class vide pour le moment et je dois la faire en tant qu'arbre ! car vous voyez l'hiérarchie des postes; chefs et les subordonnés... et j'espère que j'etais un peu clair

[elmouvic]

Bonjour, si c'est pour un arbre tu peux stocker une liste de classe dans une autre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class Employe {
public:
        Employe(){}
};
 
class Patron {
public:
        Parton(){}
private:
        Employe listeEmploye[ 10 ];
};

Je ne sais pas si c'est la meilleur solution cependant elle est simple à gérer.

Si tu parlais de les représenter, koala01 nous avait donné le lien de ce site :http://www.graphviz.org/Home.php

le problem n'est pas dans la class personne ! c'est dans la class "listpost" et ce sont les poste qui sont accessible et vide

[PilloBuenaGente]

"Employe listeEmploye[ 10 ];" Indique qu'il y aura 10 employés pour un patron, dans ces classes tu y rajoutera sans doûte un nom, qui poura être "vide" lorsque le poste sera à pourvoir.
Il est donc facile de retrouver dans un tableau les classes qui contiennent le nom "vide".

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
 
class Patron {
public:
        Parton( std::string nom= "vide" ){}
        std::string VoirPatron() const { return nom; }
        void NouveauPatron(std::string nom) { this->nom = nom; }
private:
        std::string nom;
        Employe listeEmploye[ 10 ];
}
 
class listpost {
   public:
      listpost();
 
   private:
      Patron patron;
};

[elmouvic]

"Employe listeEmploye[ 10 ];" Indique qu'il y aura 10 employés pour un patron, dans ces classes tu y rajoutera sans doûte un nom, qui poura être "vide" lorsque le poste sera à pourvoir.
Il est donc facile de retrouver dans un tableau les classes qui contiennent le nom "vide".

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
 
class Patron {
public:
        Parton( std::string nom= "vide" ){}
        std::string VoirPatron() const { return nom; }
        void NouveauPatron(std::string nom) { this->nom = nom; }
private:
        std::string nom;
        Employe listeEmploye[ 10 ];
}
 
class listpost {
   public:
      listpost();
 
   private:
      Patron patron;
};

merciii bcp! je vais essayer avc ce que vous m'avez donné!

[GeantVert13]

enfin j'ai un grand travail
j'ai commencé par faire des class "personne" et "poste" "listpersonne" et "listposte".
mon travail consiste a faire une affectation des individus a ces poste là!
j'ai modéliser mon probleme et je coince dans listpost qui est une class vide pour le moment et je dois la faire en tant qu'arbre ! car vous voyez l'hiérarchie des postes; chefs et les subordonnés... et j'espère que j'etais un peu clair

Donc si je comprends bien ta question, c'est comment implémenter un arbre en C++ ?

http://lmgtfy.com/?q=c%2B%2B+tree+implementation

[elmouvic]

"Employe listeEmploye[ 10 ];" Indique qu'il y aura 10 employés pour un patron, dans ces classes tu y rajoutera sans doûte un nom, qui poura être "vide" lorsque le poste sera à pourvoir.
Il est donc facile de retrouver dans un tableau les classes qui contiennent le nom "vide".

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 Patron {
public:
        Parton( std::string nom= "vide" ){}
        std::string VoirPatron() const { return nom; }
        void NouveauPatron(std::string nom) { this->nom = nom; }
private:
        std::string nom;
        Employe listeEmploye[ 10 ];
}
 
 
class listpost {
   public:
      listpost();
 
   private:
      Patron patron;
};

donc pour votre conseil: je rajoute la class patron a mes 4 classqui sont ( personne listpersonne et poste et listposte)?? et la class employe c la class personne je pense

[PilloBuenaGente]

Ops.. Si tu n'a que: "personne listpersonne et poste et listposte" il n'est pas question d'arbre, l'arbre aurait servit à gérer une hiérarchie par exemple, un simple std::map ou dans le genre pourrait suffire à mettre en relation les postes aux personnes !

[elmouvic]

Ops.. Si tu n'a que: "personne listpersonne et poste et listposte" il n'est pas question d'arbre, l'arbre aurait servit à gérer une hiérarchie par exemple, un simple std::map ou dans le genre pourrait suffire à mettre en relation les postes aux personnes !

j'ai pas bien compris ce que vous m'avez dit!
au fete j'ai 4 class :

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
class personne
public:
	  personne(){affecte=0;};
	  ~personne(){};
	  void afficherP();
      void intialiserP(int matPersonne,char *nom , int gra,int Comp);
	  int getmat();
	  int getetat();
	  void nonSatefe();
	  void ajouter_comp(poste *po,int niv_comp);
	  void affecte_pers(poste *po);
	  poste *poste_pers; //le poste
 private:
	 int matP;
     char *nomP;
     vector <competance> comp_pers;// Niveau de competance
	 int cod_gra; // code grade
	 int affecte;// 0 non Affecte 1 pour Affecte -1 Affecte non satesfe 
class poste
{
  public:
	  poste(){post_occupe=0;}; 
	  ~poste(){};
	 int get_numpost();
	 char get_postratt();
	 void set_num_post(int n);
  private:
	 int num_post;
     char desi_post;
     char post_ratt;
	 int capacite;
	 int post_occupe;
};
class listpersonne
{
  public:
	  listpersonne(){};
	  ~listpersonne();
	  int CalculerCCout();
	  void Ajouterpersonne(personne p,int position);
	  void Retirerpersonne(personne p);
      void affichel();
	  int nombrpersnonsatisfai();
	  personne *getpersonne(int i);
 private:
	 int num;
     int n;
	 vector <personne> personneaffecte;
};

et je veux une class listposte ??? voila ce que j'ai fait en résumé

[ternel]

Code :

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

class list_post {}

Prends le problème à l'endroit: quels services doit rendre cette classe?

parce que sinon, une simple std::list<poste> pourrait suffire

[elmouvic]

Code :

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

class list_post {}

Prends le problème à l'endroit: quels services doit rendre cette classe?

parce que sinon, une simple std::list<poste> pourrait suffire

je vais vous repondre:
alors je suis dans un probleme d'affectation du personnel:
je veux attribuer des employé a des poste selon des competance et des preferences! alors j'avais vraiment un obstacle pour demarrer! alors j'ai pensé de faire ces classe ! car j'ai pensé qu'elles serai utile pour le reste du problem: puisque e vais implementer l'algorithme tabou dans mon pb d'affectation aprés !
alors si vous voyez une autre methode plus simple et plus utiles! ou bien une modelisation des class dont je l'utilise vraiment vous me le proposez ! merci

[PilloBuenaGente]

Ou alors c'est peut-être dût au fait que tu as trop de classes. (tes deux listes peuvent être gérées par la même classe, ce sera d'autant plus facile)

Code :

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

1
2
3
4
5
6
7
8
9
 
class RelationEmployePoste {//Une classe regroupant la liste de postes et la liste d'employés
        RelationEmployePoste() {}
        //La création, comparaison, destruction d'employé ou de poste... ce fera ici 
        //Les fonctions viendrons sans doute plus logiquement
private:
        std::vector <Personne> listeDePersonne;
        std::vector <Poste> listeDePoste;
};

(Au fait, on ce tutoie ici !!)

[ternel]

Premièrement, corrigeons ton code:

• Choisir une langue et bien la parler. Je propose le français.
• Utiliser les concepts C++ à bon escient (enum, bool, std::string)
• Ne pas suffixer les membres avec l'initiale de la classe, c'est de l'information inutile et parasite
• utiliser un constructeur correct, et ne pas avoir de init()
• séparer les descripteurs des éléments algorithmiques: une personne est affectée si elle est à une place
• utiliser une classe pour représenter les données algorithmiques.
• séparer les informations. le poste n'est pas une partie de la personne, par contre, il y a des paires {poste, personne}

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
//ai pas bien compris ce que vous m'avez dit!
//au fete j'ai 4 class :
enum grade_t {Agent, Chef, GrandChef, PDG};
 
class personne {
private:
	const std::string m_nom;
	int m_matricule;
	map<competance, int> m_competences;// Niveau de competance
	grade_t m_grade; // code grade
public:
	void personne(int mat, std::string const& nom , grade_t grade, std::map<competence, int> competences):
		m_matricule(mat), m_nom(nom), m_grade(grade), m_competences(competences){
	}
	~personne(){};
	void afficher(std::ostream& flux);
	int matricule() const {return m_matricule;}
	int matricule() const {return m_matricule;}
	int matricule() const {return m_matricule;}
};
 
class poste {
private:
	const int m_numero;
	const std:string m_designation;
	const char m_post_ratt;//hein?
	const int m_capacite;
	std::vector<personne*> occupants
public:
	poste(int numero, std::string const& m_designation, char post_ratt, int capacite):
		m_numero(numero), m_designation(designation), m_post_ratt(post_ratt), m_capacite(capacite){
		occupants.reserve(capacity);
	}
	~poste(){};
	int numero() const {return m_numero;}
	char postratt() const {return m_post_ratt;}//hein?
 
	bool contient(const personne* p) const;
 
	//ajoute une personne à ce poste, si possible
	bool ajouter(const personne* p) {
		if (occupants.size() == m_capacite) return false;
 
		occupants.push_back(p);
		return true;
	}
 
private://vraiment?
	//retire une personne de ce poste
	bool retirer(const personne* p); //en exercice
 
public:
	//cherche le plus malheureux.
	const personne* malheureux() const;
 
 
	//calcul la somme des niveaux de bonheur des gens dans ce poste
	int bonheur() const;
 
	//calcul la somme des niveaux de bonheur des gens dans ce poste si p y était ajouté
	int bonheurAvec(const personne* p) const;
 
	//calcul la somme des niveaux de bonheur des gens dans ce poste si p en était enlevé
	int bonheurSans(const personne* p) const;
 
	bool transfererMalheureuxVers(poste& autre) {
		const personne* lui = malheureux();
		if (autre.ajouter(lui)) return retirer(lui);
		return false;
	}
};

il te faudra bien sur une fonction (libre) pour calculer le bonheur d'une personne en fonction de son poste.

Ceci étant fait, il te reste à créer deux ensembles de postes et de gens, et à travailler avec.
Pour cela tu auras besoin d'une fonction qui prennent l'ensemble des postes, et teste s'il contient une personne

PS: D'ailleurs, ce ne sont pas des postes, mais des bureaux

[elmouvic]

Premièrement, corrigeons ton code:

• Choisir une langue et bien la parler. Je propose le français.
• Utiliser les concepts C++ à bon escient (enum, bool, std::string)
• Ne pas suffixer les membres avec l'initiale de la classe, c'est de l'information inutile et parasite
• utiliser un constructeur correct, et ne pas avoir de init()
• séparer les descripteurs des éléments algorithmiques: une personne est affectée si elle est à une place
• utiliser une classe pour représenter les données algorithmiques.
• séparer les informations. le poste n'est pas une partie de la personne, par contre, il y a des paires {poste, personne}

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
//ai pas bien compris ce que vous m'avez dit!
//au fete j'ai 4 class :
enum grade_t {Agent, Chef, GrandChef, PDG};
 
class personne {
private:
	const std::string m_nom;
	int m_matricule;
	map<competance, int> m_competences;// Niveau de competance
	grade_t m_grade; // code grade
public:
	void personne(int mat, std::string const& nom , grade_t grade, std::map<competence, int> competences):
		m_matricule(mat), m_nom(nom), m_grade(grade), m_competences(competences){
	}
	~personne(){};
	void afficher(std::ostream& flux);
	int matricule() const {return m_matricule;}
	int matricule() const {return m_matricule;}
	int matricule() const {return m_matricule;}
};
 
class poste {
private:
	const int m_numero;
	const std:string m_designation;
	const char m_post_ratt;//hein?
	const int m_capacite;
	std::vector<personne*> occupants
public:
	poste(int numero, std::string const& m_designation, char post_ratt, int capacite):
		m_numero(numero), m_designation(designation), m_post_ratt(post_ratt), m_capacite(capacite){
		occupants.reserve(capacity);
	}
	~poste(){};
	int numero() const {return m_numero;}
	char postratt() const {return m_post_ratt;}//hein?
 
	bool contient(const personne* p) const;
 
	//ajoute une personne à ce poste, si possible
	bool ajouter(const personne* p) {
		if (occupants.size() == m_capacite) return false;
 
		occupants.push_back(p);
		return true;
	}
 
private://vraiment?
	//retire une personne de ce poste
	bool retirer(const personne* p); //en exercice
 
public:
	//cherche le plus malheureux.
	const personne* malheureux() const;
 
 
	//calcul la somme des niveaux de bonheur des gens dans ce poste
	int bonheur() const;
 
	//calcul la somme des niveaux de bonheur des gens dans ce poste si p y était ajouté
	int bonheurAvec(const personne* p) const;
 
	//calcul la somme des niveaux de bonheur des gens dans ce poste si p en était enlevé
	int bonheurSans(const personne* p) const;
 
	bool transfererMalheureuxVers(poste& autre) {
		const personne* lui = malheureux();
		if (autre.ajouter(lui)) return retirer(lui);
		return false;
	}
};

il te faudra bien sur une fonction (libre) pour calculer le bonheur d'une personne en fonction de son poste.

Ceci étant fait, il te reste à créer deux ensembles de postes et de gens, et à travailler avec.
Pour cela tu auras besoin d'une fonction qui prennent l'ensemble des postes, et teste s'il contient une personne

PS: D'ailleurs, ce ne sont pas des postes, mais des bureaux

vous avez cité deux classe au lieu 4
merci ! mais a partir de la ligne 47 de votre code proposé! le private et le public qui suivent sont pour quelle classe!?
-mais comment l'initialisation d'un groupe d'employé se fait ?
j'ai une proposition pour ça: je fait un chargement d'un fichier XML qui contient les infos. mais comment ?
-la différence entre les 3 fonctions du bonheur?
-comment tester

[ternel]

les privacités sont utilisables plusieurs fois, si tu as plusieurs bloc logiques dans ta classe.

Ici, c'était le cas de poste.

L'idée derrière les trois fonctions de bonheurs sont pour les calculs dans un algorithme évolutionnaire.

L'objectif étant de minimiser une action, au sens du principe de moindre action et du formalisme lagrangien (ah, les maths…), il faut avoir pouvoir obtenir deux types d'informations: la quantité d'action avant changement, et celle après changement.
L'atome de changement étant le déplacement d'une personne.

Il suffit donc de représenter les choses suivantes:

• Une situation donnée
• Le calcul de l'action
• Le mécanisme de modification de la situation

J'ai choisi de répartir la situation en trois blocs: une classe décrivant une personne, une classe de "position" où placer les personnes, et une paire d'ensemble pour assembler une situation (dont la situation initiale).
D'ailleurs, je recommande de constituer un bureau spécial pour les gens non-affectés.

Pour l'action, il y a les différentes fonctions de bonheur.
Pour le mécanisme de modification, il y a poste::transfert.

Ne reste donc qu'a choisir et coder l'algorithme de minimisation: génétique? évolutionnaire? exploration systématique? arbre de décision?
Pour cela, regarde du coté de l'IA et de la prise de décision.