Discussion :

[Caduchon]

Bonjour,

Je suis à la recherche de la bonne formulation. J'ai pu écrire ceci qui fonctionne:

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
 
class A
{
	public:
		A() {}
		~A() {}
		void run() { result = (*ptr)(); }
	protected:
		bool result;
		bool (*ptr)();
};
 
class B: public A
{
	public:
		B() { ptr = &myFunction; }
		~B() {}
		static bool myFunction() { return true; }
};
 
int main()
{
	A* p = new B();
	p->run();
 
	return 0;
}

Mais j'aimerais pouvoir faire là même chose sans que ma fonction dans la classe B ne soit statique. C'est à dire quelque chose qui pourrait ressembler à ceci (qui ne marche pas):

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
 
class A
{
	public:
		A() {}
		~A() {}
		void run() { result = (*ptr)(); }
	protected:
		bool result;
		bool (A::* ptr)();
};
 
class B: public A
{
	public:
		B() { ptr = &myFunction; }
		~B() {}
		bool myFunction() { return true; }
};
 
int main()
{
	A* p = new B();
	p->run();
 
	return 0;
}

Auriez-vous comme toujours une bonne idée en stock ?

Caduchon.

[Nogane]

Bonjour,
Pour ca, il y a les boost::function:

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 A
{
	public:
		void run() { result = ptr(); }
	protected:
		bool result;
		boost::function<bool> ptr;
};
 
class B: public A
{
	public:
		B() { ptr = boost::bind(&B::myFunction, this); }
		bool myFunction() { return true; }
};

Mais pourquoi ne pas faire de "ptr" une fonction virtuel, surchargé par la class B?

[r0d]

Bonjour,

il y a plusieurs solutions. J'en connais 3.
La première consiste à utiliser boost::function.
La seconde consiste à utiliser des foncteurs, mais ça dépend de la façon dont tu utilises ce pointeur de fonction.
La troisième consiste à utiliser les adaptateurs de la stl (voir le chapitre I-C de cet article).

[3DArchi]

=> L'appel d'un pointeur sur une fonction membre, c'est

Code :

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

void run() { result = (this->*ptr)(); }

Mais tu ne vas pas y arriver à cause de ça :

Code :

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

B() { ptr = &B::myFunction; } // error: cannot convert 'bool (B::*)()' to 'bool (A::*)()' in assignment

Cependant, il y a quelque chose d'intéressant qui s'appelle les fonctions virtuelles

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
class A
{
	public:
		A() {}
		virtual ~A() {}
		void run() { result = do_run(); }
	protected:
		bool result;
		virtual bool do_run()=0;
    private:
};
 
class B: public A
{
	public:
		~B() {}
		bool do_run() { return true; }
};
 
int main()
{
	A* p = new B();
	p->run();
 
	delete p;
 
	return 0;
}

[Caduchon]

Merci pour vos réponses.

Comme je l'ai déjà mentionné dans un autre post, boost ne me convient pas pour le moment. Difficile à installer, etc...

Je sais bien qu'il existe des fonctions virtuelles, mais en virtualisant la fonction run, je ne ferais que dupliquer son contenu, qui sera identique quelle que soit la classe héritée. En plus d'être de la duplication de code, c'est un code très long, très moche (en gros, ça génère des fichiers .log). Et troisièmement, c'est au client d'écrire les héritages de la classe A, qui seront très nombreux. Ce n'est pas au client à écrire dans chacune des classes héritées une copie de la fonction virtuelle.

Je vais m'orienter vers les foncteurs. Si j'arrive à faire simple, ça peut être une solution de demander au client d'écrire un foncteur plutôt qu'une fonction. Même si l'écriture d'une fonction était la version vraiment simple pour lui.

[3DArchi]

Je sais bien qu'il existe des fonctions virtuelles, mais en virtualisant la fonction run, je ne ferais que dupliquer son contenu, qui sera identique quelle que soit la classe héritée. En plus d'être de la duplication de code, c'est un code très long, très moche (en gros, ça génère des fichiers .log). Et troisièmement, c'est au client d'écrire les héritages de la classe A, qui seront très nombreux. Ce n'est pas au client à écrire dans chacune des classes héritées une copie de la fonction virtuelle

J'ai rien compris. Tu n'es pas obligé de spécialiser la fonction virtuelle (à ce moment ne pas la définir pure dans la classe de base) dans les classes dérivées si un comportement par défaut te convient.

[Caduchon]

J'ai opté pour les foncteurs. Pratiques ces p'tites bêtes !

Merci.