Aide correction examen

Version imprimable

2 pièce(s) jointe(s)

Bonjour à tous,

Je vous contacte car j'ai un examen en C++ (à l'écrit) vendredi. J'ai une annale à laquelle j'ai répondu et je souhaiterais savoir si vous pourriez jeter un coup d’œil aux réponses que j'ai apporté.
Je vous joins l'annale et mes réponses:
Pièce jointe 170110 Pièce jointe 170111

Et voici mon code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
class Client {
	string nom;
	string adresse;
	AgenceLocale& agenceLocale;
 
	public:
		Client(string n="",string a="", AgenceLocale& al):nom(n), adresse(a), agenceLocale(al){}
		AgenceLocale operator() {return agenceLocale->nom;}
		void afficher() {cout << nom << adresse << *agenceLocale;}
}
//1.4 - Oui, comm il y a un autre constructeur définit dans la classe, le compilateur n'en génère pas un par défaut.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class Employe {
	string nom;
	int id;
	AgenceLocale *agl;
 
	public:
		Employe(string ="", int i = 0):nom(n), id(i) {agl = new AgenceLocale();}
		virtual void afficher() {cout << nom << id << *agl;}
		virtual void calculerSalaire() = 0;
}
//2.4 Oui, car une classe abstraite est une classe qui possède au moins une fonction virtuelle pure. Elle n'est donc pas instanciable
//	  car elle possède une fonction qui doit être surplantée.
 
//2.5 Non, car on ne peut pas créer d'objet abstrait.

Code:

1
2
3
4
5
6
7
8
9
 
class Commercial {
	float pourcentage;
	float fixe;
 
	public:
		Commercial(string n="", int i =0, float p=0.0, float f=0.0):Employer(n,i), pourcentage(p), fixe(f) {}
		public void calculerSalaire(float pourcentage, float fixe){?}
}

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
 
class AgenceLocale {
	string nom;
	Region& nomR;
	int nbEmp;
	Employe * employe;
	list<Client> c;
	list<Vente> v;
 
	public:
		AgenceLocale(string n="", Region& r, int nb = 0):nom(n), nomR(r), nbEmp(nb) {
			employe = new Employe();
			c = *new list<Client>();
			v = *new list<Vente>();
		}
		AgenceLocale(const AgenceLocale& copie) {
			nom = copie.nom;
			nomR = copie.nomR;
			nbEmp = copie.nbEmp;
			employe = copie.employe;
			employe = new Employe[copie.nbEmp];
			for(int i = 0; i < nbEmp; i++) {
				employe[i] = copie.employe[i];
			}
			c = copie.c;
			v = copie.v;
		}
 
//4.2 Oui, car l'opérateur d'affection par défaut n'est pas suffisant si on utilise des pointeurs
 
		void addEmploye(string nom, int id) {
			Employe * e = new Employe(nom, id);
			employe[nbEmp] = *e;
			nbEmp++;
		}
		Vente AgenceLocale::operator[](int i) const {
			return v[i];
		}
		ostream& operator<<(ostream& out, Client& c) {
			for(list<Clien*> ::iterator it=lclient.begin(); it != lclient.endl();++it) {
				out << it->c.nom << endl;
			}
		}
		public void calculerSalaire() {
			???
		}
		public void salaireCommerciaux() {
			???
		}
}

Les "?" présents dans mon code signifient que je ne sais pas répondre à la question.

Je vous remercie de votre aide :)

en rouge dans le code, les remarques et corrections ....

en plus, il y a des opportunités d'économiser du code en créant des classes de base...

Citation:

Envoyé par CaNiBaLe

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Client {
	string nom;
	string adresse;
	AgenceLocale& agenceLocale;
et pourquoi pas AgenceLocale * agenceLocale;
	
	public:
		Client(string n="",string a="", AgenceLocale& al):nom(n), adresse(a), agenceLocale(al){}
		AgenceLocale operator() {return agenceLocale->nom;}
		void afficher() {cout << nom << adresse << *agenceLocale;}
}
//1.4 - Oui, comm il y a un autre constructeur définit dans la classe, le compilateur n'en génère pas un par défaut.
Non, le cTor propose des valeurs par défaut pour TOUS les parametres donc :
Client c = new Client(); marche sans avoir à déclarer un cTor sans arguments

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Employe {
	string nom;
	int id;
	AgenceLocale *agl;
	
	public:
		Employe(string ="", int i = 0):nom(n), id(i) {agl = new AgenceLocale();}
		virtual void afficher() {cout << nom << id << *agl;}
		virtual void calculerSalaire() = 0;void ?? pas float ??
}
//2.4 Oui, car une classe abstraite est une classe qui possède au moins une fonction virtuelle pure. Elle n'est donc pas instanciable
//	  car elle possède une fonction qui doit être surplantée. Implémentée

