Hériter surcharge ostream istream

**skyangel** · 23/03/2007, 14h44

Bonjour,

Dans le cadre d'un travail à rendre en formation, je dois dévelloper des classes.

J'ai par exemple , une classe personnel qui possèdes différents informations, voir ci dessous.
Personnel.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
#ifndef _personnel_H
 
#define _personnel_H
 
#include <iostream>
using namespace std;
 
 
//classe personnel
 
class personnel {
 
	protected:
	//reservation de nom pour les chars
 
	char *nom;
 
	char *prenom;
 
	int  tel;
 
 
 
	public:
 
	//constructeur personnel
 
	personnel(char* = NULL,char* = NULL,char* = 0);
	//destructeur
	~personnel();
	//modifie le numéro de téléphone
	int modiftel(int);
	//verifie si la personne passé en paramètre est identique à l'objet cible
	bool operator ==(const personnel &);
	//permet l'affectation
	void operator = ( const personnel &);
	//affiche 
 
    	friend ostream & operator << (ostream &, const personnel &);
	//saisie
 
	friend istream & operator >> (istream &, personnel &);
 
};
#endif

Personnel.cpp

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
#include "personnel.h"
#include <iostream>
using namespace std;
 
//constructeur specialisé de personnnel
personnel::personnel(char *x, char *y, char *z)
{
	if (x && y)
 	{
		nom= new char[strlen(x)+1];
		prenom=new char[strlen(y)+1];
		strcpy(nom,x);
		strcpy(prenom,y);
 	}
	tel = z;
}
//destructeur
personnel::~personnel()
 
{
	//si il y a un nom on libère l'espace pareil pour le prenom
 
	if(nom)
	{
 
		delete []nom;
	}
 
	if(prenom)
	{
 
		delete []prenom;
	}
 
}
// fonction de saisie par surcharge
istream & operator >>(istream & f, personnel & p)
{
	char tmp[50];
	cout << "Entrez le nom: " ;
	f >> tmp;
	p.nom=new char[strlen(tmp)+1];
	strcpy(p.nom,tmp);
	cout << "Entrez le prenom: ";
	f >> tmp;
	p.prenom=new char[strlen(tmp)+1];
	strcpy(p.prenom,tmp);
	cout << "Entrez le numero de tel: ";
	f >> p.tel;
	return f;
 
}
//fonction d'affichage par surcharge
ostream & operator <<(ostream & f, const personnel & p)
{
	return f<< p.nom << '\t' << p.prenom <<'\t'<<p.tel<<endl;
}
//on modifie le numéro de tel
int personnel::modiftel(int nouveautel)
{
	tel= nouveautel;
}
//operator ==
bool personnel::operator==(const &personnel p)
{
	// on compare le nom 
	if ((strcmp(nom,p.nom)==0) && (strcmp(prenom,p.prenom)==0) && (tel==p.tel))
	{
		return true;
	}
	else
	{	
		return false;
	}
}
//on affecte
void personnel::operator = (const personnel & p)
{
	nom=p.nom;
	prenom=p.prenom;
	tel=p.tel;	
}

Je codes à l'identique une classe salarie qui hérite de personnel.

Dans ma classe salarie, je dois saisir des informations et je le fais par surcharge.
Comment je peux faire pour que ma classe salarie appele automatiquement mes fonctions de surcharge de saisie de ma classe personnel???

J'espère que je suis assez explicite. Sinon demandez moi d'autres informations.

Merci d'avance.

**NewbiZ** · 23/03/2007, 14h55

Pour tous les accesseurs/mutateurs communs il te suffit de ne pas les virtualiser dans Personnel, et de ne pas les recoder dans Salarie.

Pour appeler les méthodes de la classe mère, il te suffira d'appeler Personnel::methode.

Par exemple :

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
class Personnel
{
public:
  Personnel( const std::string& nom, const std::string& surnom )
  {
    nom_ = nom;
    surnom_ = surnom;
  }
 
  void setInfo( const std::string& nom, const std::string& surnom )
  {
    nom_ = nom;
    surnom_ = surnom;
  }
 
private:
  std::string nom_;
  std::string surnom_;
};
 
class Salarie : public Personnel
{
public:
  Salarie( const std::string& nom, const std::string& surnom, unsigned int salaire )
    : Personnel( nom, surnom )
  {
    salaire_ = salaire;
  }
 
