problème librairie

Version imprimable

problème librairie

Bonjour,

J'essaie de faire un programme en c++ qui affiche les commerciaux et les manutentionnaires avec leur salaire mais la console n'affiche rien, je ne sais si c'est un problème d'en tête car code blocks le compile.

Voici les fichiers

Employe.cpp

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
 
#include <string>
#include <cstdio>
#include <iostream>
#include "Employe.h"
 
using namespace std;
 
Employe::Employe(char *n, char *p, int a)
{
	strcpy(nom,n);
	strcpy(prenom,p);
	age=a;
}
 
Employe::~Employe(void)
{
}
 
void Employe::Afficher()
{
	cout<<"Nom : "<<nom<<endl;
	cout<<"Prenom : "<<prenom<<endl;
	cout<<"Age : "<<age<<endl;
}

employe.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#pragma once
 
using namespace std;
 
class Employe
{
protected:
	char nom[20],prenom[20];
	int age;
public:
	Employe(char *n="", char *p="", int a=0);
	virtual ~Employe(void);
	virtual void Afficher();
	virtual int CalculSalaire()=0;
 
};

personnel.cpp

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
 
#include <iostream>
#include <cstdio>
#include <string>
#include "Personnel.h"
 
Personnel::Personnel(int a=0)
{
	nele=0;
	nmax=a;
	T = new Employe * [a];
}
 
Personnel::~Personnel(void)
{
	if(T) delete [] T;
}
 
void Personnel::Ajouter(Employe & E)
{
	if(nele<nmax)
		T[nele++]=&E;
}
 
void Personnel::Affiche_Salaires()
{
	for(int i=0;i<nele;i++)
	{
		T[i]->Afficher();
		cout<<"Salaire : "<<T[i]->CalculSalaire()<<endl<<endl;
	}
}
 
int Personnel::Salaire_Moyen()
{
	int moy=0;
	for(int i=0;i<nele;i++)
		moy+=T[i]->CalculSalaire();
	moy/=nele;
	return moy;
}

personnel.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#pragma once
 
#include "Manutentionnaire.h"
#include "Commercial.h"
 
class Personnel
{
protected:
	Employe ** T;
	int nele, nmax;
public:
	Personnel(int);
	~Personnel(void);
	void Ajouter(Employe &);
	void Affiche_Salaires();
	int Salaire_Moyen();
};

commercial.cpp

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
 
#include <iostream>
#include <cstdio>
#include <string>
#include "Commercial.h"
 
Commercial::Commercial(char *n, char *p, int a, int ca):Employe(n,p,a)
{
	ChiffreAffaire=ca;
}
 
Commercial::~Commercial(void)
{
}
 
void Commercial::Afficher()
{
	Employe::Afficher();
	cout<<"Chiffre d'affaire : "<<ChiffreAffaire<<endl;
}
 
int Commercial::CalculSalaire()
{
	return 0.2*ChiffreAffaire+400;
}

commercial.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
#pragma once
#include "Employe.h"
 
 
class Commercial : public Employe
{
protected:
	int ChiffreAffaire;
public:
	Commercial(char *n="", char *p="", int a=0, int ca=0);
	~Commercial(void);
	virtual void Afficher();
	virtual int CalculSalaire();
};

manutentionnaire.cpp

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
 
#include <cstdio>
#include <iostream>
#include <string>
#include "Manutentionnaire.h"
 
using namespace std;
 
 
Manutentionnaire::Manutentionnaire(char *n, char *p, int a, int nh):Employe(n,p,a)
{
	NombreHeures=nh;
}
 
Manutentionnaire::~Manutentionnaire(void)
{
}
 
void Manutentionnaire::Afficher()
{
	Employe::Afficher();
	cout<<"Nombre d'heures : "<<NombreHeures<<endl;
}
 
int Manutentionnaire::CalculSalaire()
{
	return 9*NombreHeures;
}

Manutentionnaire.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
#pragma once
 
#include "Employe.h"
 
class Manutentionnaire : public Employe
{
protected:
	int NombreHeures;
public:
	Manutentionnaire(char *n, char *p, int a, int nh);
	~Manutentionnaire(void);
	virtual void Afficher();
	virtual int CalculSalaire();
};

prjpersonnel.cpp
qui est le point d'entrée pour l'appli console

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
 
#include <iostream>
#include <string>
#include <cstdio>
#include "Personnel.h"
 
 
 
int main(int argc, char *argv[])
{
	Commercial d("DUPONT","Michel",31,10235);
	//d.Afficher();
 
    Commercial b("BLANC","Pierre",29,8500);
 
	Commercial d1("DUMIER","Jean",33,15600);
 
    Commercial k("KOLOSKY","Jean",29,12006);
 
	Manutentionnaire m("MANGEOT","Nicolas",35,200);
 
    Manutentionnaire u("UGUR","Mehmet",24,140);
 
    Manutentionnaire t("TURCAN","Gregory",28,148);
 
    Manutentionnaire l("LOISEAU","Henri",33,150);
 
    Manutentionnaire m1("MORIOT","Frederic",28,145);
 
    Manutentionnaire i("ISSIAR","DIA",30,178);
 
 
	Personnel p(10);
	p.Ajouter(d);
	p.Ajouter(b);
	p.Ajouter(d1);
	p.Ajouter(k);
	p.Ajouter(m);
	p.Ajouter(u);
	p.Ajouter(t);
	p.Ajouter(l);
	p.Ajouter(m1);
	p.Ajouter(i);
	p.Affiche_Salaires();
	cout<<"Salaire moyen : "<<p.Salaire_Moyen()<<endl;
 
	system("PAUSE");
	return 0;
}

