关于c++委托机制的实现（一）_c++实现委托机制(一)-优快云博客

本博客参考其他博客，介绍C++中普通函数、类静态成员函数、类普通成员函数和lamda函数。重点实现无返回值、无形参的函数委托，先声明抽象类包含纯虚方法，对不同函数进行抽象，使用模板处理类成员函数，还创建类统一接口，后续将实现任意返回和形参函数的委托。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

写自己的bug，让自己无bug可写

下一篇传送门：https://blog.youkuaiyun.com/qq_34236354/article/details/89878858

本博客参考其他博客编写而成，参考博客地址：https://blog.youkuaiyun.com/gouki04/article/details/6852394，有兴趣的可以去看看

函数简介：c++中有普通函数，类静态成员函数，类普通成员函数，lamda函数

普通函数：一般指全局函数

类静态成员函数：类的静态函数，可以通过Class::Fun()形式调用

类普通成员函数：类的普通成员函数，一般是obj.fun()或pObj->fun()形式调用

lamda函数：有兴趣的可以自己百度，这里不考虑；（因为lamda函数实质是匿名函数，就是一个没有函数名的函数，从它的用途上来说本来就是提供编码便利，并且其他地方并不会出现，如果有两个或两个以上地方需要调用，那最好还是换成普通函数）

一：本次实现的是无返回值，无形参的函数委托；

二：实现

1：普通函数和类的静态成员函数十分相似，都不需要通过对象来调用，因此可以看成是一类

2：不管是什么函数都能调用

因此要实现函数委托，可以先声明一个抽象类，该类中包含一个纯虚方法

class IFun
{
public:
    virtual ~IFun() {}
    
    virtual void operator()() = 0;
};

因为普通函数和类的静态成员函数类似，因此可以抽象成下面这个类

class CStaticFun : public IFun
{
    typedef void(*PFun)();
public:
    explicit CStaticFun(PFun pFun) : m_pFun(pFun) {}
    
    virtual void operator()() override
    {
        m_pFun();
    }
private:
    PFun m_pFun;
};

而关于类成员函数，因为考虑到根本不知道用户会用什么样的类对象，所以这里需要使用到c++中的模板

template <typename TObj>
class CMemberFun : public IFun
{
    typedef void(TObj::*PFun)();
public:
    explicit CMemberFun(TObj *pObj, PFun pFun) : m_pObj(pObj), m_pFun(pFun) {}
    
    virtual void operator()() override
    {
        (m_pObj->*m_pFun)();
    }
private:
    TObj *m_pObj;
    PFun  m_pFun;
};

至此普通函数、类静态成员函数和类普通成员函数基本抽象完成，但为了让客户端更好的使用，因此我们可以再创建下面这个类，来统一接口

class CFun : public IFun
{
public:
    explicit CFun(void(*pFun)()) : m_pFun(new CStaticFun(pFun)) {}
    ~CFun() { delete m_pFun; }
    
    template <typename TObj>
    explicit CFun(TObj *pObj, void(TObj::*pFun)()) : m_pFun(new CMemberFun<TObj>(pObj, pFun)) {}
    
    virtual void operator()() override
    {
        if(m_pFun)
            (*m_pFun)();
    }
private:
    IFun *m_pFun;
};

这样无返回值，无形参函数的委托基本上就完成了

下面是实例：

#include <iostream>

/*
 * 测试时记得把那三个类复制粘贴至此处
 */

void fun() { std::cout << "这是一个函数" << std::endl; }

class A
{
public:
    explicit A() {}
    
    static void fun1() { std::cout << "这是类的静态函数" << std::endl; }
    void fun2() { std::cout << "这是类的成员函数" << std::endl; }
};


int main()
{
    A a;
    CFun f(fun), f1(&A::fun1), f2(&a, &A::fun2);
    
    CFun lamda([](){
        std::cout << "lamda" << std::endl;
    });
    
    f();
    f1();
    f2();
    lamda();
    
    return 0;
}

运行结果如下：