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