Memanggil metode kelas C ++ melalui penunjuk fungsi

Bagaimana cara mendapatkan penunjuk fungsi untuk fungsi anggota kelas, dan kemudian memanggil fungsi anggota tersebut dengan objek tertentu? Saya ingin menulis:

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

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

Juga, jika memungkinkan, saya juga ingin memanggil konstruktor melalui pointer:

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

Apakah ini mungkin, dan jika demikian, cara apa yang lebih disukai untuk melakukan ini?

Baca ini untuk detailnya:

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

Bagaimana cara mendapatkan penunjuk fungsi untuk fungsi anggota kelas, dan kemudian memanggil fungsi anggota tersebut dengan objek tertentu?

Paling mudah untuk memulai dengan a typedef. Untuk fungsi anggota, Anda menambahkan nama kelas di deklarasi type:

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

Kemudian untuk memanggil metode tersebut, Anda menggunakan ->*operator:

(pDog->*pBark)();

Juga, jika memungkinkan, saya juga ingin memanggil konstruktor melalui pointer. Apakah ini mungkin, dan jika demikian, cara apa yang lebih disukai untuk melakukan ini?

Saya tidak percaya Anda dapat bekerja dengan konstruktor seperti ini - pemberi dan penjual itu istimewa. Cara normal untuk mencapai hal semacam itu akan menggunakan metode pabrik, yang pada dasarnya hanyalah fungsi statis yang memanggil konstruktor untuk Anda. Lihat kode di bawah ini sebagai contoh.

Saya telah memodifikasi kode Anda untuk melakukan apa yang pada dasarnya Anda gambarkan. Ada beberapa peringatan di bawah.

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

Sekarang meskipun Anda biasanya dapat menggunakan a Dog*sebagai pengganti Animal*berkat keajaiban polimorfisme, jenis penunjuk fungsi tidak mengikuti aturan pencarian hierarki kelas. Jadi penunjuk metode Hewan tidak kompatibel dengan penunjuk metode Anjing, dengan kata lain Anda tidak dapat menetapkan a Dog* (*)()ke variabel tipe Animal* (*)().

newDogMetode statis adalah contoh sederhana dari sebuah pabrik, yang hanya membuat dan mengembalikan instance baru. Menjadi fungsi statis, ia memiliki reguler typedef(tanpa kualifikasi kelas).

Setelah menjawab pertanyaan di atas, saya bertanya-tanya apakah tidak ada cara yang lebih baik untuk mencapai apa yang Anda butuhkan. Ada beberapa skenario khusus di mana Anda akan melakukan hal semacam ini, tetapi Anda mungkin menemukan ada pola lain yang bekerja lebih baik untuk masalah Anda. Jika Anda mendeskripsikan dalam istilah yang lebih umum apa yang ingin Anda capai, pikiran sarang mungkin terbukti lebih berguna!

Terkait dengan hal di atas, Anda pasti akan menemukan pustaka Boost bind dan modul terkait lainnya sangat berguna.

Saya tidak berpikir ada orang yang menjelaskan di sini bahwa satu masalah adalah Anda memerlukan " pointer anggota " daripada pointer fungsi normal.

Pointer anggota ke fungsi bukan sekadar pointer fungsi. Dalam istilah implementasi, kompilator tidak dapat menggunakan alamat fungsi sederhana karena, secara umum, Anda tidak tahu alamat yang akan dipanggil sampai Anda mengetahui objek mana yang akan didereferensi (pikirkan fungsi virtual). Anda juga perlu mengetahui objeknya untuk memberikan thisparameter implisit, tentunya.

Setelah mengatakan bahwa Anda membutuhkannya, sekarang saya akan mengatakan bahwa Anda benar-benar perlu menghindarinya. Serius, petunjuk anggota menyebalkan. Jauh lebih masuk akal untuk melihat pola desain berorientasi objek yang mencapai tujuan yang sama, atau menggunakan boost::functionatau apa pun seperti yang disebutkan di atas - dengan asumsi Anda bisa membuat pilihan itu.

Jika Anda menyediakan penunjuk fungsi tersebut ke kode yang sudah ada, sehingga Anda benar - benar membutuhkan penunjuk fungsi sederhana, Anda harus menulis fungsi sebagai anggota statis kelas. Fungsi anggota statis tidak mengerti this, jadi Anda harus meneruskan objek sebagai parameter eksplisit. Pernah ada idiom yang tidak biasa di sepanjang baris ini untuk bekerja dengan kode C lama yang membutuhkan pointer fungsi

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

    static void myfunction (myclass *p);
}

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

Karena myfunctionbenar-benar hanya fungsi normal (masalah lingkup selain), penunjuk fungsi dapat ditemukan dengan cara C normal.

