在编译时验证std :: initializer_list的内容

Question

我试图在编译时确定std::initializer_list中的所有值是否唯一。 我能够找到一种解决方案来改变列表的大小 ，但是无法将其应用于内容。 我尝试使用自由函数和构造函数，但两种方法均导致GCC 4.7.2出现以下错误。

错误：静态声明的非恒定条件
错误：“开始”不是常量表达式

我意识到没有声明std::initializer_list的成员为constexpr但我希望有一个像大小验证这样的解决方案。 是否可以使用以下类似的方法在编译时验证内容？

#include <initializer_list>

template<typename InputIterator>
constexpr bool Validate(InputIterator begin, InputIterator end)
{
    static_assert(*begin == *end, "begin and end are the same");
    //  The actual implemetnation is a single line recursive check.
    return true;
}

template<typename InputType>
constexpr bool Validate(const std::initializer_list<InputType>& input)
{
    // "-1" removed to simplify and eliminate potential cause of error
    return Validate(input.begin(), input.end() /* - 1 */);
}

int main()
{
    Validate({1, 2, 1});
}

Answer 1

经过一番挖掘后，由于在声明中缺少constexpr ，因此在GCC 4.7中似乎无法使用std::initializer_list 。 它应该与GCC 4.8一起使用，因为<initializer_list>已更新为包括constexpr 。 不幸的是，目前还不能使用GCC 4.8。

但是，如果通过引用传递了衰减的指针，则可以访问数组的元素。 这样可以根据需要进行验证，但仍然不是我希望的解决方案。 以下代码是数组的可行解决方案。 仍然需要将数组的大小提供给验证功能，但是要足够容易地进行校正。

#include <initializer_list>

template<typename T>
constexpr bool Compare(T& data, int size, int needleIndex, int haystackIndex)
{
    return
        needleIndex == haystackIndex ?
            Compare(data, size, needleIndex + 1, haystackIndex)
        :   needleIndex == size ?
                false
            :   data[needleIndex] == data[haystackIndex] ?
                    true
                :   Compare(data, size, needleIndex + 1, haystackIndex);
}

template<typename T>
constexpr bool Compare(T& data, int size, int index)
{
    return
        index == size ?
            false
        :   Compare(data, size, index + 1) ?
                true
            :   Compare(data, size, 0, index);
}


template<typename T, int ArraySize>
constexpr bool Validate(T(&input)[ArraySize], int size)
{
    return !Compare(input, size, 0);
}

int main()
{
    constexpr int initData0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    constexpr int initData1[] = {1, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    constexpr int initData2[] = {2, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    constexpr int initData3[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 8};
    constexpr int initData4[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 7};
    constexpr int initData5[] = {0, 1, 0, 3, 4, 5, 6, 7, 8, 9};
    constexpr int initData6[] = {0, 1, 2, 3, 4, 5, 6, 9, 8, 9};

    static_assert(Validate(initData0, 10), "set 0 failed"); // <-- PASS
    static_assert(Validate(initData1, 10), "set 1 failed"); // <-- (and below) FAIL
    static_assert(Validate(initData2, 10), "set 2 failed");
    static_assert(Validate(initData3, 10), "set 3 failed");
    static_assert(Validate(initData4, 10), "set 4 failed");
    static_assert(Validate(initData5, 10), "set 5 failed");
    static_assert(Validate(initData6, 10), "set 6 failed");
}

。

构建日志：

C：\\ Source \\ SwitchCaseString \\ main.cpp：在函数'int main（）'中：
C：\\ Source \\ SwitchCaseString \\ main.cpp：198：2：错误：静态断言失败：设置1失败
C：\\ Source \\ SwitchCaseString \\ main.cpp：199：2：错误：静态断言失败：设置2失败
C：\\ Source \\ SwitchCaseString \\ main.cpp：200：2：错误：静态断言失败：设置3失败
C：\\ Source \\ SwitchCaseString \\ main.cpp：201：2：错误：静态断言失败：设置4失败
C：\\ Source \\ SwitchCaseString \\ main.cpp：202：2：错误：静态断言失败：设置5失败
C：\\ Source \\ SwitchCaseString \\ main.cpp：203：2：错误：静态断言失败：设置6失败