problème d'appel de méthode

Version imprimable

Bonjour

J'ai un petit problème et je ne sais pas si c'est possible (j'aimerais bien quand même :) )

Dans les exemple ci dessous je souhaiterais que le dernier appel arrive dans

Code:

1
2
 
static void fromString( materielB* t)

Ce code n'est qu'un exemple et ne fait absolument pas ce qu'il devrait faire au vu des nom de méthodes. Si besoin je renomme et clarifie le code.
Je suis sur VS2005, mais j'ai testé le code dans sans template avec gcc aussi (je n'ai pas réussi à le compilé avec les template ... mais la n'est pas le problème)

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
 
 
#include <iostream>
 
class materiel
{
public:
	virtual bool dosomeThing() = 0;
};
 
class materielA : public materiel
{
public:
	virtual bool dosomeThing(){return true;}
 
};
 
class materielB : public materiel
{
public:
	virtual bool dosomeThing(){return true;}
 
};
 
class materielC : public materiel
{
public:
	virtual bool dosomeThing(){return true;}
 
};
 
 
class IsGoodArg
{
public:
 
	template<typename T> 
	static void isGoodArg( T* t )
	{
		std::cout << "generic"  << std::endl;
	}
 
	template<>
	static void isGoodArg<materielC>( materielC* t)
	{
		std::cout << "materielC"  << std::endl;
	}
 
	template<>
	static void isGoodArg<materielB>( materielB* t)
	{
		std::cout << "materielB"  << std::endl;
	}
 
};
int main(int argc, char* argv[])
{
 
	materielA a;
	materielB b;
	materielC c;
 
	materiel *d = new materielB();
	IsGoodArg::isGoodArg(&a);
	IsGoodArg::isGoodArg(&b);
	IsGoodArg::isGoodArg(&c);
	IsGoodArg::isGoodArg(d);
 
	return 0;
}

J'ai aussi essayé sans template. J'étais parti sur des template mais au final il ne me sont pas forcément utile

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
 
 
#include <iostream>
 
class materiel
{
public:
	virtual bool dosomeThing() = 0;
};
 
class materielA : public materiel
{
public:
	virtual bool dosomeThing(){return true;}
 
};
 
class materielB : public materiel
{
public:
	virtual bool dosomeThing(){return true;}
 
};
 
class materielC : public materiel
{
public:
	virtual bool dosomeThing(){return true;}
 
};
 
 
class IsGoodArg
{
public:
 
	static void isGoodArg( materiel* t )
	{
		std::cout << "generic"  << std::endl;
	}
 
	static void isGoodArg( materielC* t)
	{
		std::cout << "materielC"  << std::endl;
	}
 
	static void isGoodArg( materielB* t)
	{
		std::cout << "materielB"  << std::endl;
	}
};
 
int main(int argc, char* argv[])
{
 
	materielA a;
	materielB b;
	materielC c;
 
	materiel *d = new materielB();
	IsGoodArg::isGoodArg(&a);
	IsGoodArg::isGoodArg(&b);
	IsGoodArg::isGoodArg(&c);
	IsGoodArg::isGoodArg(d);
 
	return 0;
}

Merci à tous les curieux qui passeront.
Un plus grand merci à ceux qui auront peut être une idée à me soumettre :)

Ambroise

Bonjour Ambroise,

Tes exemples utilisent :
méthode virtuelle pour dosomeThing(), permet de retrouver à l'exécution l'action correspondant à l'objet appelant.
méthode template pour isGoodArg(), la sélection de la fonction dépend de la valeur 'au moment de la compilation'
méthode avec surdéfinition de isGoodArg(), même capacité qu'avec le templates.
Tu as bien parcouru les possibilités. Tu souhaites une action où la fonction à retrouver dépend du 'vrai' type de l'objet (comme le cas a), mais sélectionne à partir d'un paramètre (comme les cas b et c.)
Le seul moyen de retrouver un type dynamique est l'utilisation de méthodes virtuelles (ou les dynamic_cast<>())
Et comme la sélection par paramètre nécessite une surdéfinition ou des template. Je te propose de relier ces capacités par une fonction 'relai'.
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 class materiel { public: virtual void relay() = 0; }; class materielA : public materiel { public: void relay() override; }; class materielB : public materiel { public: void relay() override; }; class IsGoodArg { public: static void isGoodArg( materielA* t) { std::cout << "materielC" << std::endl; } static void isGoodArg( materielB* t) { std::cout << "materielB" << std::endl; } }; void materielA::relay() { IsGoodArg::isGoodArg( this ); /*appelera isGoodArg( materielA* )*/ } void materielB::relay() { IsGoodArg::isGoodArg( this ); /*appelera isGoodArg( materielB* )*/ }

10/04/2017, 09h06
ambroise_petitgenet

Bonjour dalfab,

Effectivement sur mes templates j'ai confondu instance et type de données.
Et effectivement, j'avais oublié deux ou trois principes sur l'héritage.

J'ai bien ton idée de relay. Je vais essayer de le modifier pour mes besoins.

En tout cas merci de ton aide

Ambroise