EDIT - metode semacam ini disebut "metode kelas" atau "fungsi anggota statis". Perbedaan utama dari fungsi non-anggota adalah, jika Anda mereferensikannya dari luar kelas, Anda harus menentukan cakupan menggunakan ::operator resolusi cakupan. Misalnya, untuk mendapatkan penunjuk fungsi, gunakan &myclass::myfunctiondan untuk memanggilnya gunakan myclass::myfunction (arg);.

Hal semacam ini cukup umum ketika menggunakan Win32 API lama, yang awalnya dirancang untuk C daripada C ++. Tentu saja dalam kasus itu, parameternya biasanya LPARAM atau serupa daripada sebuah pointer, dan diperlukan beberapa casting.

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

Contoh minimal runnable

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

Kompilasi dan jalankan:

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

Diuji di Ubuntu 18.04.

Anda tidak dapat mengubah urutan tanda kurung atau menghilangkannya. Berikut ini tidak berhasil:

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

GCC 9.2 akan gagal dengan:

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

Standar C ++ 11

.*dan ->*merupakan operator tunggal yang diperkenalkan di C ++ untuk tujuan ini, dan tidak ada di C.

Draf standar C ++ 11 N3337 :

• 2.13 "Operator dan punctuator" memiliki daftar semua operator, yang berisi .*dan ->*.
• 5.5 "Operator penunjuk-ke-anggota" menjelaskan apa yang mereka lakukan

Saya datang ke sini untuk mempelajari cara membuat penunjuk fungsi (bukan penunjuk metode) dari sebuah metode tetapi tidak ada jawaban di sini yang memberikan solusi. Inilah yang saya dapatkan:

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>

Jadi untuk contoh Anda, Anda sekarang akan melakukan:

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

Sunting:
Menggunakan C ++ 17, ada solusi yang lebih baik:

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

yang dapat digunakan secara langsung tanpa makro:

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

Untuk metode dengan pengubah seperti constAnda mungkin memerlukan beberapa spesialisasi seperti:

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

Alasan mengapa Anda tidak dapat menggunakan penunjuk fungsi untuk memanggil fungsi anggota adalah karena penunjuk fungsi biasa biasanya hanya alamat memori dari fungsi tersebut.

Untuk memanggil fungsi anggota, Anda perlu mengetahui dua hal:

• Anggota mana yang berfungsi untuk dihubungi
• Contoh mana yang harus digunakan (yang fungsi anggotanya)

Penunjuk fungsi biasa tidak dapat menyimpan keduanya. Pointer fungsi anggota C ++ digunakan untuk menyimpan a), itulah sebabnya Anda perlu menentukan instance secara eksplisit saat memanggil penunjuk fungsi anggota.

Penunjuk fungsi ke anggota kelas adalah masalah yang sangat cocok untuk menggunakan boost :: function. Contoh kecil:

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

Untuk membuat objek baru, Anda dapat menggunakan penempatan baru, seperti yang disebutkan di atas, atau meminta kelas Anda mengimplementasikan metode clone () yang membuat salinan objek. Anda kemudian dapat memanggil metode klon ini menggunakan penunjuk fungsi anggota seperti yang dijelaskan di atas untuk membuat instance baru dari objek. Keuntungan dari kloning adalah terkadang Anda mungkin bekerja dengan pointer ke kelas dasar di mana Anda tidak mengetahui tipe objeknya. Dalam hal ini metode clone () bisa lebih mudah digunakan. Selain itu, clone () akan membiarkan Anda menyalin status objek jika itu yang Anda inginkan.

Saya melakukan ini dengan std :: function dan std :: bind ..

Saya menulis kelas EventManager ini yang menyimpan vektor penangan dalam unordered_map yang memetakan jenis peristiwa (yang hanya const unsigned int, saya memiliki enum lingkup namespace besar dari mereka) ke vektor penangan untuk jenis peristiwa itu.

Di kelas EventManagerTests saya, saya menyiapkan penangan peristiwa, seperti ini:

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

Inilah fungsi 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;
}

Berikut definisi tipe EventHandler:

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

Kemudian kembali ke EventManagerTests :: RaiseEvent, saya melakukan ini:

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

Berikut kode untuk 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);
            }
        );
    }
}

Ini bekerja. Saya mendapatkan panggilan di EventManagerTests :: OnKeyDown. Saya harus menghapus vektor datang waktu pembersihan, tetapi begitu saya melakukannya, tidak ada kebocoran. Meningkatkan acara membutuhkan waktu sekitar 5 mikrodetik di komputer saya, yaitu sekitar tahun 2008. Tidak bisa dibilang super cepat, tapi. Cukup adil selama saya mengetahuinya dan saya tidak menggunakannya dalam kode ultra hot.

Saya ingin mempercepatnya dengan menggulung std :: function dan std :: bind saya sendiri, dan mungkin menggunakan array array daripada unordered_map vektor, tetapi saya belum cukup menemukan cara menyimpan fungsi anggota pointer dan memanggilnya dari kode yang tidak tahu apa-apa tentang kelas yang dipanggil. Jawaban bulu mata terlihat Sangat Menarik ..