//2.5 Non, car on ne peut pas créer d'objet abstrait.
réponse incomplète on ne peux pas faire :
Employe e = new Employe(); certes mais une classe dérivée appelera le constructeur quand même

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Commercial { il est ou l'héritage ?
	float pourcentage;
	float fixe;

	public:
		Commercial(string n="", int i =0, float p=0.0, float f=0.0):Employer(n,i), pourcentage(p), fixe(f) {}
Employer ? Employe peut etre.
Erreur de compilation assurée, Employe n'est pas une classe de base de Commercial
		public void calculerSalaire(float pourcentage, float fixe){?}
ceci n'est pas l'implementation de calculerSalaire de la classe de base (paramètres différents)
pulic float calculerSalaire() { ... }

}

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
class AgenceLocale {
	string nom;
	Region& nomR;pourquoi & ?
	int nbEmp;
	Employe * employe;il n'y a qu'un employé dans l'agence ?
	list<Client> c;pas de * ?
	list<Vente> v;pas de * ?
	
	public:
		AgenceLocale(string n="", Region& r, int nb = 0):nom(n), nomR(r), nbEmp(nb) {
			employe = new Employe();
			c = *new list<Client>();*new ?
			v = *new list<Vente>();* new ?
		}
		AgenceLocale(const AgenceLocale& copie) {maladroit de nommer le parametre "copie"
			nom = copie.nom;les this->xxx ne sont pas optionnel
			nomR = copie.nomR;
			nbEmp = copie.nbEmp;
			employe = copie.employe;
			employe = new Employe[copie.nbEmp];argh !!
			for(int i = 0; i < nbEmp; i++) {
				employe[i] = copie.employe[i];
			}
			c = copie.c;révise les pointeurs, c'est juste pour éviter ça qu'n fait des cTor copie
			v = copie.v;
		}
		
//4.2 Oui, car l'opérateur d'affection par défaut n'est pas suffisant si on utilise des pointeurs

		void addEmploye(string nom, int id) {
			Employe * e = new Employe(nom, id);
			employe[nbEmp] = *e;
			nbEmp++;
		}
		Vente AgenceLocale::operator[](int i) const {
			return v[i];
		}
		ostream& operator<<(ostream& out, Client& c) {
			for(list<Clien*> ::iterator it=lclient.begin(); it != lclient.endl();++it) {
				out << it->c.nom << endl;
			}
		}
		public void calculerSalaire() {
			???retourner la somme des salaires de tous les emplyés (parcours de liste)
		}
		public void salaireCommerciaux() {
			???idem
		}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Client {
	string nom;
	string adresse;
	AgenceLocale& agenceLocale;
et pourquoi pas AgenceLocale * agenceLocale;
Car c'est un paramètre passé par référence
	
	public:
		Client(string n="",string a="", AgenceLocale& al):nom(n), adresse(a), agenceLocale(al){}
		AgenceLocale operator() {return agenceLocale->nom;}
		void afficher() {cout << nom << adresse << *agenceLocale;}
}
//1.4 - Oui, comm il y a un autre constructeur définit dans la classe, le compilateur n'en génère pas un par défaut.
Non, le cTor propose des valeurs par défaut pour TOUS les parametres donc :
Client c = new Client(); marche sans avoir à déclarer un cTor sans arguments
D'accord merci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Employe {
	string nom;
	int id;
	AgenceLocale *agl;
	
	public:
		Employe(string ="", int i = 0):nom(n), id(i) {agl = new AgenceLocale();}
		virtual void afficher() {cout << nom << id << *agl;}
		virtual float calculerSalaire() = 0;void ?? pas float ??
                Et bien fait ça fait partie des fonctions que j'ai pas bien compris, on demande de calculer le salaire, retourner le salaire n'est pas précisé donc... Mais je pense que tu as raison c'est bien float
}
//2.4 Oui, car une classe abstraite est une classe qui possède au moins une fonction virtuelle pure. Elle n'est donc pas instanciable
//	  car elle possède une fonction qui doit être surplantée. Implémentée
          ok j'ai mis ça car c'était la phrase de mon cours

