Вызов методов класса C ++ через указатель на функцию

Как получить указатель на функцию для функции-члена класса, а затем вызвать эту функцию-член с конкретным объектом? Я хочу написать:

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

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

Также, если возможно, я хотел бы вызвать конструктор и через указатель:

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

Возможно ли это, и если да, то каков предпочтительный способ сделать это?

Прочтите это для подробностей:

// 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');

Как получить указатель на функцию для функции-члена класса, а затем вызвать эту функцию-член с конкретным объектом?

Проще всего начать с файла typedef. Для функции-члена вы добавляете имя класса в объявление типа:

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

Затем для вызова метода вы используете ->*оператор:

(pDog->*pBark)();

Также, если возможно, я хотел бы также вызвать конструктор через указатель. Возможно ли это, и если да, то каков предпочтительный способ сделать это?

Я не верю, что с такими конструкторами можно работать - ctors и dtors особенные. Обычный способ добиться такого рода вещей - использовать фабричный метод, который в основном представляет собой статическую функцию, вызывающую за вас конструктор. См. Пример кода ниже.

Я изменил ваш код, чтобы в основном делать то, что вы описываете. Ниже приведены некоторые предостережения.

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

Теперь, хотя вы обычно можете использовать Dog*вместо знака Animal*благодарности магию полиморфизма, тип указателя на функцию не соответствует правилам поиска иерархии классов. Таким образом, указатель на метод Animal несовместим с указателем на метод Dog, другими словами, вы не можете присвоить Dog* (*)()a переменной типа Animal* (*)().

Статический newDogметод - это простой пример фабрики, которая просто создает и возвращает новые экземпляры. Будучи статической функцией, она имеет обычный typedef(без классификатора).

Ответив на вышесказанное, мне интересно, нет ли лучшего способа добиться того, что вам нужно. Есть несколько конкретных сценариев, в которых вы бы поступили подобным образом, но вы можете обнаружить, что есть другие шаблоны, которые лучше подходят для вашей проблемы. Если вы опишете в более общих выражениях, чего пытаетесь достичь, коллективный разум может оказаться еще более полезным!

В связи с вышесказанным, вы, несомненно, найдете очень полезными библиотеку привязки Boost и другие связанные модули.

Я не думаю, что кто-то объяснил здесь, что одна из проблем заключается в том, что вам нужны « указатели на элементы », а не обычные указатели на функции.

Указатели на элементы функций - это не просто указатели на функции. С точки зрения реализации, компилятор не может использовать простой адрес функции, потому что, как правило, вы не знаете адрес для вызова, пока не узнаете, для какого объекта разыменовать (подумайте о виртуальных функциях). Вам также необходимо знать объект, чтобы this, конечно же, предоставить неявный параметр.

Сказав, что они вам нужны, теперь я скажу, что вам действительно нужно их избегать. Серьезно, указатели на члены - это боль. Гораздо разумнее взглянуть на объектно-ориентированные шаблоны проектирования, которые достигают той же цели, или использовать boost::functionили что-то еще, как упомянуто выше, если вы сделаете этот выбор, то есть.

Если вы предоставляете этот указатель на функцию существующему коду, поэтому вам действительно нужен простой указатель на функцию, вам следует написать функцию как статический член класса. Статическая функция-член не понимает this, поэтому вам нужно передать объект в качестве явного параметра. Когда-то была довольно необычная идиома в этих строках для работы со старым кодом C, которому нужны указатели на функции.

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

    static void myfunction (myclass *p);
}

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

Поскольку myfunctionна самом деле это обычная функция (не считая проблем с областью видимости), указатель на функцию можно найти обычным способом C.

РЕДАКТИРОВАТЬ - этот вид метода называется «методом класса» или «статической функцией-членом». Основное отличие от функции, не являющейся членом, состоит в том, что если вы ссылаетесь на нее извне класса, вы должны указать область с помощью ::оператора разрешения области. Например, чтобы получить указатель на функцию, используйте &myclass::myfunctionи для его вызова используйте myclass::myfunction (arg);.

