ตัวชี้ฟังก์ชันไปยังฟังก์ชันสมาชิก

ฉันต้องการตั้งค่าตัวชี้ฟังก์ชันเป็นสมาชิกของคลาสที่เป็นตัวชี้ไปยังฟังก์ชันอื่นในคลาสเดียวกัน เหตุผลที่ฉันทำมันซับซ้อน

ในตัวอย่างนี้ฉันต้องการให้เอาต์พุตเป็น "1"

class A {
public:
 int f();
 int (*x)();
}

int A::f() {
 return 1;
}


int main() {
 A a;
 a.x = a.f;
 printf("%d\n",a.x())
}

แต่สิ่งนี้ล้มเหลวในการรวบรวม ทำไม?

ไวยากรณ์ไม่ถูกต้อง ตัวชี้สมาชิกเป็นประเภทประเภทที่แตกต่างจากตัวชี้ธรรมดา ตัวชี้สมาชิกจะต้องใช้ร่วมกับออบเจ็กต์ของคลาส:

class A {
public:
 int f();
 int (A::*x)(); // <- declare by saying what class it is a pointer to
};

int A::f() {
 return 1;
}


int main() {
 A a;
 a.x = &A::f; // use the :: syntax
 printf("%d\n",(a.*(a.x))()); // use together with an object of its class
}

a.xยังไม่ได้บอกว่าจะเรียกใช้ฟังก์ชันอะไร aมันก็บอกว่าคุณต้องการที่จะใช้ตัวชี้ที่เก็บไว้ในวัตถุ การเติมaเวลาอีกครั้งในขณะที่ตัวถูกดำเนินการด้านซ้ายไปยังตัว.*ดำเนินการจะบอกคอมไพเลอร์ว่าจะเรียกใช้ฟังก์ชันใด

int (*x)()ไม่ใช่ตัวชี้ไปยังฟังก์ชันสมาชิก int (A::*x)(void) = &A::f;ตัวชี้ไปยังฟังก์ชันสมาชิกที่เขียนเช่นนี้

เรียกใช้ฟังก์ชันสมาชิกด้วยคำสั่งสตริง

#include <iostream>
#include <string>


class A 
{
public: 
    void call();
private:
    void printH();
    void command(std::string a, std::string b, void (A::*func)());
};

void A::printH()
{
    std::cout<< "H\n";
}

void A::call()
{
    command("a","a", &A::printH);
}

void A::command(std::string a, std::string b, void (A::*func)())
{
    if(a == b)
    {
        (this->*func)();
    }
}

int main()
{
    A a;
    a.call();
    return 0;
}

ให้ความสนใจ(this->*func)();และวิธีการประกาศตัวชี้ฟังก์ชันด้วยชื่อคลาสvoid (A::*func)()

คุณต้องใช้ตัวชี้ไปยังฟังก์ชันสมาชิกไม่ใช่แค่ตัวชี้ไปที่ฟังก์ชัน

class A { 
    int f() { return 1; }
public:
    int (A::*x)();

    A() : x(&A::f) {}
};

int main() { 
   A a;
   std::cout << (a.*a.x)();
   return 0;
}

แม้ว่านี่จะเป็นไปตามคำตอบสเตอร์ลิงที่อื่นในหน้านี้ แต่ฉันมีกรณีการใช้งานที่ไม่ได้รับการแก้ไขอย่างสมบูรณ์ สำหรับเวกเตอร์ของพอยน์เตอร์ไปยังฟังก์ชันให้ทำดังต่อไปนี้:

#include <iostream>
#include <vector>
#include <stdio.h>
#include <stdlib.h>

class A{
public:
  typedef vector<int> (A::*AFunc)(int I1,int I2);
  vector<AFunc> FuncList;
  inline int Subtract(int I1,int I2){return I1-I2;};
  inline int Add(int I1,int I2){return I1+I2;};
  ...
  void Populate();
  void ExecuteAll();
};

