heritage et constructeur

Version imprimable

Bonjour ceci doit certainement être basique mais je ne vois (mais alors pas du tout) pq ca ne fonctionne pas...
Voici le code
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 class A { public: int a_; A(){}; A(int a):a_(a){}; }; class B: virtual public A { public: int b_; B(){}; B(int b):A(b) {}; }; class C: virtual public A { public: int c_; C(){}; C(int c):A(c) {}; }; class D: public B, public C { public: int d_; D(){}; D(int b, int c, int d):B(b), C(c), d_(d) {}; };
et voici le main.cpp
Code:

1 2 3 4 5 int b = 1; int c = 2; int d = 5; D test(b,c,d);
Il ne me construit pas le test (enfin si mais avec des valeurs folles... sauf le d = 5 yeahhhh :-) )

Si qqun voit, je lui tire déjà mon chapeau ...

Merci
D

05/10/2007, 09h23
bolhrak

Les constructeurs de B et C se contentent d'appeler le constructeur de la classe mère, ils n'initialisent pas leur membre. Donc normal que b_ et c_ n'aient pas les valeurs que tu leur passes.

Bon en fait c'est toujours dur d'expliquer son code a partir de code style titi, toto => voici ma classe A

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
 
template < typename X = double, typename Y= double>
class Curve
{
	friend class TermRateCurve;
	friend class TermRealCurve;
	friend class YieldCurve;
 
public:
	class Point
	{
	public:
               // fcts membres + constructeurs
 
	private:
		X x_;
		Y y_;
	};
	Curve<X,Y> ();
	Curve<X,Y> (const boost::numeric::ublas::vector<Point>&);
	Curve<X,Y> (const boost::numeric::ublas::vector<X>&, const boost::numeric::ublas::vector<Y>&);
private:
	boost::numeric::ublas::vector<Point> v_;
	bool splineMade_;
	bool isSorted_;
};

voici ma classe B:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
class TermRateCurve: virtual public Curve<Term, Rate>
{
public:
	TermRateCurve(){}
	TermRateCurve (boost::numeric::ublas::vector<Term>& vt, boost::numeric::ublas::vector<Rate>& vr)
		:Curve<Term, Rate>(vt, vr)
	{}
	TermRateCurve (bool spline)
		:Curve<Term,Rate>(spline)
	{}
	boost::numeric::ublas::vector<Term> vt();
	boost::numeric::ublas::vector<Rate> vr();
};

voici ma classe C:

Code:

1
2
3
4
5
6
7
8
9
10
class TermRealCurve: virtual public Curve<Term, Real>
{
public:
	TermRealCurve(){}
	TermRealCurve (boost::numeric::ublas::vector<Term>& vt, boost::numeric::ublas::vector<Real>& vp)
		:Curve<Term, Real>(vt, vp)
	{}
	boost::numeric::ublas::vector<Term> vt() ;
	boost::numeric::ublas::vector<Real> vp() ;
};

et voici ma classe D:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
using namespace boost::numeric::ublas;
 
class YieldCurveBIS: public TermRateCurve, public TermRealCurve
{
protected:
	date settlementDate_;
	Frequency m_;
	bool isContinuous_;
	bool isRateDefined_;
	bool isPriceDefined_;
public:
 
	YieldCurveBIS(date, vector<Term>&, vector<Rate>&, bool);
};
 
YieldCurveBIS::YieldCurveBIS(date t, vector<Term>& vt, vector<Rate>& vr, bool isCont)
	:TermRateCurve (isCont),
	settlementDate_(t), 
	isContinuous_(isCont), m_(0), 
	isRateDefined_(true), isPriceDefined_(false)
{}

Je ne vois pas comment je pourrais faire pour ne pas appeller le constructeur de Curve<X,Y>....????
Merci bcp
D

05/10/2007, 10h09
bolhrak

Je ne comprends pas trop ce que tu veux faire à vrai dire. Tu as une seule "instance" de Curve lorsque tu crées une YieldCurveBIS (fin une seule zone mémoire contenant les données de Curve dans ta zone mémoire correspondant à ton instance de YieldCurveBIS). Donc une seule variable x_ et une seule variable y_.

Et tu initialises ces variables deux fois, une première fois via le constructeur de TermRateCurve, une autre fois avec le constructeur de TermRealCurve (donc cela va écraser la première initialisation). Ca ne me paraît pas être ce que tu souhaites faire (ou alors j'ai mal compris le pb).

A mon avis la composition serait plus adaptée à ton problème que l'héritage multiple.

Pour l'appel au constructeur de Curve, tu 'na pa le choix, si tu ne spécifies pas un appel explicite, le compilo mettra un appel implicite au constructeur par défaut.
05/10/2007, 11h28
dhoorens
non non en fait YieldCurveBIS doit pouvoir etre defini
*soit par un termRateCurve (via le constructeur que j'ai indiqué). Dans ce cas, il construit la TermRateCurve et il pourra en déduire (par après) la TermRealCurve correspondante
*Soit par une TermRealCurve (via le constructeur suivant). Dans ce cas, il construit la TermRealCurve et il pourra déduire (si je veux) la TermRateCurve correspondante.
Code:

1 2 3 4 5 YieldCurveBIS::YieldCurveBIS(date t, vector<Term>& vt, vector<Real>& vp) :TermRealCurve (vt,vp), settlementDate_(t), isRateDefined_(false), isPriceDefined_(true) {}
Le but est vraiment de créer un object YieldCurveBIS qui puisse être défini par deux portes d'entrée (une via Curve<Term,Rate>, une via Curve<Term,Real>). Maintenant je suis ouvert à toutes propositions... :-)

La seule contrainte est de garder ma classe Curve<X,Y> et de créer ma classe YieldCurveBIS, le reste ...
05/10/2007, 14h34
bolhrak

Ok donc amha le mieux serait de :

- garder tes TermRateCurve et TermRealCurve, héritant toutes les deux de Curve.

- Mettre deux attributs dans YieldCurveBIS, un de type TermRateCurve et l'autre de type TermRealCurve, et de les initialiser en fonction du constructeur qui est appelé (lors de l'instanciation de ton YIeldCurveBIS) ou de la méthode utilisée (pour la déduction à partir de l'autre Curve déjà initialisée).
05/10/2007, 14h38
dhoorens

okay je vais essayer
Merci