Discussion :

[MicBeastKiller]

Bonjour,

voici une question que je me pose sur un projet actuel.
Je dois créer deux classes variables : une classe "VariableInteger" et une classe "VariableDouble" qui doivent, outre contenir chacune leur attribut de la variable (int pour "VariableInteger" et double pour "VariableDouble"), aussi contenir un attribut du nom de la variable (std::string).

Je pense à deux manières pour définir cela :

1 : je crée une classe mère "Variable" ne contenant comme attribut que le nom de la variable, puis je crée les deux classes "VariableInteger" et "VariableDouble" qui héritent de la classe "Variable"

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
 
class Variable
{
	std::string m_name;
 
	/* les méthodes qui vont bien */
};
 
class VariableInteger : public Variable
{
	int m_value;
 
	/* les méthodes qui vont bien */
};
 
class VariableDouble : public Variable
{
	double m_value;
 
	/* les méthodes qui vont bien */
};

2 : je crée uniquement les deux classes "VariableInteger" et "VariableDouble" qui ont chacune leur attribut de la variable (int pour "VariableInteger" et double pour "VariableDouble") ainsi que l'attribut supplémentaire du nom de la variable

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
 
class VariableInteger
{
	int m_value;
	std::string m_name;
 
	/* les méthodes qui vont bien */
};
 
class VariableDouble
{
	double m_value;
	std::string m_name;
 
	/* les méthodes qui vont bien */
};

