C++: Tableau de pointeurs de fonctions membres vers différentes fonctions

Question

J'ai une classe A qui contient les fonctions membres foo() et bar() qui renvoient toutes deux un pointeur vers la classe B. Comment puis-je déclarer un tableau contenant les fonctions foo et bar en tant que variable membre dans la classe A? Et comment puis-je appeler les fonctions à travers le tableau?

Answer 1

La syntaxe de pointeur de fonction membre est ReturnType (Class::*)(ParameterTypes...), de sorte que par exemple .:

typedef B* (A::*MemFuncPtr)(); // readability 
MemFuncPtr mfs[] = { &A::foo, &A::bar }; // declaring and initializing the array 
B* bptr1 = (pointerToA->*mfs[0])(); // call A::foo() through pointer to A 
B* bptr2 = (instanceOfA.*mfs[0])(); // call A::foo() through instance of A 

Voir, par exemple this InformIT article pour plus de détails sur les pointeurs vers les membres.

Vous pouvez également regarder dans Boost.Bind et Boost.Function (ou leurs équivalents TR1) qui vous permettent de lier de manière opaque les pointeurs de fonctions des membres à une instance:

typedef boost::function<B*()> BoundMemFunc; 
A instanceOfA; 
BoundMemFunc mfs[] = { 
    boost::bind(&A::foo, &instanceOfA), 
    boost::bind(&A::bar, &instanceOfA) 
}; 
B* bptr = mfs[0](); // call A::foo() on instanceOfA 

Pour utiliser un tel tableau comme membre, notez que vous ne pouvez pas initialiser des tableaux à l'aide de la liste des initialiseurs de membres. Ainsi, vous pouvez lui attribuer dans le corps du constructeur:

A::A { 
    mfs[0] = &A::foo; 
} 

... ou vous utilisez un type qui peut effectivement y être initialisé comme std::vector ou boost::array:

struct A { 
    const std::vector<MemFuncPtr> mfs; 
    // ... 
}; 

namespace { 
    std::vector<MemFuncPtr> init_mfs() { 
     std::vector<MemFuncPtr> mfs; 
     mfs.push_back(&A::foo); 
     mfs.push_back(&A::bar); 
     return mfs; 
    } 
} 

A::A() : mfs(init_mfs()) {} 

Answer 2

Qu'est-ce que vous cherchez pour sont pointeurs vers les fonctions membres. Voici un petit exemple qui montre leur déclaration et l'utilisation:

#include <iostream> 

class B { 
public: 
    B(int foo): foo_(foo) { 
    std::cout << "Making a B with foo_ = " << foo_ << std::endl; 
    } 
    ~B(void) { 
    std::cout << "Deleting a B with foo_ = " << foo_ << std::endl; 
    } 
    int foo_; 
}; 

class A { 
public: 
    A(void) { 
    funcs_[0] = &A::foo; 
    funcs_[1] = &A::bar; 
    } 

    B* foo(void) { 
    return new B(3); 
    } 

    B* bar(void) { 
    return new B(5); 
    } 

    // Typedef for the member function pointer, for everyone's sanity. 
    typedef B* (A::*BMemFun)(void); 
    BMemFun funcs_[2]; 
}; 

int main(int argc, char *argv[]) { 
    A a; 
    for (int i = 0; i < 2; ++i) { 
    A::BMemFun func = a.funcs_[i]; 
    // Call through the member function pointer (the .* operator). 
    B* b = (a.*func)(); 
    delete b; 
    } 
    return 0; 
} 

Le C++ FAQ section on pointers to member functions est là que je trouve toutes ces informations.