Héritage initialisation membre const

Version imprimable

Bonjour,

Je suis confronté à un petit problème pour l'initialisation d'un membre const avec une fonction.

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
#include <map>
#include <string>
#include <iostream>
 
using namespace std ;
 
class Toto
{
	const map<string,string> s_map;
 
protected:
	virtual const map<string,string> init()
	{
		map<string,string> ret ;
		ret["h1"] = "value1" ;
		return ret ;
	}
public:
	Toto() : s_map( init() ) {}
	~Toto() {}
	inline const map<string,string>& getMap() { return s_map; }
};
 
class SuperToto : public Toto
{
protected:
	virtual const map<string,string> init()
	{
		map<string,string> ret = Toto::init();
		ret["h2"] = "value2" ;
		return ret ;
	}
 
public:
	SuperToto() {}
};
 
int main()
{
	SuperToto toto ;
	map<string,string>::const_iterator it = toto.getMap().find("h2");
	if ( it != toto.getMap().end() )
		cout << (*it).second << endl ;
	else
		cout << "Not found" << endl ;
}

Ma question est pourquoi la fonction SuperToto::init() n'est pas appeler automatiquement? Merci d'avance.

Salut

Tu ne peux pas appeler une méthode de l'objet dans la liste d'initialisation ! Une solution est de passer la méthode en statique :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class Toto { const map<string,string> s_map; protected: static map<string,string> init() { map<string,string> ret ; ret["h1"] = "value1" ; return ret ; } public: Toto() : s_map( init() ) {} ~Toto() {} inline const map<string,string>& getMap() { return s_map; } };

26/05/2011, 12h16
themadmax

Euh, en fait mon exemple compile et fonctionne (VS2008) mais c'est la surcharge de la fonction init qui n'est pas appeler, je ne pense pas que l’utilisation d'une déclaration static résolve mon problème.
26/05/2011, 12h22
3DArchi

Salut,

Pendant la construction (ou du destruction) d'un objet, la fonction virtuelle appelée est celle du type du constructeur/destructeur en cours d'exécution et non du type final de l'objet en cours de construction/destruction. Pour une fonction virtuelle pure, le comportement dans la classe abstraite est indéterminée.

Cf Quand est construit le type dynamique ou quel est l'impact des appels de fonctions virtuelles dans un constructeur ?

En d'autres termes et compte tenu que ta map est const, tu ne peux pas faire de cette façon. Une solution est de passer un initialiseur à ton constructeur en s'appuyant éventuellement sur une fonction statique comme proposée par Jean Bernard :

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
#include <map>
#include <string>
#include <iostream>
#include <algorithm>
 
 
class Toto
{
	const std::map<std::string,std::string> s_map;
 
protected:
	static const std::map<std::string,std::string> init()
	{
		std::map<std::string,std::string> ret ;
		ret["h1"] = "value1" ;
		return ret ;
	}
public:
    template<class T >
	Toto(T callable_) : s_map( callable_() ) {}
 
 
    Toto()
    :
    // en C++ 0x, avec la délégation de constructeur :
    // Toto( &Toto::init ) {}
    s_map(init())
    {
 
    }
 
 
	virtual ~Toto() {}
	inline const std::map<std::string,std::string>& getMap() { return s_map; }
};
 
class SuperToto : public Toto
{
private:
	static const std::map<std::string,std::string> init()
	{
		std::map<std::string,std::string> ret = Toto::init();
		ret["h2"] = "value2" ;
		return ret ;
	}
 
public:
	SuperToto():Toto(&SuperToto::init) {}
};
 
 
template<class T>
void test()
{
	T toto ;
	auto toto_map = toto.getMap(); // auto de C++0x
   std::for_each(
       toto_map.begin(),
       toto_map.end(),
       [](std::pair<std::string,std::string> const&pair_) // et un p'tit foncteur C++ 0x car cela le vaut bien ;)
        {
            std::cout<<"["<<pair_.first<<"] = "<<pair_.second<<" ; ";
        }
   );
   std::cout<<"\n";
}
 
int main()
{
    test<Toto>();
 
    test<SuperToto>();
    return 0;
}

26/05/2011, 14h44
jblecanard

Je comprend ce que tu veux faire, mais il va à mon avis falloir passer par une autre solution.

Ce que je ferais à ta place, c'est passer la map à initialiser en argument et créer les objets avec des factory. Tu peux par exemple utiliser une factory statique ou bien l'amitié pour bien protéger tout ça.
26/05/2011, 15h17
3DArchi

Citation:

Envoyé par jblecanard

Ce que je ferais à ta place, c'est passer la map à initialiser en argument et créer les objets avec des factory. Tu peux par exemple utiliser une factory statique ou bien l'amitié pour bien protéger tout ça.

La map est const, elle ne peut donc être passée à une fonction pour construction. La solution que je propose avec une 'fabrique de map' en paramètre template du constructeur permet de construire la map en déléguant la construction effective à l'extérieur de la classe toto. Le paramètre template peut être un membre (static il va de soi) de la classe de base, de la classe dérivée ou un 'callable' externe (jouant le rôle de fabrique de la map) sans besoin d'amitié.
26/05/2011, 15h31
jblecanard

Citation:

Envoyé par 3DArchi

La map est const, elle ne peut donc être passée à une fonction pour construction.

Pourquoi ne pourrait-elle pas être passée en argument du constructeur ? La factory appelle le constructeur de l'objet avec la bonne map. Il suffit de protéger le constructeur de sorte que seule la factory y ait accès et le tour est joué. Mais je ne me suis pas très bien exprimé. Je parlais bien sûr d'une fabrique de Toto et pas d'une fabrique de map.

Mais sinon ça marche aussi avec ta technique, oui.