如何在编译时表达式中转换/使用运行时变量？

Answer 1

目前尚不清楚您是否想要一个元素或每个元素之一。

如果您需要其中一个，SomeLogicClass 应该有一个std::tuple<Class1, Class2, Class3>。这存储了“一个”，还提供了std::get<>()，它返回元素i。因此，getInstance() 基本上可以委托给std::get<ID>()。

如果您需要任一类型的元素，SomeLogicClass 应该有一个std::variant<Class1, Class2, Class3>。这存储了活动元素的种类和元素本身。您可以使用std::get<>()，或者-更好-您可以通过std::visit()访问。

Answer 2

由于您仅限于 C++11 并且不允许使用诸如 boost::variant 之类的外部库，因此另一种选择是反转逻辑：不要尝试返回子类型，而是传入要在孩子。您的示例可能会变成这样 (godbolt)：

#include <iostream>
#include <type_traits>

enum struct Type : unsigned { base = 0, child1, child2, child3 /* so on*/ };

// CRTP Base
template<typename Child> struct Base {
    void doSomething() { static_cast<Child*>(this)->doSomething_Impl(); }
private:
    Base() = default;
    friend Child;
};

struct Child1 : public Base<Child1> {
    void doSomething_Impl() { std::cout << "Child1 implementation\n"; }
};
struct Child2 : public Base<Child2> {
    void doSomething_Impl() { std::cout << "Child2 implementation\n"; }
}; 
struct Child3 : public Base<Child3> {
    void doSomething_Impl() { std::cout << "Child3 implementation\n"; }
};
// ... so on

class SomeLogicClass
{
    Type mClassId{ Type::base };
    Child1 mChild1;
    Child2 mChild2;
    Child3 mChild3;
    // ... child3  so on!

public:
    Type getId() const { return mClassId; }
    void setId(Type id) { mClassId = id; } // run time depended!

    template <class Func>
    void apply(Func func)
    {
        switch (mClassId){
            case Type::child1: func(mChild1); break;
            case Type::child2: func(mChild2); break;
            case Type::child3: func(mChild3); break;
            default:  // error case!
                break;
        }
    }
};


struct DoSomethingCaller
{
    template <class T>
    void operator()(T & childInstance){
        childInstance.doSomething();
    }
};

void test(SomeLogicClass& ob, Type id)
{
    ob.setId(id);

    ob.apply(DoSomethingCaller{});

    // Starting with C++14, you can also simply write:
    //ob.apply([](auto & childInstance){ childInstance.doSomething(); });
}

int main() 
{
    SomeLogicClass ob;    
    test(ob, Type::child1);
    test(ob, Type::child2);
    test(ob, Type::child3);
}

请注意新函数 apply() 如何替换您的 getInstance()。但它不是尝试返回子类型，而是接受一些适用于正确子类型的通用操作。传入的函子需要处理（即编译）所有可能的子类型。由于它们都有doSomething() 方法，您可以简单地使用模板仿函数（DoSomethingCaller）。不幸的是，在 C++14 之前，它不能简单地是一个多态 lambda，而是需要在函数之外是一个适当的结构 (DoSomethingCaller)。

如果您愿意，您还可以将 DoSomethingCaller 限制为 CRTP 基类 Base<T>：

struct DoSomethingCaller
{
    template <class T>
    void operator()(Base<T> & childInstance){
        childInstance.doSomething();
    }
};

这可能使它更具可读性。

根据“无外部库”限制的严格程度，可能只允许 boost，但单个外部头文件（可以像任何其他头文件一样简单地包含在代码库中）是可能的？如果是，您可能还想看看variant-lite。它旨在成为std::variant 的兼容 C++98/C++11 的替代品。

Answer 3

我在这里认识到您的 CRTP 代码库中的桥接模式，尽管在我看来做得很糟糕。但是无论如何，如果您无法触及该代码，那么您应该实现第二个桥接代码。幸运的是，有了模板，这并不难。

这是代码（godbold）：

#include <iostream>

enum struct Type : unsigned { base = 0, child1, child2, child3 /* so on*/ };
// CRTP Base
template<typename Child> struct Base {
    void doSomething() { static_cast<Child*>(this)->doSomething_Impl(); }
private:
    Base() = default;
    friend Child;
};

struct Child1 : public Base<Child1> {
    void doSomething_Impl() { std::cout << "Child1 implementation\n"; }
};
struct Child2 : public Base<Child2> {
    void doSomething_Impl() { std::cout << "Child2 implementation\n"; }
}; 
struct Child3 : public Base<Child3> {
    void doSomething_Impl() { std::cout << "Child3 implementation\n"; }
};
// ... so on

class CommonInterface {
    public:
        virtual void doSomething() = 0;
};

template<class Child>
class ChildCaller : public CommonInterface {
    private:
        Child child;
    public:
        virtual void doSomething() {
            child.doSomething_Impl();
        }
};

class SomeLogicClass
{
    Type mClassId{ Type::base };
    ChildCaller<Child1> mChild1;
    ChildCaller<Child2> mChild2;
    ChildCaller<Child3> mChild3;

    CommonInterface* currentChild;

    public:
    Type getId() const { return mClassId; }
    void setId(Type id) { 
        mClassId = id; 
        switch(id) {
            case Type::child1:
                currentChild = &mChild1;
                break;
            case Type::child2:
                currentChild = &mChild2;
                break;
            case Type::child3:
                currentChild = &mChild3;
                break;
            default:
                currentChild = nullptr; // or anything you want
        }
    } 

    void doSomething() {
        currentChild->doSomething();
    }
};

void test(SomeLogicClass& ob, Type id)
{
    ob.setId(id);
    ob.doSomething(); // calls the corresponding implementations!
}

int main() {
    SomeLogicClass ob;    
    test(ob, Type::child1);
    test(ob, Type::child2);
    test(ob, Type::child3);
}

我在这里和那里省略了错误检查，因此代码更具可读性。