Llamar a métodos de clase C ++ a través de un puntero de función

¿Cómo obtengo un puntero de función para una función miembro de clase y luego llamo a esa función miembro con un objeto específico? Me gustaría escribir:

class Dog : Animal
{
    Dog ();
    void bark ();
}

…
Dog* pDog = new Dog ();
BarkFunction pBark = &Dog::bark;
(*pBark) (pDog);
…

Además, si es posible, también me gustaría invocar el constructor a través de un puntero:

NewAnimalFunction pNew = &Dog::Dog;
Animal* pAnimal = (*pNew)();    

¿Es esto posible y, de ser así, cuál es la forma preferida de hacerlo?

Lea esto para obtener más detalles:

// 1 define a function pointer and initialize to NULL

int (TMyClass::*pt2ConstMember)(float, char, char) const = NULL;

// C++

class TMyClass
{
public:
   int DoIt(float a, char b, char c){ cout << "TMyClass::DoIt"<< endl; return a+b+c;};
   int DoMore(float a, char b, char c) const
         { cout << "TMyClass::DoMore" << endl; return a-b+c; };

   /* more of TMyClass */
};
pt2ConstMember = &TMyClass::DoIt; // note: <pt2Member> may also legally point to &DoMore

// Calling Function using Function Pointer

(*this.*pt2ConstMember)(12, 'a', 'b');

¿Cómo obtengo un puntero de función para una función miembro de clase y luego llamo a esa función miembro con un objeto específico?

Es más fácil comenzar con un typedef. Para una función miembro, agrega el nombre de clase en la declaración de tipo:

typedef void(Dog::*BarkFunction)(void);

Luego, para invocar el método, usa el ->*operador:

(pDog->*pBark)();

Además, si es posible, también me gustaría invocar el constructor a través de un puntero. ¿Es esto posible y, de ser así, cuál es la forma preferida de hacerlo?

No creo que puedas trabajar con constructores como este, los ctors y dtors son especiales. La forma normal de lograr ese tipo de cosas sería usando un método de fábrica, que es básicamente una función estática que llama al constructor por usted. Consulte el código a continuación para ver un ejemplo.

He modificado su código para hacer básicamente lo que describe. Hay algunas advertencias a continuación.

#include <iostream>

class Animal
{
public:

    typedef Animal*(*NewAnimalFunction)(void);

    virtual void makeNoise()
    {
        std::cout << "M00f!" << std::endl;
    }
};

class Dog : public Animal
{
public:

    typedef void(Dog::*BarkFunction)(void);

    typedef Dog*(*NewDogFunction)(void);

    Dog () {}

    static Dog* newDog()
    {
        return new Dog;
    }

    virtual void makeNoise ()
    {
        std::cout << "Woof!" << std::endl;
    }
};

int main(int argc, char* argv[])
{
    // Call member function via method pointer
    Dog* pDog = new Dog ();
    Dog::BarkFunction pBark = &Dog::makeNoise;

    (pDog->*pBark)();

    // Construct instance via factory method
    Dog::NewDogFunction pNew = &Dog::newDog;

    Animal* pAnimal = (*pNew)();

    pAnimal->makeNoise();

    return 0;
}

Ahora bien, aunque normalmente puede usar un Dog*en lugar de un Animal*gracias a la magia del polimorfismo, el tipo de puntero de función no sigue las reglas de búsqueda de la jerarquía de clases. Por lo tanto, un puntero de método Animal no es compatible con un puntero de método Dog, en otras palabras, no puede asignar un Dog* (*)()a una variable de tipo Animal* (*)().

El newDogmétodo estático es un ejemplo simple de una fábrica, que simplemente crea y devuelve nuevas instancias. Al ser una función estática, tiene una función regular typedef(sin calificador de clase).

Habiendo respondido lo anterior, me pregunto si no existe una mejor manera de lograr lo que necesita. Hay algunos escenarios específicos en los que haría este tipo de cosas, pero es posible que encuentre otros patrones que funcionan mejor para su problema. Si describe en términos más generales lo que está tratando de lograr, ¡la mente colmena puede resultar aún más útil!

En relación con lo anterior, sin duda encontrará muy útiles la biblioteca de enlaces Boost y otros módulos relacionados.

No creo que nadie haya explicado aquí que un problema es que necesita " punteros a miembros " en lugar de punteros a funciones normales.

Los apuntadores de miembros a funciones no son simplemente apuntadores de funciones. En términos de implementación, el compilador no puede usar una dirección de función simple porque, en general, no conoce la dirección a la que llamar hasta que sepa qué objeto desreferenciar (piense en funciones virtuales). También necesita conocer el objeto para proporcionar el thisparámetro implícito, por supuesto.

