Passage des propriétés dans l'héritage

Version imprimable

Bonjour à tous,

pour vous expliquer mon problème :
Voici une classe mère dont j'ai définis un super constructeur ci dessous :

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
 
Scheme::Scheme(int size, double debut, double fin, double Delta_X, double temps, double bc1, double bc2, double U)
{
	numberP = size;
	DeltaX = Delta_X;
	time = temps;
	BC1 = bc1;
	BC2 = bc2;
	u = U;
	std::vector <double> x(size);
	std::vector <double> fn(size);
	std::vector <double> fan(size);
	std::vector <double> fnplusone(size);
 
	x[0] = debut;
	x[size - 1] = fin;
	Delta_T = Delta_X*0.93;
	A = Delta_T / Delta_X;
 
	for (i = 1; i < size - 1; i++)
	{
		x[i] = x[0] + (i*Delta_X);
	}
 
	double t;
}

Ce super constructeur me sert à initialiser toutes mes variables.

J'ai une classe "fille" heritant de cette classe mère, et je souhaite réutiliser les variables définies ci dessus dans des méthodes de cette classe "fille".
Classe fille :

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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
std::vector <double> MethodsNum::UpwindScheme(double scheme)
{
	Calculateur C;
 
	for (i = 0; i < numberP - 1; i++)
	{
		x[i] = x[0] + (i*DeltaX);
	}
 
	if (scheme == 1)
	{
		for (t = 0; t <= time; t += Delta_T)
		{
			if (t == 0)
			{
				for (i = 0; i<numberP; i++)
				{
					fn[i] = 0.5*(C.sign(x[i]) + 1);
				}
			}
 
			//Boundary condition
 
			fn[0] = BC1;
			fn[numberP - 1] = BC2;
			fnplusone[0] = fn[0];
			fnplusone[numberP - 1] = fn[numberP - 1];
 
			for (i = 1; i < numberP - 1; i++)
			{
				fnplusone[i] = (-u*(Delta_T / DeltaX)*(fn[i] - fn[i - 1])) + fn[i];
			}
 
			for (i = 1; i < numberP; i++)
			{
				fn[i] = fnplusone[i];
 
			}
 
		}
 
		return fnplusone;
	}
	else if (scheme == 2)
	{
		for (t = 0; t <= time; t += Delta_T)
		{
			if (t == 0)
			{
				for (i = 0; i<numberP; i++)
				{
					fn[i] = 0.5*(C.sign(x[i]) + 1);
				}
			}
 
			//Boundary condition
 
			fn[0] = BC1;
			fn[numberP - 1] = BC2;
			fnplusone[0] = fn[0];
			fnplusone[numberP - 1] = fn[numberP - 1];
 
			for (i = 1; i < numberP - 1; i++)
			{
				fnplusone[i] = (((1 / (1 + u*A))*fn[i])) + (1 / (1+(DeltaX / (u*Delta_T)))*fnplusone[i - 1]);
			}
 
			for (i = 1; i < numberP; i++)
			{
				fn[i] = fnplusone[i];
 
			}
 
		}
 
		return fnplusone;
	}
 
 
}

Cependant, les valeurs initialisées dans le super constructeur deviennent 0 quand j'instancie ma classe fille.

Est-il possible de garder ses valeurs en mémoire sans les passer en argument de ma méthode issue de la classe fille ?
Car si ce n'est pas possible, qu'elle est l'utilité de la classe mère ?

Merci d'avance,

cordialement

18/10/2016, 11h27
Médinoc

Franchement, pour initialiser des variables non-membres, il vaut mieux utiliser autre chose que le constructeur.
Si tu veux regrouper ce code dans la classe mère, fais-toi une fonction membre statique qui fait ça, et prend les vecteurs voulus par référence...

Ce que j'ai compris de la question de l'OP est qu'il veut simplement réaliser une initialisation commune aux classes dérivées.

Ça se réalise simplement en invoquant le constructeur de la classe de base dans la liste d'initialisation de celui de la classe dérivée :
Code:

1 2 3 4 5 6 7 8 9 class Base { /* ... */ }; Base::Base(int foo, float bar) : m_foo(foo), m_bar(bar) { /* ... */ } class Specialized : public Base { /* ... */ }; Specialized::Specialized(int foo, float bar, bool b) : Base(foo, bar), m_b(b) { /* ... */ }

18/10/2016, 11h53
Bousk

Citation:

Envoyé par mzjul

Cependant, les valeurs initialisées dans le super constructeur deviennent 0 quand j'instancie ma classe fille.

Par quelle magie ? La classe fille doit appeler le constructeur de la classe mère. A moins que tu aies fourni un constructeur sans paramètre avec ta classe mère, auquel cas : pourquoi ?

Citation:

Envoyé par mzjul

Est-il possible de garder ses valeurs en mémoire sans les passer en argument de ma méthode issue de la classe fille ?

gni???
Si tu veux les garder en mémoire, garde-les en mémoire...
Fais en une copie ou que sais-je, un endroit (en mémoire) où y accéder :weird:
Btw, ce sont vraiment des variables non-membres comme indiqué par Médinoc ?! 8O

Citation:

Envoyé par mzjul

Car si ce n'est pas possible, qu'elle est l'utilité de la classe mère ?

Je te retourne la question :calim2:

La liste d'initialisation, c'est comme le plastique, c'est fantastique. :aie:
Code:

1 2 3 4 5 6 7 8 9 Scheme::Scheme(int size, double debut, double fin, double Delta_X, double temps, double bc1, double bc2, double U):numberP(size),DeltaX(Delta_X),time (temps),BC1(bc1),BC2(bc2),u(U),x(size),fn(size),fan(size),fnplusone(size),Delta_T(Delta_X*0.93),A(0.93) { for (i = 1; i < size - 1; i++) { x[i] = x[0] + (i*Delta_X); } //double t; c'est quoi cette crotte ??? }
Les conventions de nommages, c'est comme le plastique ... :aie:

Faudrait revoir la différence entre les variables locales à une fonction/méthode et un champ d'une classe, ça n'a pas grand-chose en commun.

Citation:

et je souhaite réutiliser les variables définies ci dessus dans des méthodes de cette classe "fille".

Vous pouvez utiliser les champs de la classe mère si ils sont public ou protected, PAS les variables de fonction/méthode.

Citation:

les valeurs initialisées dans le super constructeur

C'est pas un "super constructeur", c'est un constructeur tout moisi avec beaucoup trop de paramètres pour être vraiment utilisable.

Citation:

Est-il possible de garder ses valeurs en mémoire sans les passer en argument de ma méthode issue de la classe fille ?

Heu, et comment elles passent en mémoire si vous les passez pas en argument ? En scannant les ondes alpha du développeur ?

Un constructeur, c'est pour construire un objet complètement opérationnel. S'il faut une tétra-chié de paramètre pour configurer votre classe mère, c'est qu'ils sont nécessaires (sinon, vous vous compliquez la vie pour rien).

Une classe mère, cela n'a de sens que lorsqu'il y a plusieurs classes filles. La classe mère regroupe le comportement identique ou "par défaut" de ses classes filles et permet d'utiliser les classes filles là où on demande la classe mère (le principe du LSP).