强制表达式为 constexpr

Question

给定两个constexpr 函数，是否可以将它们组合成一个函数？

template <char... C>
constexpr int boo()
{
    char ch[] = { C... };
    int count = 0;

    for (char c : ch)
    {
        if (c != '0') count += 1;
    }

    return count;
}

template <char... C>
constexpr auto foo()
{
    std::array<char, boo<C...>()> x{};

    return x;
}

如示例所示，我可以将“count”作为常量返回。 我的问题是我不能在声明的函数中使用 'count' 作为常量。也就是说，如果“boo()”的主体放在“foo()”中，编译器会抛出“count”不是常量。

Answer 1

问题是std::array 需要一个常量作为大小值。

如果您定义count 并在foo() 内部对其进行修改，则count（如foo() 函数内部所示）是一个变量，而不是一个常量。

所以你需要在另一个地方修改它：在一个constexpr 函数中，所以返回的值变成一个编译时已知的常量。

如果你可以使用 C++17，那么模板折叠（从 Evg 和 Rakete1111 改进；谢谢），你可以完全避免 bar()

template <char... C>
constexpr auto foo()
{
    std::array<char, (0u + ... + (C != '0'))> x{};

    return x;
}

但如果你只有 C++11，你需要递归

template <typename = void>
constexpr std::size_t bar ()
 { return 0u; }

template <char C0, char ... C>
constexpr std::size_t bar ()
 { return bar<C...>() + (C0 == '0' ? 0u : 1u); }

template <char... C>
constexpr std::array<char, bar<C...>()> foo()
 { return {}; }

Answer 2

对于 C++14 及更高版本，如果您的目标是“合并”主体，您可以简单地在函数模板中定义一个类型：

template <char... C>
constexpr auto foo()
{
    struct {
        constexpr int operator()() {
            char ch[] = { C... };
            int count = 0;

            for (char c : ch)
            {
                if (c != '0') count += 1;
            }

            return count;
        };
    } boo;

    std::array<char, boo()> x{};

    return x;
}

如果你有 C++17，你也可以在常量表达式中使用 lambda，所以你可以将 boo 缩短为：

constexpr auto boo = []() { /* ... */ };

在 C++20 中，您将能够将 lambda 表达式直接编写为模板参数，因此您可以进一步简化为（如果您真的想要的话）：

std::array<char, []() { /* ... */ }()> x{};

话虽如此，一般来说，我想说的是，在标头中包含模板使用的各种额外代码但不属于公共接口的通常（更简洁）方法是将它们放在 @987654325 @ 或类似名称的命名空间：

namespace detail {
    template <char... C>
    constexpr int boo()
    {
        /* ... */
    }
}

template <char... C>
constexpr auto foo()
{
    /* ... detail::boo<C...>() ... */
}