Je ne vois pas spécifiquement la différence fondamentale (lors de l'exécution finale du logiciel créé) entre ces deux manières et je n'ai pas trouvé de réponse précise à cette question.

Merci beaucoup.

[paladice]

Je ne suis pas expert mais je pense que si ta classe mère n'est pas plus développée que ça : il vaut mieux privilégier la seconde méthode.

Corrigez moi les autres si je me trompe

[MicBeastKiller]

Certes la classe "Variable" ne contient que ce seul attribut du nom et les méthodes get et set qui vont bien.
Mais qu'elle sera justement la différences ?

[phi1981]

Utiliser l'héritage juste pour ça me parait compliqué. Tu es sûr que tu ne peux pas utiliser un template ?

[MicBeastKiller]

Utiliser l'héritage juste pour ça me parait compliqué. Tu es sûr que tu ne peux pas utiliser un template ?

Je peux utiliser ce que je veux.
Néanmoins une petite explication sur la complication de l'utilisation (beaucoup de "ion" ) de l'héritage me serait utile.

[phi1981]

Néanmoins une petite explication sur la complication de l'utilisation (beaucoup de "ion" ) de l'héritage me serait utile.

Oh là je suis vraiment pas la personne la mieux indiquée, mais personnellement je préfère éviter l'héritage et plutôt favoriser la composition.
Dans le cas de tes variables, l'idée d'avoir deux classes dérivées, une pour chaque type (si j'ai bien compris le but), est intéressante. Mais dans la pratique, à un moment, tu vas avoir un pointeur vers une "Variable", et même si tu sais que c'est un Int qu'elle contient, tu vas être bloqué parce qu'il te faudra faire un dynamic_cast ou un static_cast pour accéder à l'Int, ce qui est horrible.

[MicBeastKiller]

Oh là je suis vraiment pas la personne la mieux indiquée, mais personnellement je préfère éviter l'héritage et plutôt favoriser la composition.
Dans le cas de tes variables, l'idée d'avoir deux classes dérivées, une pour chaque type (si j'ai bien compris le but), est intéressante. Mais dans la pratique, à un moment, tu vas avoir un pointeur vers une "Variable", et même si tu sais que c'est un Int qu'elle contient, tu vas être bloqué parce qu'il te faudra faire un dynamic_cast ou un static_cast pour accéder à l'Int, ce qui est horrible.

Merci beaucoup de ta réponse.

[gl]

Tes classes ont une sémantique de valeur, ce qui se marie mal avec l'héritage.

En outre l'héritage public en C++ est de modéliser une relation EST-UN (i.e. un sous-typage) et doit respecter le LSP.
Ce que tu essaies de faire ici, c'est de la réutilisation de code, ce qui passe plutôt par de la composition ou éventuellement un héritage privée [1].

EDIT:
1/ ou un template comme le fait fort justement remarqué Bousk

[Bousk]

Bonjour,

attention par défaut la visibilité d'un attribut ou méthode d'une classe est à private, donc ton héritage en plus ne fonctionnerait pas : VariableDouble ne peut pas accéder à son nom dans Variable dont il hériterait.

Par contre, une solution très simple est selon moi

Code :

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

1
2
3
4
5
6
7
template<class TYPE>
class Variable
{
 std::string m_name;
 TYPE m_value;
 ...
}

[MicBeastKiller]

Tes classes ont une sémantique de valeur, ce qui se marie mal avec l'héritage.

En outre l'héritage public en C++ est de modéliser une relation EST-UN (i.e. un sous-typage) et doit respecter le LSP.
Ce que tu essaies de faire ici, c'est de la réutilisation de code, ce qui passe plutôt par de la composition ou éventuellement un héritage privée.

Merci beaucoup pour ces précisions.
Néanmoins je souhaite utiliser la classe variable comme identifiant de n'importe quelle variable (Integer ou Double ou autre) en créant par la suite des mécanismes pour que chaque variable est un identifiant unique.

Bonjour,

attention par défaut la visibilité d'un attribut ou méthode d'une classe est à private, donc ton héritage en plus ne fonctionnerait pas : VariableDouble ne peut pas accéder à son nom dans Variable dont il hériterait.

Par contre, une solution très simple est selon moi

Code :

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

1
2
3
4
5
6
7
template<class TYPE>
class Variable
{
 std::string m_name;
 TYPE m_value;
 ...
}

C'était une omision pour éviter d'alourdir le code, mais les attributs sont en protected.
Je vais m'orienter vers cette solution.

Merci beaucoup.

[Bousk]

Par contre si l'idée c'est d'avoir une collection de Variable indexées sur le nom indépendament du type.
Je trouve l'idée pas top, parce que pour accéder à son type réel/valeur etc ça va être galère, et je pense que si vraiment on s'entête dans cette voie, il vaut mieux quelque chose comme ceci afin de pouvoir créer une collection

Code :

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

1
2
3
4
5
class Variable
{
 std::string m_name;
 boost::any m_value; // voire variant, à vrai dire je ne les ai jamais utilisés
};

Et par mauvaise idée, j'entends que si à chaque manipulation il faut vérifier le type réel puis en récupérer la valeur correct selon son type, ça va être chiant pour l'utilisateur amha.

D'ailleurs, en général quand un débutant vient en demandant de pouvoir créer une collection de n'importe quel type possible
- structure
- mauvaise conception
- mauvaise habitude d'un autre langage
- faux besoin ("au cas où")

[MicBeastKiller]

Par contre si l'idée c'est d'avoir une collection de Variable indexées sur le nom indépendament du type.
Je trouve l'idée pas top, parce que pour accéder à son type réel/valeur etc ça va être galère, et je pense que si vraiment on s'entête dans cette voie, il vaut mieux quelque chose comme ceci afin de pouvoir créer une collection

Code :

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

1
2
3
4
5
class Variable
{
 std::string m_name;
 boost::any m_value; // voire variant, à vrai dire je ne les ai jamais utilisés
};

Et par mauvaise idée, j'entends que si à chaque manipulation il faut vérifier le type réel puis en récupérer la valeur correct selon son type, ça va être chiant pour l'utilisateur amha.

D'ailleurs, en général quand un débutant vient en demandant de pouvoir créer une collection de n'importe quel type possible
- structure
- mauvaise conception
- mauvaise habitude d'un autre langage
- faux besoin ("au cas où")

Merci pour ces précisions, sauf que je ne peux utiliser boost (pour le moment).
Pour mon besoin, j'ai un fichier ayant plusieurs variables données de la manière suivantes : Type nomVariable valeurVariable (où Type peut être int, double, bool et enum ; et nomVariable est un identifiant unique).
À l'analyse de ce fichier, je crée des vecteurs de variables (un pour chaque Type) et par la suite j'accède à ces variables par leur nom.

[Ekleog]

J'avais fait ça, pour un problème similaire : https://github.com/Ekleog/misc/blob/.../namedvars.cpp

Je ne sais pas si c'est exactement ce qui est recherché, mais ça m'en semble proche.

[MicBeastKiller]

J'avais fait ça, pour un problème similaire : https://github.com/Ekleog/misc/blob/.../namedvars.cpp

Je ne sais pas si c'est exactement ce qui est recherché, mais ça m'en semble proche.

Merci bien, je vais regarder.

[Bousk]

Merci pour ces précisions, sauf que je ne peux utiliser boost (pour le moment).
Pour mon besoin, j'ai un fichier ayant plusieurs variables données de la manière suivantes : Type nomVariable valeurVariable (où Type peut être int, double, bool et enum ; et nomVariable est un identifiant unique).
À l'analyse de ce fichier, je crée des vecteurs de variables (un pour chaque Type) et par la suite j'accède à ces variables par leur nom.

Dans ce cas alors la première solution plus haut devrait convenir et tu auras une collection pour chaque type. Mais hors de question de mélanger les types !
Je verrais bien ça

Code :

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

1
2
3
4
5
6
7
8
9
template<class TYPE> class Variable
{
  std::string m_name;
  TYPE m_value;
};
template<class TYPE> class Collection
{
  std::vector<Variable<TYPE> > m_vector;
};

Ou bien utiliser directement une map<std::string, TYPE>

[MicBeastKiller]

Dans ce cas alors la première solution plus haut devrait convenir et tu auras une collection pour chaque type. Mais hors de question de mélanger les types !
Je verrais bien ça

Code :

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

1
2
3
4
5
6
7
8
9
template<class TYPE> class Variable
{
  std::string m_name;
  TYPE m_value;
};
template<class TYPE> class Collection
{
  std::vector<Variable<TYPE> > m_vector;
};

Ou bien utiliser directement une map<std::string, TYPE>

C'est ce sur quoi je me suis dirigé. Je verrai plus tard pour le map<std::string, TYPE>.
Merci beaucoup.

[Joel F]

ou faire du Type erasure en ayant les classes templates qui heritent d'une classe non template fournissant l'interface qui va bien.