Подобные вещи довольно распространены при использовании старых API Win32, которые изначально были разработаны для C, а не C ++. Конечно, в этом случае параметром обычно является LPARAM или аналогичный, а не указатель, и требуется некоторое приведение типов.

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

Минимальный запускаемый пример

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

Скомпилируйте и запустите:

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

Протестировано в Ubuntu 18.04.

Вы не можете изменить порядок скобок или опустить их. Следующие действия не работают:

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

GCC 9.2 завершится ошибкой:

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);
      |

Стандарт C ++ 11

.*и ->*являются одиночными операторами, введенными в C ++ для этой цели и отсутствующими в C.

Стандартный проект C ++ 11 N3337 :

• 2.13 «Операторы и знаки препинания» содержит список всех операторов, который содержит .*и ->*.
• 5.5 "Операторы указателя на член" объясняют, что они делают.

Я пришел сюда, чтобы узнать, как создать указатель на функцию (а не указатель на метод) из метода, но ни один из ответов здесь не дает решения. Вот что я придумал:

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>

Итак, для вашего примера вы бы теперь сделали:

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

Изменить:
используя С ++ 17, есть еще лучшее решение:

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...);
    }
};

который можно использовать напрямую без макроса:

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

Для методов с такими модификаторами, как constвам могут потребоваться дополнительные специализации, например:

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...);
    }
};

Причина, по которой вы не можете использовать указатели функций для вызова функций-членов, заключается в том, что обычные указатели на функции обычно являются просто адресом памяти функции.

Чтобы вызвать функцию-член, вам нужно знать две вещи:

• Какую функцию-член вызывать
• Какой экземпляр следует использовать (чья функция-член)

Указатели на обычные функции не могут хранить и то, и другое. Указатели функций-членов C ++ используются для хранения a), поэтому вам необходимо явно указать экземпляр при вызове указателя функции-члена.

Указатель функции на член класса - это проблема, которая действительно подходит для использования boost :: function. Небольшой пример:

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

Чтобы создать новый объект, вы можете либо использовать новое размещение, как упомянуто выше, либо реализовать в вашем классе метод clone (), который создает копию объекта. Затем вы можете вызвать этот метод клонирования с помощью указателя на функцию-член, как описано выше, для создания новых экземпляров объекта. Преимущество клонирования заключается в том, что иногда вы можете работать с указателем на базовый класс, когда вы не знаете тип объекта. В этом случае проще использовать метод clone (). Кроме того, clone () позволит вам скопировать состояние объекта, если вы этого хотите.

Я сделал это с помощью std :: function и std :: bind ..

Я написал этот класс EventManager, который хранит вектор обработчиков в unordered_map, который сопоставляет типы событий (которые являются просто const unsigned int, у меня их большое перечисление в области имен) на вектор обработчиков для этого типа события.

В моем классе EventManagerTests я настроил обработчик событий, например:

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

Вот функция 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;
}

Вот определение типа EventHandler:

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

Затем снова в EventManagerTests :: RaiseEvent я делаю следующее:

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

Вот код для 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);
            }
        );
    }
}

Это работает. Я получаю вызов в EventManagerTests :: OnKeyDown. Мне нужно удалить векторы, наступает время очистки, но как только я это сделаю, утечек не будет. Создание события на моем компьютере занимает около 5 микросекунд, это примерно в 2008 году. Не совсем быстро, но. Достаточно справедливо, если я знаю это и не использую это в сверхгорячем коде.

Я хотел бы ускорить его, свернув свои собственные std :: function и std :: bind, и, возможно, используя массив массивов, а не unordered_map векторов, но я не совсем понял, как сохранить функцию-член указатель и вызовите его из кода, который ничего не знает о вызываемом классе. Ответ Ресницы выглядит очень интересно ..