//2.5 Non, car on ne peut pas créer d'objet abstrait.
réponse incomplète on ne peux pas faire :
Employe e = new Employe(); certes mais une classe dérivée appelera le constructeur quand même
Du coup la réponse c'est oui et non en ajoutant ce que tu as précisé?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Commercial : public Employe (merci){ il est ou l'héritage ?
	float pourcentage;
	float fixe;

	public:
		Commercial(string n="", int i =0, float p=0.0, float f=0.0):Employer(n,i), pourcentage(p), fixe(f) {}
Employer ? Employe peut etre. Oui effectivement erreur de syntaxe :)
Erreur de compilation assurée, Employe n'est pas une classe de base de Commercial
		public float calculerSalaire(*vide*){?}
ceci n'est pas l'implementation de calculerSalaire de la classe de base (paramètres différents)
pulic float calculerSalaire() { ... }
Oui ça me semblait bizarre, seulement je ne vois comment je peux implémenter ce qu'ils demandent, à savoir calculer le salaire. Tu aurais une idée du code que je dois mettre? Car je ne vois pas comment connaitre les ventes propres à un commercial etc...
Toutes ces questions relatives au calcul des salaires, je ne vois pas comment y répondre
}

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
class AgenceLocale {
	string nom;
	Region& nomR;pourquoi & ?Paramètre passé par référence
	int nbEmp;
	Employe employe[nbEmp];il n'y a qu'un employé dans l'agence ?Non, c'est un tableau si c'est ce que tu veux dire exact
	list<Client> c;pas de * ? Je ne comprends pas pourquoi il faudrait un * pour la déclaration de liste?
	list<Vente> v;pas de * ?
	
	public:
		AgenceLocale(string n="", Region& r, int nb = 0):nom(n), nomR(r), nbEmp(nb) {
			employe = new Employe();
			c = *new list<Client>();*new ?
			v = *new list<Vente>();* new ?
		}
		AgenceLocale(const AgenceLocale& copie) {maladroit de nommer le parametre "copie"
			this->nom = copie.nom;les this->xxx ne sont pas optionnel
			this->nomR = copie.nomR;
			this->nbEmp = copie.nbEmp;
			this->employe = copie.employe;
			this->employe = new Employe[copie.nbEmp];argh !!Sûrement quelque chose qui cloche? ^^
			for(int i = 0; i < nbEmp; i++) {
				employe[i] = copie.employe[i];
			}
			c = copie.c;révise les pointeurs, c'est juste pour éviter ça qu'n fait des cTor copieD'accord, mais pourrais-tu m'expliquer quelle est l'erreur ici?
			v = copie.v;
		}
		
//4.2 Oui, car l'opérateur d'affection par défaut n'est pas suffisant si on utilise des pointeurs

		void addEmploye(string nom, int id) {
			Employe * e = new Employe(nom, id);
			employe[nbEmp] = *e;
			nbEmp++;
		}
		Vente AgenceLocale::operator[](int i) const {
			return v[i];
		}
		ostream& operator<<(ostream& out, Client& c) {
			for(list<Clien*> ::iterator it=lclient.begin(); it != lclient.endl();++it) {
				out << it->c.nom << endl;
			}
		}
		public float calculerSalaire() {
			???retourner la somme des salaires de tous les emplyés (parcours de liste)
                        float somme = 0.0;
			for(list<Employe*>::iterator it = lemploye.begin(); it != lemploye.end();++it) {
				somme += it->calculerSalaire();
			}
			return somme;
		}
		public float salaireCommerciaux() {
			???idem
                        float somme = 0.0;
			for(list<Commercial*>::iterator it = lcommercial.begin(); it != lcommercial.end();++it) {
				somme += it->calculerSalaire();
			}
			return somme;
		}
}

Je te remercie vraiment pour toute l'aide que tu m'apportes ainsi que pour tes remarques! C'est vraiment génial! Merci!

Je mets à jour les données:

Client.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
 
#ifndef __annale2014__client__
#define __annale2014__client__
 
#include <iostream>
class AgenceLocale;
class Client
{
friend class AgenceLocale;
public:
  Client(const std::string& nom,
         const std::string& adresse,
         const AgenceLocale& agence);
 
  AgenceLocale operator();
  void afficher(std::ostream& out) const;
  std::string getNom();
 
private:
  std::string _nom;
  std::string _adresse;
  const AgenceLocale& _agenceLocale;
};
#endif /* defined(__annale2014__client__) */

Client.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
#include "client.h"
 
Client::Client(const std::string& nom, const std::string& adresse, const AgenceLocale& al)
  : _nom(nom), _adresse(adresse), _agenceLocale(agence)
{
}
 
std::string Client::operator() const
{
  return _agenceLocale->nom;
}
 
