我应该使用什么来代替模板化枚举？

Question

在我的代码中，我使用如下内容：

enum {
    foo = sizeof(some_type_t) < 32 ? 1 : 2,
    bar = some_constexpr_function() - N,
    baz = foo + bar,
    // etc.
}

对于我想确保没有运行时存储的一堆编译时常量；我有一些使用这些常量的函数。 N 是我们从其他地方得到的一些常数。

现在我想将我的代码模板化：N 不再是一个全局常量，而是一个数字模板参数。现在，如果我这样做：

template <size_t N> f()
{
    enum {
        foo = sizeof(some_type_t) < 32 ? 1 : 2,
        bar = some_constexpr_function() - N,
        baz = foo + bar,
        // etc.
    }
}

那行得通；但是 - 它限制了我在单个函数中使用这些常量；我想要几个。在 C++ 中，我们不能拥有

    template <size_t N>
    enum {
        foo = sizeof(some_type_t) < 32 ? 1 : 2,
        bar = some_constexpr_function() - N,
        baz = foo + bar,
        // etc.
    }

什么是实现这种模板化等效的优雅或惯用方式？

Answer 1

也许重载逗号 constexprly 会满足您的需求？

#include <utility>

enum params {
    foo = 1,
    bar = 2,
    baz = 3
};


struct some_type_t { };
constexpr std::size_t some_constexpr_function() {
    return 0;
}


constexpr std::size_t operator ,(params P, std::size_t N) {
    switch (P) {
        case foo:
            return sizeof(some_type_t) < 32 ? 1 : 2;
        case bar:
            return some_constexpr_function() - N;
        case baz:
            return (foo, N) - (bar, N);
    }
    return 0;
}


template <std::size_t>
struct example { };

int main() {
    example<(baz, 2)>{};
}

[live demo]

Answer 2

到目前为止，我所做的是将我的枚举放在一个虚拟的持有者类中，可以模板化：

template <size_t N>
struct params
{
    enum {
        foo = sizeof(some_type_t) < 32 ? 1 : 2,
        bar = some_constexpr_function() - N,
        baz = foo + bar,
    };
}

但后来我不得不到处写params::foo、params::bar，这很乏味：

do_stuff_with(params::foo, params::bar)

而不是

do_stuff_with(foo, bar);

Answer 3

就像你在 cmets 中被告知的那样，我认为坚持将这些命名常量放在一个枚举之下是没有意义的。只需在单个命名空间范围内拥有一堆 constexpr 变量。您可以获得相同的净效果：

namespace constants {
    namespace detail {
                using underlying_t = int;
    }
    template<size_t N>
    constexpr detail::underlying_t foo = sizeof(some_type_t) < 32 ? 1 : 2;

    template<size_t N>
    constexpr detail::underlying_t bar = some_constexpr_function() - N;

    template<size_t N>
    constexpr detail::underlying_t baz = foo<N> + bar<N>;
}

它们都是constexpr，因此它们很容易成为运行时常量，如果需要，您可以在一个地方控制底层类型。此外，您可以通过完全限定的 id 访问它们，或者使用 using 指令将它们全部引入。