Discussion :

[mzjul]

Bonjour à tous,

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

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
 
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 :

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
 
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

[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...

[Matt_Houston]

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 :

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

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)
{ /* ... */ }

[Bousk]

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 ?

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
Btw, ce sont vraiment des variables non-membres comme indiqué par Médinoc ?!

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

Je te retourne la question

[bacelar]

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

Code :

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

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 ...

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.

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.

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.

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).