void A::Populate(){
    FuncList.push_back(&A::Subtract);
    FuncList.push_back(&A::Add);
    ...
}

void A::ExecuteAll(){
  int In1=1,In2=2,Out=0;
  for(size_t FuncId=0;FuncId<FuncList.size();FuncId++){
    Out=(this->*FuncList[FuncId])(In1,In2);
    printf("Function %ld output %d\n",FuncId,Out);
  }
}

int main(){
  A Demo;
  Demo.Populate();
  Demo.ExecuteAll();
  return 0;
}

สิ่งนี้มีประโยชน์หากคุณกำลังเขียนตัวแปลคำสั่งที่มีฟังก์ชันที่จัดทำดัชนีซึ่งจำเป็นต้องเชื่อมโยงกับไวยากรณ์ของพารามิเตอร์และคำแนะนำความช่วยเหลือเป็นต้นนอกจากนี้ยังมีประโยชน์ในเมนูด้วย

แม้ว่าคุณจะไม่สามารถแปลงตัวชี้ฟังก์ชันสมาชิกที่มีอยู่เป็นตัวชี้ฟังก์ชันธรรมดาได้ แต่คุณสามารถสร้างเทมเพลตฟังก์ชันอะแด็ปเตอร์ได้อย่างตรงไปตรงมาซึ่งจะรวมตัวชี้ฟังก์ชันสมาชิกที่รู้จักในเวลาคอมไพล์ในฟังก์ชันปกติเช่นนี้

template <class Type>
struct member_function;

template <class Type, class Ret, class... Args>
struct member_function<Ret(Type::*)(Args...)>
{
    template <Ret(Type::*Func)(Args...)>
    static Ret adapter(Type &obj, Args&&... args)
    {
        return (obj.*Func)(std::forward<Args>(args)...);
    }
};

template <class Type, class Ret, class... Args>
struct member_function<Ret(Type::*)(Args...) const>
{
    template <Ret(Type::*Func)(Args...) const>
    static Ret adapter(const Type &obj, Args&&... args)
    {
        return (obj.*Func)(std::forward<Args>(args)...);
    }
};

int (*func)(A&) = &member_function<decltype(&A::f)>::adapter<&A::f>;

โปรดทราบว่าในการเรียกใช้ฟังก์ชันสมาชิกAต้องระบุอินสแตนซ์

จากคำตอบของ @ IllidanS4 ฉันได้สร้างคลาสเทมเพลตที่อนุญาตให้ฟังก์ชันของสมาชิกแทบทุกฟังก์ชันที่มีอาร์กิวเมนต์ที่กำหนดไว้ล่วงหน้าและอินสแตนซ์คลาสสามารถส่งผ่านโดยการอ้างอิงสำหรับการโทรในภายหลัง

template<class RET, class... RArgs> class Callback_t {
public:
    virtual RET call(RArgs&&... rargs) = 0;
    //virtual RET call() = 0;
};

template<class T, class RET, class... RArgs> class CallbackCalltimeArgs : public Callback_t<RET, RArgs...> {
public:
    T * owner;
    RET(T::*x)(RArgs...);
    RET call(RArgs&&... rargs) {
        return (*owner.*(x))(std::forward<RArgs>(rargs)...);
    };
    CallbackCalltimeArgs(T* t, RET(T::*x)(RArgs...)) : owner(t), x(x) {}
};

template<class T, class RET, class... Args> class CallbackCreattimeArgs : public Callback_t<RET> {
public:
    T* owner;
    RET(T::*x)(Args...);
    RET call() {
        return (*owner.*(x))(std::get<Args&&>(args)...);
    };
    std::tuple<Args&&...> args;
    CallbackCreattimeArgs(T* t, RET(T::*x)(Args...), Args&&... args) : owner(t), x(x),
        args(std::tuple<Args&&...>(std::forward<Args>(args)...)) {}
};

ทดสอบ / ตัวอย่าง:

class container {
public:
    static void printFrom(container* c) { c->print(); };
    container(int data) : data(data) {};
    ~container() {};
    void print() { printf("%d\n", data); };
    void printTo(FILE* f) { fprintf(f, "%d\n", data); };
    void printWith(int arg) { printf("%d:%d\n", data, arg); };
private:
    int data;
};

int main() {
    container c1(1), c2(20);
    CallbackCreattimeArgs<container, void> f1(&c1, &container::print);
    Callback_t<void>* fp1 = &f1;
    fp1->call();//1
    CallbackCreattimeArgs<container, void, FILE*> f2(&c2, &container::printTo, stdout);
    Callback_t<void>* fp2 = &f2;
    fp2->call();//20
    CallbackCalltimeArgs<container, void, int> f3(&c2, &container::printWith);
    Callback_t<void, int>* fp3 = &f3;
    fp3->call(15);//20:15
}

เห็นได้ชัดว่าสิ่งนี้จะใช้ได้ก็ต่อเมื่ออาร์กิวเมนต์ที่กำหนดและคลาสเจ้าของยังคงใช้ได้ เท่าที่อ่านได้ ... โปรดยกโทษให้ฉันด้วย

แก้ไข:ลบ malloc ที่ไม่จำเป็นออกโดยสร้างที่เก็บข้อมูลแบบทูเปิล เพิ่มประเภทที่สืบทอดมาสำหรับการอ้างอิง เพิ่มตัวเลือกเพื่อให้อาร์กิวเมนต์ทั้งหมดในเวลาโทรแทน ตอนนี้ทำงานมีทั้ง ....

แก้ไข 2:ตามที่สัญญาไว้ทั้งคู่ ข้อ จำกัด เพียงอย่างเดียว (ที่ฉันเห็น) คืออาร์กิวเมนต์ที่กำหนดไว้ล่วงหน้าต้องมาก่อนอาร์กิวเมนต์ที่รันไทม์ให้มาในฟังก์ชันการเรียกกลับ ขอบคุณ @Chipster สำหรับความช่วยเหลือในการปฏิบัติตามข้อกำหนดของ gcc ใช้งานได้กับ gcc บน Ubuntu และ Visual Studio บน windows

#ifdef _WIN32
#define wintypename typename
#else
#define wintypename
#endif

template<class RET, class... RArgs> class Callback_t {
public:
    virtual RET call(RArgs... rargs) = 0;
    virtual ~Callback_t() = default;
};

template<class RET, class... RArgs> class CallbackFactory {
private:
    template<class T, class... CArgs> class Callback : public Callback_t<RET, RArgs...> {
    private:
        T * owner;
        RET(T::*x)(CArgs..., RArgs...);
        std::tuple<CArgs...> cargs;
        RET call(RArgs... rargs) {
            return (*owner.*(x))(std::get<CArgs>(cargs)..., rargs...);
        };
    public:
        Callback(T* t, RET(T::*x)(CArgs..., RArgs...), CArgs... pda);
        ~Callback() {};
    };
public:
    template<class U, class... CArgs> static Callback_t<RET, RArgs...>* make(U* owner, CArgs... cargs, RET(U::*func)(CArgs..., RArgs...));
};
template<class RET2, class... RArgs2> template<class T2, class... CArgs2> CallbackFactory<RET2, RArgs2...>::Callback<T2, CArgs2...>::Callback(T2* t, RET2(T2::*x)(CArgs2..., RArgs2...), CArgs2... pda) : x(x), owner(t), cargs(std::forward<CArgs2>(pda)...) {}
template<class RET, class... RArgs> template<class U, class... CArgs> Callback_t<RET, RArgs...>* CallbackFactory<RET, RArgs...>::make(U* owner, CArgs... cargs, RET(U::*func)(CArgs..., RArgs...)) {
    return new wintypename CallbackFactory<RET, RArgs...>::Callback<U, CArgs...>(owner, func, std::forward<CArgs>(cargs)...);
}