Habiendo dicho que los necesita, ahora diré que realmente necesita evitarlos. En serio, los consejos para miembros son un fastidio. Es mucho más sensato mirar patrones de diseño orientados a objetos que logren el mismo objetivo, o usar uno boost::functiono lo que sea como se mencionó anteriormente, suponiendo que pueda tomar esa decisión, claro.

Si está proporcionando ese puntero de función a código existente, por lo que realmente necesita un puntero de función simple, debe escribir una función como miembro estático de la clase. Una función miembro estática no comprende this, por lo que deberá pasar el objeto como un parámetro explícito. Hubo una vez un modismo no tan inusual en este sentido para trabajar con código C antiguo que necesita punteros de función

class myclass
{
  public:
    virtual void myrealmethod () = 0;

    static void myfunction (myclass *p);
}

void myclass::myfunction (myclass *p)
{
  p->myrealmethod ();
}

Dado myfunctionque en realidad es solo una función normal (dejando de lado los problemas del alcance), se puede encontrar un puntero de función en la forma C normal.

EDITAR : este tipo de método se denomina "método de clase" o "función miembro estática". La principal diferencia con una función que no es miembro es que, si hace referencia a ella desde fuera de la clase, debe especificar el alcance utilizando el ::operador de resolución de alcance. Por ejemplo, para obtener el puntero de función, use &myclass::myfunctiony para llamarlo use myclass::myfunction (arg);.

Este tipo de cosas es bastante común cuando se utilizan las antiguas API de Win32, que fueron diseñadas originalmente para C en lugar de C ++. Por supuesto, en ese caso, el parámetro normalmente es LPARAM o similar en lugar de un puntero, y se necesita algo de conversión.

typedef void (Dog::*memfun)();
memfun doSomething = &Dog::bark;
....
(pDog->*doSomething)(); // if pDog is a pointer
// (pDog.*doSomething)(); // if pDog is a reference

Ejemplo ejecutable mínimo

main.cpp

#include <cassert>

class C {
    public:
        int i;
        C(int i) : i(i) {}
        int m(int j) { return this->i + j; }
};

int main() {
    // Get a method pointer.
    int (C::*p)(int) = &C::m;

    // Create a test object.
    C c(1);
    C *cp = &c;

    // Operator .*
    assert((c.*p)(2) == 3);

    // Operator ->*
    assert((cp->*p)(2) == 3);
}

Compilar y ejecutar:

g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp
./main.out

Probado en Ubuntu 18.04.

No puede cambiar el orden de los paréntesis ni omitirlos. Lo siguiente no funciona:

c.*p(2)
c.*(p)(2)

GCC 9.2 fallaría con:

main.cpp: In function ‘int main()’:
main.cpp:19:18: error: must use ‘.*’ or ‘->*’ to call pointer-to-member function in ‘p (...)’, e.g. ‘(... ->* p) (...)’
   19 |     assert(c.*p(2) == 3);
      |

Estándar C ++ 11

.*y ->*son operadores únicos introducidos en C ++ para este propósito, y no están presentes en C.

Borrador estándar de C ++ 11 N3337 :

• 2.13 "Operadores y puntuadores" tiene una lista de todos los operadores, que contiene .*y ->*.
• 5.5 "Operadores de puntero a miembro" explica lo que hacen

Vine aquí para aprender cómo crear un puntero de función (no un puntero de método) a partir de un método, pero ninguna de las respuestas aquí proporciona una solución. Esto es lo que se me ocurrió:

template <class T> struct MethodHelper;
template <class C, class Ret, class... Args> struct MethodHelper<Ret (C::*)(Args...)> {
    using T = Ret (C::*)(Args...);
    template <T m> static Ret call(C* object, Args... args) {
        return (object->*m)(args...);
    }
};

#define METHOD_FP(m) MethodHelper<decltype(m)>::call<m>

Entonces, para su ejemplo, ahora haría:

Dog dog;
using BarkFunction = void (*)(Dog*);
BarkFunction bark = METHOD_FP(&Dog::bark);
(*bark)(&dog); // or simply bark(&dog)

Editar:
usando C ++ 17, hay una solución aún mejor:

template <auto m> struct MethodHelper;
template <class C, class Ret, class... Args, Ret (C::*m)(Args...)> struct MethodHelper<m> {
    static Ret call(C* object, Args... args) {
        return (object->*m)(args...);
    }
};

que se puede utilizar directamente sin la macro:

