C＆＃x2B;＆＃x2B;基于函数名称动态创建函数的实现？

Question

我有多个具有相似实现的功能。唯一的区别是他们调用不同的呼叫，基本上基于下面的函数名称。

// A.h
class A : public ParentA
{
  public:
    explicit A(B& b);
    ~A() override = default;

    // accessors
    C does_same_thing1() const;
    C does_same_thing2() const;
    C does_same_thing3() const;
    // ...
}

// A.cpp
C A::does_same_thing1() const
{
    ...
    return xyz.values().thing1();
}

C A::does_same_thing2() const
{
    ...
    return xyz.values().thing2();
}

C A::does_same_thing3() const
{
    ...
    return xyz.values().thing3();
}

我想知道是否有一种动态填写几乎相同的功能的方法，除了他们称之为的登录器（thing1（），thing2（）和thing 3（），这实际上不止一次发生，而不仅仅是在返回行上）基于其功能名称。在C ++中可以吗？

谢谢！

Answer 1

您可以编写一个功能模板，然后让呼叫者选择要返回的内容：

template <typename F>
auto foo(F f) {
     ...
     return f(xyz.values());
}

详细信息取决于您从问题中遗漏的详细信息。例如，xyz.values（）的类型是否可供呼叫者使用？另外，您必须让呼叫者选择f或编写包装器：

 auto does_same_thing1() {
      foo([](auto& x) { return x.thing1(); }
 }
 // ... and same for the others

Answer 2

一些选项是：

• 使用抽象并覆盖所需的零件。
• 使用lambas并通过您的需要的功能。
• 使用模板函数是上面两个的混合，但是我会让其他人解释这一点。

创建基类

class Base
{
protected:
    int value;

public:
    virtual void differentFunction(int mathThing) = 0;
    void longFunction()
    {
        value = 0;
        std::cout << "I do a lot of steps" << std::endl;

        std::cout << "Step 1" << std::endl;
        value++;

        std::cout << "Step 2" << std::endl;
        value++;

        std::cout << "Step 3" << std::endl;
        value++;

        std::cout << "Step 4" << std::endl;
        value++;

        std::cout << "Step 5" << std::endl;
        value++;

        std::cout << "Step 6" << std::endl;

        //And finally I do a unique thing
        differentFunction(3);
        std::cout << "Resulting value: " << value << std::endl;
    }

    void longLamdaFunction(std::function<void(int& value, int mathThing)> mathFunction)
    {
        value = 0;
        std::cout << "I do a lot of steps" << std::endl;

        std::cout << "Step 1" << std::endl;
        value++;

        std::cout << "Step 2" << std::endl;
        value++;

        std::cout << "Step 3" << std::endl;
        value++;

        std::cout << "Step 4" << std::endl;
        value++;

        std::cout << "Step 5" << std::endl;
        value++;

        std::cout << "Step 6" << std::endl;

        //And finally I do a unique thing
        mathFunction(value, 3);
        std::cout << "Resulting value: " << value << std::endl;
    }
};

创建一个覆盖类创建

class Derived1 : public Base
{
public:
    void differentFunction(int mathThing) override
    {
        std::cout << "I multiply the value" << std::endl;
        value *= mathThing;
    }

};

不同的覆盖类示例，您也可以在此处查看lambda示例

class Derived2 : public Base
{
public:
    void differentFunction(int mathThing) override
    {
        std::cout << "I divide the value" << std::endl;
        value /= mathThing;
    }

};

使用

int main()
{
    Derived1 d1;
    Derived2 d2;

    std::cout << "\nUsing multiple interface\n";
    d1.longFunction();

    std::cout << "\nUsing divide interface\n";
    d2.longFunction();

    std::cout << "\nUsing add lamda\n";
    //I now add them
    auto addFunction = [](int& x, int y) -> void { x += y; };
    d1.longLamdaFunction(addFunction);

    std::cout << "\nUsing subtract lamda\n";
    //I now subtract them
    auto subtractFunction = [](int& x, int y) -> void { x -= y; };
    d1.longLamdaFunction(subtractFunction);
}