C ++根据函数名称动态创建函数的实现？

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（）和thing3（）之外几乎相同的函数，而这实际上不止一次发生，而不仅仅是在返回线上) 基于它们的函数名称。 这在 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;
    }

};

创建一个不同的覆盖类

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

};

使用示例，您也可以在此处查看 Lambda 示例

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