je ma casse la tête dessus depuis un moment, mais les corrections que j'ai pu apporter n'ont rien donné!
Process terminated with status -1073741510 (0 minutes, 4 seconds), compilé sous code blocks!
Merci

29/05/2010, 12h53
Joel F

Fais toi une faveur et utilise std::vector au lieu de gérer ta mémoire mal à propos via new;
29/05/2010, 16h57
skawll

Je suis débutant et c'est un travail imposé, j'essaie déjà de tester pour voir si ça marche, après c'est sûr on peut mieux faire!
29/05/2010, 17h07
Invité
Bonjour,
Tout ceci me parait compliqué.
Il y devrait y avoir une classe au niveau des individus
- nom
- prénom
- ages
- date d'embauche
- poste
- salaire actuel (mensuel ou horaire ?)
- etc

C'est le membre poste qui est intéressant
A mon avis, il y a plusieurs solutions, mais je pense que toutes reviennent à la même méthode : la liste des postes est fixée et à chaque poste correspond un indice, 0 pour le patron, 1 pour les commerciaux etc.

Pour chaque poste, ou chaque groupe de poste, une classe comprenant par exemple
- mode de paiement ( mensuel ou horaire)
- type de prime
- responsabilité (oui - non) etc.

J'ai l'impression que c'est la classe Personnel qui est en trop, ou en quelque sorte fait double emploi avec la classe Employe.

Quant vous embauchez un nouvel employé, C'est d'abord un Commercial, ou bien d'abord une personne qui a un nom, prénom, age etc. et on indique son poste (commercial, manutentionnaire etc). Autant il est possible qu'un manutentionnaire devienne commercial, autant il est fort peu probable que cette personne change de nom.
Par ailleurs, vous créez bien un nouvel objet, mais comment faites-vous pour le retrouver? En faisant
Code:

1 2 3 4 5 for (int i=0; i<NbEmpl; i++) { Employe *Empl=T[i]; }
En ce qui me concerne, je préfère raisonner, dans un premier temps, indépendamment de tout langage.

Bon courage.
29/05/2010, 17h27
skawll

En faite, le but est d'afficher le nom, prénom, âge et chiffre d'affaire du commercial. A partir du chiffre d'affaire, on peut calculer le salaire, la formule est dans le fichier commercial cpp.
Pour le manutentionnaire, c'est pareil, seulement lui c'est pa le chiffre d'affaires mais à partir du nombre d'heures que le calcul du salaire pourra se faire!
par la suite, il y aura calcul du salaire moyen en additionnant tous les salaires pour diviser par le nombre de personnes!
29/05/2010, 19h10
Invité

Oui, j'imagine, mais si vous partez du résultat à obtenir, vous démarrez à l'envers.
Il s'agit de gestion de personnel.
Dans une société, il y des individus, des postes, des localisations etc.
Si vous organisez vos données à partir de la question "Salaire", vous faites toute une organisation pour un seul résultat.
Vous n'avez aucune idée de l'information qu'on va vous demander demain.
Si vous ne faites pas une organisation logique et surtout possible à compléter en fonction de la question à résoudre demain, vous aurez tout faux.

Si ça vous intéresse, je veux bien vous écrire le code tel que je l'imagine.
Je ne veux pas dire par là que ce serait un exemple, mais c'est juste une proposition.
29/05/2010, 20h17
Invité

Je pense aussi qu'il y a une faute.
La liste des Employe est un tableau de pointeurs Employe ** T
Quand vous faites
T= new Employe * [a];
vous créez un nouvel objet Employe, et vous dites que T est un pointeur sur cet objet. Or T est déclaré comme un tableau de pointeurs.
Je ne comprend pas la syntaxe Employe * [a]
Moi, j'écrirais cette ligne comme ceci
T[a] = new Employe( ? );
Quel constructeur? En fait, vous n'avez pas (j'ai pas vu) créé le nouvel objet Employe mais vous créez un nouveau pointeur dans le tableau T*
Il me semble que si vous surcharger l'opérateur new dans la classe Personnel, ça pourrait marcher.

Dans la fonction Ajouter, vous passez Employe en référence, étant donné l'organisation, à mon avis ce devrait être un pointeur.
En tout cas, vous faites T[n] = & E;
Comme E est passé par référence, à mon avis il y a toutes les chances que l'adresse, c'est à dire la référence (qui n'est pas un pointeur) soit très vite perdue.

Petit avis personnel, ce type de programmation ne me plait pas.
Je suppose qu'il s'agit d'un exercice destiné à comprendre l'utilisation des fonctions virtuelles.
Une fonction virtuelle DOIT être redéfinie pour être utilisée. Elle appartient à une classe de base et elle doit être redéfinie dans la classe dérivée.
Une classe de base peut contenir des fonctions non virtuelles qui peuvent ou non être surchargées dans les classes dérivées.
29/05/2010, 21h20
Joel F

Citation:

Envoyé par Pierre Dolez

T= new Employe * [a];
Je ne comprend pas la syntaxe Employe * [a]

Goto la FAQ C++ ...

T = new Employe* [a] alloue de la mémpire pour a pointeur sur Employe et renvoit ce pointeur de pointeur dans T ...
30/05/2010, 01h13
skawll

Merci pour les réponses. Bien sur que ça m'interesse de voir une autre manière d'opérer!