c++ -> surcharge d'ope et heritage ...

je suis vraiment au bord du suicide, j'ai exam dans trois jours ... et c la merde

comment peux on faire et est ce que cela existe :
utiliser la surcharge d'un operateur (ope + par ex) d'une classe mere pour surcharger l'operateur dans la classe fille sans reecrire tout le code (surtout qu'on peux pas puisque c un heritage prive)

si c pas comprehensible je veux bien mettre un exemple de classe mais c de la surcharge toute bateau ... seulement y a rien marque dans les livres a ce sujet et c'est chiant

merci a tous pour vos reponses

c'est pas trés clair ce que tu veux
est ce que ceci correspont à ce que tu attend ?
class LaMere
{
private:

double FValue;

public:

LaMere();
LaMere(const LaMere& d);
LaMere(double d);

double DoubleValue() const;

};
LaMere operator +(const LaMere& A, const LaMere& B)
{
return TData(A.DoubleValue() + B.DoubleValue()); /* Ne modifie pas l'original */
}

class LaFille : private LaMere
{
public:

LaFille();
};


-------------------------------
Réponse au message :
-------------------------------

> je suis vraiment au bord du suicide, j'ai exam dans trois jours ... et c la merde
>
> comment peux on faire et est ce que cela existe :
> utiliser la surcharge d'un operateur (ope + par ex) d'une classe mere pour surcharger l'operateur dans la classe fille sans reecrire tout le code (surtout qu'on peux pas puisque c un heritage prive)
>
> si c pas comprehensible je veux bien mettre un exemple de classe mais c de la surcharge toute bateau ... seulement y a rien marque dans les livres a ce sujet et c'est chiant
>
> merci a tous pour vos reponses

nan en fait c plus un truc de ce style :

class LaMere
{
private:

int x, y; // je mets des int c moins long

public:

LaMere();
LaMere(const LaMere& d);
LaMere(double d);

lamere operator + (lamere a)
{
lamere b;
b.x=x+a.x;
b.y=y+a.y;
}

}

class fille
{
private :
int jesuislafille;

public :
// constructeurs et tout et tout

fille operator + (fille a)
{
et la c la surcharge de la mere que je voudrais appeler et rajouter l'addition du int jesuisunefille...
}
}

voila j'espere que c'est plus clair

merci

Dans operator+ de la fille tu fais
Lamere::operator+
comme ça ça appele operator+ de la classe mere et ensuite tu peux faire les autres traitements...

High_Cobra ;)


-------------------------------
Réponse au message :
-------------------------------

> nan en fait c plus un truc de ce style :
>
> class LaMere
> {
> private:
>
> int x, y; // je mets des int c moins long
>
> public:
>
> LaMere();
> LaMere(const LaMere& d);
> LaMere(double d);
>
> lamere operator + (lamere a)
> {
> lamere b;
> b.x=x+a.x;
> b.y=y+a.y;
> }
>
> }
>
> class fille
> {
> private :
> int jesuislafille;
>
> public :
> // constructeurs et tout et tout
>
> fille operator + (fille a)
> {
> et la c la surcharge de la mere que je voudrais appeler et rajouter l'addition du int jesuisunefille...
> }
> }
>
> voila j'espere que c'est plus clair
>
> merci
>
>
>

tu pourrais me donner l'exemple dans le code ci dessus si'il te plait pke je vois pas comment l'integrer a mon code
merci



-------------------------------
Réponse au message :
-------------------------------

> Dans operator+ de la fille tu fais
> Lamere::operator+
> comme ça ça appele operator+ de la classe mere et ensuite tu peux faire les autres traitements...
>
> High_Cobra ;)
>
>
> -------------------------------
> Réponse au message :
> -------------------------------
>
> > nan en fait c plus un truc de ce style :
> >
> > class LaMere
> > {
> > private:
> >
> > int x, y; // je mets des int c moins long
> >
> > public:
> >
> > LaMere();
> > LaMere(const LaMere& d);
> > LaMere(double d);
> >
> > lamere operator + (lamere a)
> > {
> > lamere b;
> > b.x=x+a.x;
> > b.y=y+a.y;
> > }
> >
> > }
> >
> > class fille
> > {
> > private :
> > int jesuislafille;
> >
> > public :
> > // constructeurs et tout et tout
> >
> > fille operator + (fille a)
> > {
> > et la c la surcharge de la mere que je voudrais appeler et rajouter l'addition du int jesuisunefille...
> > }
> > }
> >
> > voila j'espere que c'est plus clair
> >
> > merci
> >
> >
> >
>

fille operator + (fille a)
{
LaMere::operator +(......) ;
// Addition de la fille à ajouter
}

High_Cobra ;)


-------------------------------
Réponse au message :
-------------------------------

> tu pourrais me donner l'exemple dans le code ci dessus si'il te plait pke je vois pas comment l'integrer a mon code
> merci
>
>
>
> -------------------------------
> Réponse au message :
> -------------------------------
>
> > Dans operator+ de la fille tu fais
> > Lamere::operator+
> > comme ça ça appele operator+ de la classe mere et ensuite tu peux faire les autres traitements...
> >
> > High_Cobra ;)
> >
> >
> > -------------------------------
> > Réponse au message :
> > -------------------------------
> >
> > > nan en fait c plus un truc de ce style :
> > >
> > > class LaMere
> > > {
> > > private:
> > >
> > > int x, y; // je mets des int c moins long
> > >
> > > public:
> > >
> > > LaMere();
> > > LaMere(const LaMere& d);
> > > LaMere(double d);
> > >
> > > lamere operator + (lamere a)
> > > {
> > > lamere b;
> > > b.x=x+a.x;
> > > b.y=y+a.y;
> > > }
> > >
> > > }
> > >
> > > class fille
> > > {
> > > private :
> > > int jesuislafille;
> > >
> > > public :
> > > // constructeurs et tout et tout
> > >
> > > fille operator + (fille a)
> > > {
> > > et la c la surcharge de la mere que je voudrais appeler et rajouter l'addition du int jesuisunefille...
> > > }
> > > }
> > >
> > > voila j'espere que c'est plus clair
> > >
> > > merci
> > >
> > >
> > >
> >
>