C++. Méthode de la classe des pointeurs

Il existe une classe

class A {
public:
    A() {};

private:
    void func1(int) {};
    void func2(int) {};


};

Je veux ajouter un pointeur de fonction qui sera crée dans le constructeur et les points à func1 ou func2.

Pour que je puisse appeler ce pointeur (en tant que membre de la classe) de chaque classe de procédure et de définir le pointeur this dans le constructeur.

Comment puis-je le faire?

Selon votre objectif, l'héritage virtuel ou d'un modèle qui pourrait être plus approprié, FWIW.

OriginalL'auteur Nikita | 2010-07-23

c++class methods pointers

8
```
class A {
public:
    A(bool b) : func_ptr_(b ? &A::func1 : &A::func2) {};

    void func(int i) {this->*func_ptr(i);}

private:
    typedef void (A::*func_ptr_t_)();
    func_ptr_t_ func_ptr_;

    void func1(int) {};
    void func2(int) {};
};
```
Cela dit, polymorphisme pourrait être une meilleure manière de faire ce que vous voulez faire avec cette.

Certainement. C'est délicat et inhabituelle de syntaxe pour une raison. C'est exactement le problème OO résout facilement.
Le Code ne compile pas (sur XCode au moins), vous avez déclaré func_ptr_ et ensuite utilisé func_ptr...
Je ne sais même pas quoi répondre à cela. Vous êtes allé à la peine de downvote et de commentaires, mais pas pour corriger cette petite erreur?! Eh bien, devinez quoi, je suis le laissant là, maintenant, juste pour vous malgré.
+1 pour le polymorphisme des conseils

OriginalL'auteur sbi
5

Ajouter une variable membre
```
void (A::*ptr)();
```
défini dans le constructeur
```
ptr=&A::func1;
```
(ou de l'utilisation de la liste d'initialiseur) et de l'appeler dans les méthodes d'Une:
```
(this->*ptr)();
```
(this->*ptr)(), pas this->*ptr()
Merci, corrigé.

OriginalL'auteur jpalecek

J'ai compilé et exécuté ce code. Les différents membres ont besoin d'être public, de sorte que vous pouvez passer dans le constructeur. Sinon, ici vous allez.

Cependant, je suis d'accord avec d'autres affiches que c'est presque certainement une mauvaise chose à faire. 😉 Juste faire appeler virtuelle pure, et ensuite faire deux sous-classes de A chaque remplacement invoke().

#include <iostream>
using namespace std;

class A;
typedef void(A::*MyFunc)(int) ;

class A { 
    public: 

        A() {}
        A(MyFunc fp): fp(fp) {}

        void invoke(int a)
        {
            (this->*fp)(a);
        }

        void func1(int a) { cout << "func1 " << a << endl; }
        void func2(int a) { cout << "func2 " << a << endl; }
    private: 

        MyFunc fp;
};

int main()
{
    A* a = new A( & A::func1 );
    a->invoke(5);
    A* b = new A( & A::func2 );
    b->invoke(6);
}

OriginalL'auteur Scott Stafford

2

Voir boost::function un moyen de gérer la fonction et membre de la classe des pointeurs dans un plus OO/C++.

Par exemple (à partir de la documentation) :
```
struct X 
{
  int foo(int);
};

boost::function<int (X*, int)> f;

f = &X::foo;

X x;
f(&x, 5);
```
OriginalL'auteur Scharron
1

Je vous suggère d'utiliser foncteur(ou la fonction de l'objet), plutôt que de pointeur de fonction, parce que l'ancien est plus sûr, et le pointeur de la fonction peut être difficile ou gênant de passer d'un état ou de la fonction de rappel

Un foncteur est fondamentalement une ré-implémentation de l'opérateur() de la classe A, pour une description très détaillée, veuillez vous référer à Wikipédia: http://en.wikipedia.org/wiki/Function_object

Le code doit être quelque chose comme ceci:
```
class A {
public:
    A() {};
    void operator()(int function_index, int parameter) {
    if(function_index == 1)
        func1(parameter);
    else if(function_index == 2)
        func2(parameter);
    else
        { //do your other handling operation
        }
  }


private:
    void func1( int ) {};
    void func2( int) {};
};
```
Par l'utilisation de cette classe:
```
A a;
a(1, 123); //calling func1
a(2, 321); //calling func2
```
OriginalL'auteur shader
0

Pourquoi pensez-vous que c'est une mauvaise chose à faire. J'ai juste besoin d'un pointeur de fonction et je ne veux pas créer deux sous-classes de cette. Alors, pourquoi est-il si mauvais?

Vous n'avez pas à créer deux sous-classes pour elle, A a; est de définir une variable de Un, et a(1, 123), c'est un appel de fonction, et appelle func1 avec entrée param 123; pointeur de fonction peut certainement traiter votre demande, mais foncteur est plus facile à utiliser et la grammaire est élégant. Quand quelqu'un a besoin de plus compliqué caractéristiques de l'appel de fonctions, telles que l'enregistrement de l'état ou alors, ils ont certainement utiliser les foncteurs. Si vous pensez foncteur peut répondre à toutes vos demande, je suis totalement OK avec ça. Je n'ai pas de problème si vous utilisez le C++ "C with classes", mais comme une question de factd, C++ est beaucoup plus que cela.

OriginalL'auteur Nikita

Quelques exemple...

class A; //forward declaration
typedef void (A::*func_type)(int);

class A { 
public:
  A() {
    func_ptr = &A::func1;
  }

  void test_call(int a) {
    (this->*func_ptr)(a);
  }

private:
  func_type func_ptr;

  void func1(int) {}
  void func2(int) {}
};

(this->*ptr)(), pas this->*ptr()

OriginalL'auteur SirDarius

Vous devez vous connecter pour publier un commentaire.