void afficher(std::ostream& out) const
{
  out << _nom << _adresse << *_agenceLocale;
}
 
std::string getNom()
{
    return _nom;
}

Employe.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#ifndef __annale2014__employe__
#define __annale2014__employe__
class AgenceLocale;
#include <iostream>
#include <string>
 
class Employe
{
public:
  Employe(const std::string& nom, int id, const AgenceLocale* agl);
  virtual ~Employe();
  virtual void afficher(std::ostream& out) const;
  virtual double calculerSalaire() const = 0;
 
protected:
  std::string _nom;
  int _id;
  const AgenceLocale* _agl;
};
#endif /* defined(__annale2014__employe__) */

Employe.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include "employe.h"
#include "agenceLocale.h"
 
Employe::Employe(const std::string& nom, int i, const AgenceLocale* agl)
  : _nom(nom), _id(id), _agl(agl)
{
}
 
virtual void
Employe::afficher(std::ostream& out) const
{
  out << _nom << _id << *_agl;
}

Commercial.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#ifndef __annale2014__commercial__
#define __annale2014__commercial__
 
#include <iostream>
 
class Commercial : public Employe
{
 
public:
  Commercial(const std::string& nom, int id, double pourcentage, double fixe);
  virtual void calculerSalaire();
 
protected:
  double _pourcentage;
  double _fixe;
}
#endif /* defined(__annale2014__commercial__) */*

Commercial.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
 
#include "commercial.h"
 
Commercial::Commercial(const std::string& nom, int id, double pourcentage, double fixe)
  : Employer(nom, id), _pourcentage(pourcentage), _fixe(fixe)
{
}
 
double calculerSalaire() const
{
}

AgenceLocale.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
 
#ifndef __annale2014__agenceLocale__
#define __annale2014__agenceLocale__
 
#include "region.h"
#include "employe.h"
#include "client.h"
#include "vente.h"
#include <iostream>
#include <vector>
 
class AgenceLocale
{
friend class Client;
public:
  AgenceLocale(const std::string& nom, const Region& region);
  AgenceLocale(const AgenceLocale& agence);
 
  void addEmploye(Employe* employe);
  Vente operator[](int i) const;
  void affiche(std::ostream& out);
  double calculerSalaire() const;
  double calculerSalaireCommerciaux() const;
 
 
private:
  std::string _nom;
  Region _region;
  std::vector<Client> _clients;
  std::vector<Vente> _ventes;
  std::vector<Employe*> _employes;
};
  std::ostream& operator<<(std::ostream& out, const Client& c);
#endif /* defined(__annale2014__agenceLocale__) */

AgenceLocale.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
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
 
#include "agenceLocale.h"
 
AgenceLocale::AgenceLocale(const std::string& nom, const Region& region)
 : _nom(nom), _region(region), _clients(), _ventes(), _employes()
{
}
 
AgenceLocale::AgenceLocale(const AgenceLocale& agence)
 :   _nom(agence._nom), _region(agence._region), _clients(agence._clients),
     _ventes(agence._ventes), _employes(agence._employes)
{
 
}
 
void
AgenceLocale::addEmploye(Employe* employe)
{
  _employes.push_back(employe);
}
 
Vente
AgenceLocale::operator[](int i) const
{
  return _ventes[i];
}
 
void
AgenceLocale::affiche(std::ostream& out)
{
  for (std::vector<Client>::const_iterator it = _clients.begin(); it != _clients.end(); ++it)
  {
    out << it-> _nom << std::endl;
  }
}
 
std::ostream& operator<<(ostream& out, const Client& client)
{
  client.afficher(out);
  return out;
}
 
double
AgenceLocale::calculerSalaire() const
{
  double somme = 0.0;
  for (std::vector<Employe*>::const_iterator it = _employes.begin(); it != _employes.end(); ++it)
  {
    somme += (*it)->calculerSalaire();
  }
 
  return somme;
}
 
double
AgenceLocale::calculerSalaireCommerciaux() const
{
  double somme = 0.0;
  for (std::vector<Employe*>::const_iterator it = _employes.begin(); it != _employes.end(); ++it)
  {
    //if (dynamic_cast<Commercial*>(*it) != 0) // Est un commercial
      somme += (*it)->calculerSalaire();
  }
 
  return somme;
}

Lorsque j'essaie de compiler, j'ai cette erreur:
client.h:14:25: error: declaration of 'operator()' as non-function

Merci encore! :)

Edit: erreur corrigée il fallait que je rajoute des parenthèses pour bien spécifier que je voulais surcharger l'opérateur().