Discussion :

[guidono2]

Bonjour,

Afin de régler un problème d'affichage dans le cadre d'un exercice de programmation parallèle, je bute sur un problème : dans ma classe A, je veux une méthode, qui me permette d'executer la méthode passée en paramètre (avec des instructions en plus). Dans ma classe B, qui hérite de ma classe A, je veux pouvoir appeler cette méthode de A, dans B, avec comme paramètre un pointeur sur une méthode de B.

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
 
class A {
    void virtual routine() {}
    void executer(void (*function)(int), int param) {
        instruction();
        (*function)(param);
        instruction();
    }
};
 
class B : A {
    void routine() {
        executer(&ma_fct, 2);
    }
    void ma_fct(int p) {
        cout << p << endl;
    }
};

Mais je ne parviens pas à faire fonctionner ce code... Il est évidamment faux ici, j'ai commencé par utiliser (*A::function) dans la déclaration présente dans A, mais du coup je me retrouve avec &B::ma_fct comme paramètre de executer() dans la classe B...

Vous auriez une idée pour résoudre ce problème ?

Bonne journée !

[Iradrille]

Hello,

Plusieurs solutions : std::function, ou pointeur de fonction + cast.

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
41
42
43
#include <iostream>
#include <functional>
 
class A {
public:
	void virtual routine() {}
	void executer(std::function<void(int)> fct, int param) {
		fct(param);
	}
 
	void executer2(std::function<void(void)> fct) {
		fct();
	}
 
	template <class T>
	void executer3(void (T::*fct)(int), int param) {
		static_assert(std::is_base_of<A, T>::value, "nop.png");
		(static_cast<T*>(this)->*fct)(param);
	}
};
 
class B : public A {
public:
	void routine() {
		executer([this](int i) { ma_fct(i); }, 1);
		executer(std::bind(&B::ma_fct, this, std::placeholders::_1), 2);
 
		executer2(std::bind(&B::ma_fct, this, 3));
 
		executer3(&B::ma_fct, 4);
	} 
 
	void ma_fct(int p) {
		std::cout << p << std::endl;
	}
};
 
int main() {
	B b;
	b.routine();
 
	return 0;
}

[Bousk]

Et pourquoi pas du CRTP ?

[guidono2]

Merci pour ton aide Iradrille ! Ca marche nickel !

Bousk : Pourrais tu être plus précis concernant ton idée ?

[JolyLoic]

As-tu besoin que ma_fct soit non statique ? C'est ça qui cause ton soucis et qu'Iradrille essaye de corriger à coup de bind.

Sinon, de nos jours, je trouve un lambda plus clair et générique qu'un bind :

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
class A {
    void virtual routine() {}
    void executer(std::function<void(int)> f, int param) {
        instruction();
        f(param);
        instruction();
    }
};
 
class B : A {
    void routine() {
        executer([this](int param){this->ma_fct(param);} , 2);
    }
    void ma_fct(int p) {
        cout << p << endl;
    }
};

[Captain'Flam]

Un mois après, j'apporte mon grain de sel (si quelqu'un suit encore ce fil) :

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
41
42
43
44
45
#include <iostream>
using namespace std ;
 
struct A
    {
    typedef void (A::*t_fct) ( int ) ;
    virtual void ma_fct1 ( int ) = 0 ;
    virtual void ma_fct2 ( int ) = 0 ;
    virtual void ma_fct3 ( int p )
        {
        cout << "A::ma_fct3(" << p << ")" << endl ;
        }
    void executer ( t_fct func, int param )
        {
        (this->*func)( param ) ;
        }
    };
 
struct B : A
    {
    void ma_fct1 ( int p )
        {
        cout << "B::ma_fct1(" << p << ")" << endl ;
        }
    void ma_fct2 ( int p )
        {
        cout << "B::ma_fct2(" << p << ")" << endl ;
        }
    void ma_fct4 ( int p )
        {
        cout << "B::ma_fct4(" << p << ")" << endl ;
        }
    void routine ()
        {
        executer( &A::ma_fct1,2 ) ;
        executer( &A::ma_fct2,3 ) ;
        executer( ma_fct3,4 ) ;
     // executer( &A::ma_fct4,3 ) ; // error: 'ma_fct4' is not a member of 'A'
        }
    };
int main ()
    {
    B b ;
    b.routine() ;
    }

La sortie :

Code :

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

1
2
3
B::ma_fct1(2)
B::ma_fct2(3)
A::ma_fct3(4)

Voilà, pas besoin de template, ni de cast, ni d'aucune version récente de c++...
La seule ombre : je ne m'explique pas la nécessité d'ajouter &A:: devant ma_fct1 et ma_fct2.