Dog dog;
using BarkFunction = void (*)(Dog*);
BarkFunction bark = MethodHelper<&Dog::bark>::call;
(*bark)(&dog); // or simply bark(&dog)

Para métodos con modificadores como, constes posible que necesite algunas especializaciones más como:

template <class C, class Ret, class... Args, Ret (C::*m)(Args...) const> struct MethodHelper<m> {
    static Ret call(const C* object, Args... args) {
        return (object->*m)(args...);
    }
};

La razón por la que no puede usar punteros de función para llamar a funciones miembro es que los punteros de función ordinarios suelen ser solo la dirección de memoria de la función.

Para llamar a una función miembro, necesita saber dos cosas:

• Que función miembro llamar
• Qué instancia debe usarse (cuya función miembro)

Los punteros de función ordinaria no pueden almacenar ambos. Los punteros de función miembro de C ++ se utilizan para almacenar a), por lo que es necesario especificar la instancia explícitamente al llamar a un puntero de función miembro.

Un puntero de función a un miembro de clase es un problema que es realmente adecuado para usar boost :: function. Pequeño ejemplo:

#include <boost/function.hpp>
#include <iostream>

class Dog 
{
public:
   Dog (int i) : tmp(i) {}
   void bark ()
   {
      std::cout << "woof: " << tmp << std::endl;
   }
private:
   int tmp;
};



int main()
{
   Dog* pDog1 = new Dog (1);
   Dog* pDog2 = new Dog (2);

   //BarkFunction pBark = &Dog::bark;
   boost::function<void (Dog*)> f1 = &Dog::bark;

   f1(pDog1);
   f1(pDog2);
}

Para crear un nuevo objeto, puede usar la ubicación nueva, como se mencionó anteriormente, o hacer que su clase implemente un método clone () que cree una copia del objeto. Luego, puede llamar a este método de clonación utilizando un puntero de función miembro como se explicó anteriormente para crear nuevas instancias del objeto. La ventaja de la clonación es que a veces puede estar trabajando con un puntero a una clase base donde no conoce el tipo de objeto. En este caso, un método clone () puede ser más fácil de usar. Además, clone () le permitirá copiar el estado del objeto si eso es lo que desea.

Hice esto con std :: function y std :: bind ..

Escribí esta clase EventManager que almacena un vector de controladores en un mapa unordered_map que asigna tipos de eventos (que son solo const unsigned int, tengo una gran enumeración de espacios de nombres de ellos) a un vector de controladores para ese tipo de evento.

En mi clase EventManagerTests, configuré un controlador de eventos, como este:

auto delegate = std::bind(&EventManagerTests::OnKeyDown, this, std::placeholders::_1);
event_manager.AddEventListener(kEventKeyDown, delegate);

Aquí está la función AddEventListener:

std::vector<EventHandler>::iterator EventManager::AddEventListener(EventType _event_type, EventHandler _handler)
{
    if (listeners_.count(_event_type) == 0) 
    {
        listeners_.emplace(_event_type, new std::vector<EventHandler>());
    }
    std::vector<EventHandler>::iterator it = listeners_[_event_type]->end();
    listeners_[_event_type]->push_back(_handler);       
    return it;
}

Aquí está la definición de tipo EventHandler:

typedef std::function<void(Event *)> EventHandler;

Luego, de vuelta en EventManagerTests :: RaiseEvent, hago esto:

Engine::KeyDownEvent event(39);
event_manager.RaiseEvent(1, (Engine::Event*) & event);

Aquí está el código para EventManager :: RaiseEvent:

void EventManager::RaiseEvent(EventType _event_type, Event * _event)
{
    if (listeners_.count(_event_type) > 0)
    {
        std::vector<EventHandler> * vec = listeners_[_event_type];
        std::for_each(
            begin(*vec), 
            end(*vec), 
            [_event](EventHandler handler) mutable 
            {
                (handler)(_event);
            }
        );
    }
}

Esto funciona. Recibo la llamada en EventManagerTests :: OnKeyDown. Tengo que eliminar los vectores en tiempo de limpieza, pero una vez que lo hago no hay fugas. Generar un evento toma alrededor de 5 microsegundos en mi computadora, que es alrededor de 2008. No exactamente súper rápido, pero. Bastante justo siempre que sepa eso y no lo use en código ultra caliente.

Me gustaría acelerarlo rodando mi propia std :: function y std :: bind, y tal vez usando una matriz de matrices en lugar de un unordered_map de vectores, pero no he descubierto cómo almacenar una función miembro puntero y llamarlo desde un código que no sabe nada sobre la clase que se llama. La respuesta de Eyelash parece muy interesante.