Question

是否有某种编译时switch语句可用于将参数传递给成员变量的构造函数？现在，我有一个控制器（在控制系统意义上，而不是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扩展。
我愿意使用更高级别的c ++扩展和特定于GNU C ++的编译器扩展，尽管clang和GNU C ++中的c ++ 14都是首选。 clang - 只有解决方案对我不利。
这适用于嵌入式环境;使用switch加new加上指针的运行时解决方案是不可接受的，因为间接性能损失，二进制文件膨胀以及嵌入式环境中内存分配的不安全性。
Filter类可以多次实例化。
涉及模板的解决方案没问题;我现在只使用float，因为我移植了某人的Matlab代码，但我最终会切换到定点数学。

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

使用宏和define条件编译（我在实际代码中使用的frequency变量是自定义数据类型，因此我需要使用{{1}和一个具有类似角色的C ++变量;我不喜欢在两个位置定义频率的想法 - 这会导致维护问题的发生。）
在构建过程中使用自定义预处理器重写变量。太神奇了，将来可能成为某人的陷阱。
枚举。我还没有排除这些，但我不能想到如何使用它们来改善代码而不具备Java枚举和/或类似Python define扩展的能力。不可否认，我只编写C ++大约四个月（非连续），并且在此之前只有一年的C经验，所以我很有可能错过了一些东西，语法-wise。
单独包含文件以包含魔法;在我的项目中，所有自动生成的文件都有一个单独的扩展，所以这是有效的。但是，我更喜欢使用更简单的构建脚本，并尽可能多地保留C ++代码中的逻辑。

Answer 1

将您的开关置于工厂方法中并使您的构造函数为私有，以便您被迫使用该方法这样，您将来只需在代码中更新一个点：

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课程添加复制构造函数或其他内容。这是显示模式如何工作的最小示例，仅此而已。

另一种单独定义它们并通过调用工厂方法使用每个构造函数的方法是基于委托构造函数：

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。

用C ++编译时编译时构造函数

1 个答案: