C++: matriz de punteros de función miembro a diferentes funciones

Question

Tengo una clase A que contiene funciones miembro foo() y barra() que devuelven un puntero a clase B. ¿Cómo puedo declarar una matriz que contiene las funciones foo y barra como una variable miembro en la clase A? ¿Y cómo llamo a las funciones a través de la matriz?

Answer 1

La sintaxis puntero de función miembro es ReturnType (Class::*)(ParameterTypes...), por lo que por ejemplo .:

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 

Véase, por ejemplo this InformIT article para más detalles sobre punteros a los miembros.

También puede ser que desee ver en Boost.Bind y Boost.Function (o sus equivalentes TR1) que le permiten enlazar opaca las de función triples miembros a una instancia:

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 

utilizar una matriz tal como una miembro, tenga en cuenta que no puede inicializar matrices utilizando la lista de inicializadores de miembros. De este modo se puede asignar a cualquiera en el cuerpo del constructor:

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

... o usar un tipo que realmente puede ser inicializado allí como std::vector o 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

Lo que estás buscando para son punteros a funciones miembro. Aquí está una muestra corta que muestra su declaración y uso:

#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; 
} 

El C++ FAQ section on pointers to member functions es donde me encontré con toda esta información.