Discussion :

[kandro]

Bonjour,
Je poste ce message pour tenter de résoudre un problème qui est apparu lorsque j'ai tenté d'adapter un programme OpenGL en fonction des extensions présentes sur une machine (mon problème ne relève pas de l'API OpenGL mais du C++ même). J'ai une classe qui permet la création et l'utilisation d'un contexte OpenGL, dans cette classe une méthode doit permettre l'affichage de données à l'écran. Le problème étant que je voulais choisir quelle méthode serait exécutée en fonction de la présence ou non d'une extension OpenGL. J'ai fait quelque chose dans ce goût là :

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
29
30
31
32
33
34
35
36
37
class Toto
{
public:
	Toto();
	~Toto();
 
private:
	void (*fonction)();
};
 
static void tata()
{
	//Faire tata
}
 
static void titi()
{
	//Faire titi
}
 
Toto::Toto
	:fonction(0)
{
	if(maCondition)
		fonction = &tata;
	else
		fonction = &titi:
}
 
int main()
{
	Toto toto;
 
	toto.fonction();
 
	return 0;
}

Le problème est qu'ici la donnée membre fonction est private pour éviter qu'on puisse la changer de n'importe qu'elle manière. Il est donc impossible de faire appel à la fonction pointée par la donnée membre fonction en dehors de la classe Toto. Il est bien sur possible de créer une méthode publique qui réalise l'appel à cette fonction, mais n'y a-t-il pas une manière plus élégante de faire les choses ?

[GR3lh442kR]

Mon avis :
La manière élégante c'est justement d'utiliser une fonction pour exécuter ta fonction membre.

Si pour une raison quelconque tu décide d'initialiser ton pointeur sur fonction comme ceci (c'est un exemple)

Code :

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

1
2
3
4
5
6
Toto::Toto:fonction(0){
	if(maCondition)
		fonction = &tata;
	else 
		fonction = NULL;
}

tu seras bien content de pouvoir vérifier que ton pointeur n'est pas NULL dans ta fonction d’exécution sans avoir a modifier tous les accès a ta fonction

Code :

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

1
2
3
4
void Toto::executer(){
	if(fonction != NULL)
		fonction();
}

[koala01]

Salut,

La spécificité des membres se trouvant dans l'accessibilité privée est, justement, de n'être accessibles depuis les fonctions membres de la classe.

Si tu veux pouvoir accéder à un membre privé (qui serait un pointeur de fonction en l'occurrence) depuis "l'extérieur de ta classe", tu as deux solutions : soit tu y accède de manière "plus ou moins indirecte" au travers d'une fonction publique sous une forme proche de

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
 
void bar(){
    std::cout<<"bar"<<std::endl;
}
void other(){
    std::cout<<"other"<<std::endl;
}
class MyClass{
    public:
        MyClass(bool context):funPtr_(context? bar : other){}
        void doIt(){
            funPtr_();
        }
    private:
        void (*funPtr_)();
};
int main(){
    MyClass obj(true);
    obj.doIt();
    MyClass obj1(false);
    obj1.doIt();
}

soit tu peux envisager l'amitié qui te permet d'éviter d'exposer un service qui n'a un intérêt que "pour un nombre particulièrement" restreint de fonctions.

Cela pourrait, par exemple, prendre la forme de

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
29
 
void bar(){
    std::cout<<"bar"<<std::endl;
}
void other(){
    std::cout<<"other"<<std::endl;
}
 
class MaClass{
 
    friend void foo(MaClass const & obj);
public:
    MaClass(bool context):fptr_(context? bar :  other){
    }
private:
    void (*fptr_)();
};
 
void foo(MaClass const & obj){
    obj.fptr_();
}
int main()
{
    MyClass obj(true);
    MyClass obj1(false);
    foo(obj);
    foo(obj1);
    return 0;
}

Note qu'il faut impérativement éviter de tomber dans le piège qui consisterait à placer un (pointeur de fonction) membre en accessibilité si c'est pour rajouter une tonne de fonctions qui pourront y accéder par amitié : Utilisée avec parcimonie, l'amitié peut très largement favoriser l'encapsulation, mais si tu commence à déclarer tout et n'importe quoi ami d'une de tes classes, tu obtiens strictement l'effet inverse

Ceci dit, je ne suis pas du tout favorable ( quel doux euphémisme pour dire que je suis farouchement opposé ) à l'utilisation des pointeurs de fonctions.

Si Tu dois, en effet, te dire que le contexte dans lequel tu devras travailler est -- très certainement -- un contexte global et que tu n'auras sans doute pas une mais... plusieurs classes qui devront modifier leur comportement en fonction de ce contexte.

Si tu cherches une solution réellement élégante, tu devrais peut être te mettre à penser réellement avec une approche OO ou, pourquoi pas, avec une approche génrique : les solutions "élégantes" tireront sans doute très largement parti du polymorphisme (qu'il soit d'inclusion, ad-hoc ou de coercition ) et / ou de politique clairement exprimées et correctement exploitées

[JolyLoic]

J'ai l'impression que tu résoudrais ton problème en rendant fonction publique, mais constante (il faudrait alors l'initialiser avec ?: plutôt qu'avec un if).

[kandro]

Bonjour,
Tout d'abord, merci de vos réponses, je vais prendre la solution du polymorphisme, si j'ai bien comprit, je devait avoir un programme de cette forme :

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
29
30
31
32
33
34
35
36
37
38
39
40
class Toto
{
public:
	virtual void faireToto() = 0;
};
 
class Titi : public Toto
{
public:
	void faireToto()
	{
		//Faire Titi
	}
};
 
class Tata : public Toto
{
public:
	void faireTata()
	{
		//Faire Titi
	}
};
 
int main()
{
	Toto *toto;
	if(maCondition)
	{
		toto = new Tata;
	}
	else
	{
		toto = new Titi;
	}
 
	toto->faireToto();
 
return 0;
}