  setInfo( const std::string& nom, const std::string& surnom, unsigned int salaire )
  {
    Personnel::setInfo( nom, surnom );
    salaire_ = salaire;
  }
 
private:
  unsigned int salaire_;
}

**skyangel** · 23/03/2007, 15h05

merci de ta réponse.

Oui pour l'héritage , j'ai compris. Mais je ne vois pas comment appeler mes fonctions ostream et istream par héritage ?? Comment je dois faire. Peux tu me l'expliquer dans mon cas.

voici salarie.h et salarie.cpp

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
#ifndef _salarie_H
 
#define _salarie_H
 
#include <iostream>
using namespace std;
// /!\ faire des listes chainees pred et suiv /!\
// vérifier
//
 
class salarie:public personnel
 
{   
	//la date d'embauche
 
       date e; 
	// le salaire
 
       float salaire;
	//le nb de jours travaillées
 
       int nbtravail;
	//en congé ou non
 
       bool enconge;
 
	salarie *prec;
	salarie *suivant;
 
 
 
       public:
		// constructeur spécialisé
 
              salarie(char*, char*, float, date, int, int, bool);
		//constructeur par défaut
	      salarie();
		//fonction augmente le salaire
 
              int augmentesalaire(float );
		// calcule le nb de rtt ayant droits
 
              int rtt();
		//ajoute un nombre de jours travaillés
 
              int ajoutenbtravail(int );
		//vérifie qu on peut prendre congé
	      bool prendreconge(int);
		//remet a jour l attr encongé
 
              bool finconge();
		// compare deux salaires
	      bool operator <(const salarie &);
		//affiche 
 
    	      friend ostream & operator << (ostream &, const salarie &);
		//saisie
 
	      friend istream & operator >> (istream &, salarie &);
 
 
};
#endif

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
int salarie::ajoutenbtravail(int x)
{
	nbtravail=nbtravail+x;	
}
//on verifie qu'il peut prendre conge. Si c'est le cas , on les déduit de son quota.
bool salarie::prendreconge(int jdem) //prend en paramètre un certains nombre de jours demandés
{
	//on test si les jours demandés sont inférieurs aux jours acquis
	if (rtt()<jdem)
	{
		return 0;	
	}
	else
	{
		int res;
		res= -(jdem*15);
		ajoutenbtravail(res);
		enconge = true;
		return 1;
	}
}
// on remet l'employe en travail et no,n plus en congé
bool salarie::finconge()
{
	enconge=false;	
}
// on compare la date des employés
bool salarie::operator <(const salarie & s)
{
	if (e<s.e)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//fonction d'affichage par surcharge
ostream & operator <<(ostream & f, const salarie & s)
{
	return f<< "Date d embauche: " << s.e << '\n' << "Nom: " << s.nom << '\n' << "Prenom: " << s.prenom << '\n' << "Tel: " <<s.tel << '\n' << "Salaire: " << s.salaire << '\n' << "Nb de jours travailles: " << s.nbtravail << '\n' << "En conge? " << s.enconge << endl;
 
}
// fonction de saisie par surcharge
istream & operator >>(istream & f, salarie & s)
{
	//comment faire pour appeler les surcharges de personnel ???? pour ne pas tout resaisir ici
}

Merci de votre aide

**Mat007** · 24/03/2007, 11h11

Salut,

Peut-être que cette entrée de la FAQ répond à ta question ?

MAT.

**skyangel** · 26/03/2007, 12h05

j ai bien compri comment ca marché le istream et ostream.
La le truc c cvomment faire pour que le istream de ma classe salarie appele le istream de ma classe personnel?

en mettant class salarie:personnel ?? est ce suffisant??

**Laurent Gomila** · 26/03/2007, 12h27

Il suffit que tu appelles explicitement la version qui prend en paramètre un Personnel :

Code :

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

1
2
3
4
5
6
7
8
ostream & operator <<(ostream & f, const salarie & s)
{
    f << static_cast<const personnel &>(s);
 
    ... le reste spécifique à salarie ...
 
    return f;
}

Mais si tu comptes utiliser le polymorphisme alors il faudra adapter le code comme le montre la FAQ, dans ce cas ce sera plutôt :

Code :

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

1
2
3
4
5
6
void salarie::Print(std::ostream& Stream)
{
    personnel::Print(Stream);
 
    ... le reste spécifique à salarie ...
}

**skyangel** · 26/03/2007, 14h16

merci de votre réponse détaillée.

Hériter surcharge ostream istream

SL & STL C++

Discussions similaires

Partager

Partager