您如何在C ++中为类有效地实现“委托”？

Question

在Objective C中，该语言内置了将类委派给其他类的支持。 C ++没有作为语言一部分的这种功能（一个类作为另一个类的委托）。 一种模仿的方法是将声明和实现分开：

在头文件ah中 ：

class AImpl;

class A
{
public:
     A();

     void f1();
     int f2(int a, int b); 
     // A's other methods...
private:
    AImpl *mImpl;
};

在.cpp （实现文件）中：

#include "a.h"

class AImpl
{
public:
     AImpl();
     // repeating the same method declarations from A
     void f1();
     int f2(int a, int b); 
     // AImpl's other methods
};

AImpl::AImpl()
{
}

void AImpl:f1()
{
    // actual implemetation
}

int AImpl::f2(int a, int b)
{
    // actual implmentation
}

// AImpl's  other methods implementation

A::A()
{
     mImpl = new AImpl();
}

// A's "forwarder"

void A::f1()
{
    mImpl->f1();
}

int A::f2(int a, int b)
{
    return mImpl->f2(a, b);
}

// etc.

这需要在类中手动创建所有“转发器”函数，这些函数将委派给另一个类以进行实际工作。 至少可以说是乏味的。

问题是：是否有使用模板或其他C ++语言构造实现此效果的更好或更有效的方法？

Answer 1

是的，有可能。 可能的示例之一是：

struct WidgetDelegate
{
    virtual ~WidgetDelegate() {}
    virtual void onNameChange(std::string newname, std::string oldname) {}
};

class Widget
{
public:
    std::shared_ptr<WidgetDelegate> delegate;
    explicit Widget(std::string name) : m_name(name){}
    void setName(std::string name) {
        if (delegate) delegate->onNameChange(name, m_name);
        m_name = name;
    }
private:
    std::string m_name;
};

用法：

class MyWidgetDelegate : public WidgetDelegate
{
public:
    virtual void onNameChange(std::string newname, std::string oldname) {
        std::cout << "Widget old name: " << oldname << " and new name: " << newname << std::endl;
    }
};

int main()
{
    Widget my_widget("Button");
    my_widget.delegate = std::make_shared<MyWidgetDelegate>();
    my_widget.setName("DoSomeThing");   
    return 0;
}

必需包括：

#include <string>
#include <iostream>
#include <memory>

Answer 2

您可以在基类中实现虚拟接口。
但是，如果您确实要委托，则可以重载operator->以委托所有调用。
您将不再需要转发方法：

#include <iostream>
#include <string>

using namespace std;

class AImpl;

class A
{
    public:
        A();

        //Overloading operator -> delegates the calls to AImpl class
        AImpl* operator->() const { return mImpl; }

    private:
        AImpl *mImpl;
};

class AImpl
{
    public:
        void f1() { std::cout << "Called f1()\n"; }
        void f2() { std::cout << "Called f2()\n"; }
};

A::A()
{
    mImpl = new AImpl();
}

int main()
{
    A a;
    a->f1(); //use a as if its a pointer, and call functions of A

    A* a1 = new A();
    (*a1)->f2();
}