Discussion :

[sone47]

Bonjour,

Je voudrais avoir une classe de base qui oblige ses enfants a definir une const map de string.
Je cherche a initialiser cette map dans les .h des classes derivees dans un style comme:

La classe de base

Code :

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

1
2
3
4
5
6
 
// Mere .h
class Mere
{
const std::map<std::string, std::string> maMap;
};

Une derivee

Code :

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

1
2
3
4
5
6
7
8
 
// FilleA.h
#include Mere.h
const std::map<std::string, std::string> Mere::maMap = boost::assign::map_list_of
("FilleA", "FilleA");
class FilleA: public Mere
{
};

Code :

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

1
2
3
4
5
6
7
8
 
// FilleB.h
#include Mere.h
const std::map<std::string, std::string> Mere::maMap = boost::assign::map_list_of
("FilleB", "FilleB");
class FilleB: public Mere
{
};

Est ce qu'il est possible de proceder dans un style comme celui ci ? (juste une init declarative dans les headers des filles)

Merci d'avance

[r0d]

Bonjour,

je ne comprend pas ce que tu veux faire, mais déjà, il me semble que tu te trompes sur l'utilisation de static. Si ta map est déclarée static, ça implique qu'elle ne peut exister qu'en un seul exemplaire dans tout ton programme. Or j'ai l'impression que toi tu souhaites avoir une map par instance.

Mais ton problème n'est pas clair, il faudrait que tu précises plus.

[ternel]

Ca ressemble plus à une map par type…

[Iradrille]

Bonjour,

Je voudrais avoir une classe de base qui oblige ses enfants a definir une const map de string.
Je cherche a initialiser cette map dans les .h des classes derivees dans un

Hello,

un attribut static est lié à une classe (tout comme une méthode statique ne peut pas être virtuelle) donc la map sera lié à la Mere et ne sera pas "redéfinie" dans les filles.

Si tu veux tester que tes filles auront une map<string, string> tu peux faire quelques chose comme ça : (mais tu sera obligé de redéfinir une map dans chaque 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
template <class T, class U>
struct same_type {
	static const bool value = false;
};
 
template <class T>
struct same_type<T, T> {
	static const bool value = true;
};
 
class Fille;
 
template <class T>
struct has_a_string_string_map {
	static_assert(same_type<std::map<std::string, std::string>, decltype(T::maMap)>::value, "pas de string string map"); 
};
 
class Fille {
	friend struct has_a_string_string_map<Fille>;
 
	static std::map<std::string, std::string> maMap;
 
	has_a_string_string_map<Fille> check; // doit être à la fin
};
 
std::map<std::string, std::string> Fille::maMap;

[sone47]

Bonjour merci pour vos reponses,
Effectivement le static dans la mere va impliquer une seule map, j'ai mis le code pour expliquer le principe.
En fait je vais avoir une map par type, dans l'ideal je devrais declarer une static map dans chaque enfant, mais la map est utilisée par la mere c'est pour sa que je voudrais la declarer dans la mere et l'initialiser dans chaque fille.

Aujourd'hui je fais juste une methode init() dans chaque fille qui initialise la map avec des valeurs desirees.

Dans l'ideal la map devrait etre const et c'est plutot sur ce point que je bloque:

Code :

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

1
2
3
4
5
// Mere .h
class Mere
{
static const std::map<std::string, std::string> maMap;
};

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
// FilleA.h
#include Mere.h
 
// Probleme pour initialiser la map ici ??
const std::map<std::string, std::string> Mere::maMap = boost::assign::map_list_of
("FilleA", "FilleA");
class FilleA: public Mere
{
};
 
// FilleB.h
#include Mere.h
 
// Probleme pour initialiser la map ici ??
const std::map<std::string, std::string> Mere::maMap = boost::assign::map_list_of
("FilleB", "FilleB");
class FilleB: public Mere
{
};

[Bousk]

Bonjour,

conceptuellement parlant, j'ai du mal avec le principe de la classe mère qui utilise quelque chose qui doit être initialisé par la classe fille.
A quel niveau intervient l'héritage et pourquoi s'encombrer d'un héritage ?

Je serais bien plus partant pour une liste de Fille, et une classe template qui prend une Fille en paramètre template, Fille ayant l'obligation de définir une const map en static:

Code :

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

1
2
3
4
struct Fille1 { static const std::map<> s_map; };
struct Fille2 { /* rien ici : classe non utilisable avec SupaClass ci-dessous */};
template< class T >
struct SpaClass { static void DoStuff() { /* utilisation de T::s_map */ }  };

Non testé.

[r0d]

ça parait bizarre à première vue effectivement, mais bon...

Le problème d'une variable membre const (qu'elle soit statique ou pas), c'est qu'elle doit être initialisée dans la liste d'initialisation du constructeur. Mais dans ton cas, c'est à dire pour une std::map, j'avoue que je ne sais pas si c'est possible.

Peut-être quelque chose dans le style (en utilisant une map temporaire et la copier):

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
class Mere
{
public:
Mere( const map<string,string> & other ) : map_( other ) {};
const map<string, string> map_;
};
 
class Fille: public Mere
{
public:
Fille( const map<string, string> & other) : Mere(other) {};
};
 
main()
{
   map<string,string> other;
   other["foo"] = "bar";
   Fille fille( other );
}

(à tester)

[r0d]

Ha non, on me fait signe que ça ne marche pas: on ne peut pas initialiser une variable membre static const dans le constructeur, puisqu'une variable const ne doit être initialisée qu'une fois, et une variable static doit l'être en dehors de la classe.

Mais franchement, une std:map const, ça me parait compliqué :/
Pourquoi ne pas l'encapsuler dans une structure et s'arranger pour que cette structure ne soit manipulée que par références constantes?

De toutes façons, ça n'a pas vraiment de sens ce que tu veux faire. Enfin, je ne le vois pas.