C 中的编译时间构造函数开关

Compile-time constructor switch in C++

本文关键字：构造函数 开关 时间 编译      更新时间：2023-10-16

是否有某种编译时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 S，因为我要移植某人的MATLAB代码，但最终我将切换到定点数学。

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

  • 使用宏和define的条件编译（我在实际代码中使用的frequency变量是一种自定义数据类型，因此我需要使用具有相似角色的define和C 变量；我不喜欢在两个位置定义频率的想法 - 这将导致道路上的维护问题）
  • 在构建过程中使用自定义预处理器重写变量。太神奇了，将来可能会成为某人的陷阱。
  • 枚举。我还没有排除这些内容，但是我无法想到如何以一种可以改善代码的方式使用它们，而无需Java Enums和/或类似Python的*args扩展。诚然，我只写了C 大约四个月（非温和地），并且在此之前只有C稳定的一年经验，所以我很有可能缺少某些内容，语法。
  • 单独包含文件以包含魔术；在我的项目中，所有自动生成的文件都有一个单独的扩展名，因此这有效。但是，我更喜欢拥有更简单的构建脚本，并将尽可能多的逻辑保留在C 代码中。

将您的开关放入工厂方法中，然后将构造函数私有化，以便您被迫使用该方法。
这样，您将来只有一个点可以在代码中更新：

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中工作。

相关文章：