c++ - C++ 中的编译时构造函数开关

Question

是否有某种编译时 switch 语句可用于将参数传递给成员变量的构造函数？现在，我有一个 Controller (在控制系统意义上，而不是 MVC 意义上)，我需要能够在编译时配置其工作频率和一个过滤器，其参数取决于所选频率。这是我如何实现它的框架:

#include <cstdint>

class Filter {
    public:
        Filter(float p1, float p2) : p1(p1), p2{p2} {}

    private:
        float const p1;
        float const p2;
};

class Controller {
    public:
        Controller(void) {}

    private:
        static constexpr uint32_t frequency = 200U;

        Filter filter{frequency == 400U ? 3.0f :    // p1
                      frequency == 200U ? 1.0f :
                      frequency == 50U ? 0.55f : 0f,
                      frequency == 400U ? 2.0f :    // p2
                      frequency == 200U ? 9.0f :
                      frequency == 50U ? 37.1f : 0f,

        };

    static_assert(frequency == 400U || frequency == 200U || frequency == 50U, "Invalid frequency");
};

对于大量的频率，即使只有两个滤波器参数(真正的软件有更多)，这显然很难维护。每次我需要添加对新频率的支持时，我都需要将代码添加到代码中的 n 点，其中 n 是过滤器的参数数量。我想要的是这样的:

Filter filter = frequency == 400U ? {3.0f, 2.0f} :
                frequency == 200U ? {1.0f, 9.0f} :
                frequency == 50U ? {0.55f, 37.1f} :
                {0.0f, 0.0f};

或者，在我更疯狂的梦想中:

Filter filter = static_switch_map(frequency) {
            400U: {3.0f, 2.0f},
            200U: {1.0f, 9.0f},
            50U: {0.55f, 37.1f},
        };

过滤器的参数不是通过公式确定的，因此不能写成表达式的一部分。一些附加说明:

• 我在 clang 和 GNU C++ 中使用 c++14 扩展。
• 我愿意使用特定于 GNU C++ 的高级 c++ 扩展和编译器扩展，尽管在 clang 和 GNU C++ 中首选 c++14。 clang - 只有解决方案对我没有好处。
• 这是用于嵌入式环境；使用 switch 加上 new 加上指针的运行时解决方案是 Not Acceptable ，因为间接性能受到影响，二进制文件膨胀，以及嵌入式环境中内存分配的不安全性.
• Filter 类可以多次实例化。
• 涉及模板的解决方案没问题；我现在只使用 float，因为我正在移植某人的 Matlab 代码，但我最终会切换到定点数学。

我考虑过的其他解决方案包括:

• 使用宏和define 进行条件编译(我在实际代码中使用的frequency 变量是自定义数据类型，因此我需要使用define 和一个具有相似角色的 C++ 变量；我不喜欢在两个位置定义频率的想法——这会导致以后出现维护问题。
• 在构建过程中使用自定义预处理器重写变量。太神奇了，将来可能会成为某人的陷阱。
• 枚举。我没有排除这些，但我想不出如何在没有 Java 枚举和/或类似 Python 的 *args 扩展能力的情况下改进代码的方式使用它们.不可否认，我只写了大约四个月的 C++(非连续的)并且在那之前只有一年的 C 经验，所以我很有可能在语法方面遗漏了一些东西。
• 单独的包含文件来包含魔法；在我的项目中，所有自动生成的文件都有一个单独的扩展名，所以这是可行的。但是，我更喜欢使用更简单的构建脚本并尽可能多地保留 C++ 代码中的逻辑。

Answer 1

把你的开关放在一个工厂方法中，让你的构造函数成为私有(private)的，这样你就被迫使用那个方法。
这样，您以后只需在代码中更新一点:

struct Filter {
    static Filter create(int freq) {
        switch(freq) {
        case 0: return { 0, 1 };
        case 2: return { 3, 7 };
        default: return { 0, 0 };
        }
    }

private:
        Filter(int, int) {}
};

int main() {
    auto filter = Filter::create(2);
    (void)filter;
}

如果你想在编译时也使用它，你可以稍微改变它如下(这需要 C++14):

class Filter {
    constexpr Filter(int i, int j)
        : i{i}, j{j}
    {}

public:
    static constexpr Filter create(int freq) {
        switch(freq) {
        case 0: return { 0, 1 };
        case 2: return { 3, 7 };
        default: return { 0, 0 };
        }
    }

    constexpr int get_i() const { return i; }
    constexpr int get_j() const { return j; }

private:        
    int i;
    int j;
};

int main() {
    constexpr auto filter = Filter::create(2);
    static_assert(filter.get_i() == 3, "!");
}

当然，您可以轻松地向您的Filter 类添加复制构造函数或其他内容。这是一个展示模式如何工作的最小示例，仅此而已。

---

另一种分别定义它们并通过调用工厂方法使用每个构造函数的方法是基于委托(delegate)构造函数:

template<int>
struct freq_tag {};

class Filter {
    constexpr Filter(int i, int j)
        : i{i}, j{j}
    {}

    constexpr Filter(freq_tag<0>): Filter{0, 1} {}
    constexpr Filter(freq_tag<2>): Filter{3, 7} {}

    template<int N>
    constexpr Filter(freq_tag<N>): Filter{0, 0} {}

public:
    template<int N>
    constexpr static Filter create() {
        return Filter{freq_tag<N>{}};
    }

    constexpr int get_i() const { return i; }
    constexpr int get_j() const { return j; }

private:
    int i;
    int j;
};

int main() {
    constexpr auto filter = Filter::create<2>();
    static_assert(filter.get_i() == 3, "!");
}

与基于开关的解决方案相比，这主要是一个品味问题，但事实上这个解决方案也应该在 C++11 中工作。