Question

在现代C ++（GCC 5.1.0中，我猜是C ++ 14）中，在编译时传递enum的值列表的最快方法是什么，然后，在运行时，检查哪些值在那里？

enum foobar { foo, bar, baz };

template<????>
void f() {
  if( contains<????, foo>() )
    std::cout << "foo!";
  if( contains<????, bar>() )
    std::cout << "bar!";
  if( contains<????, baz>() )
    std::cout << "baz!";
}

f<foo,bar>();

注意：这是针对单元测试的，所以速度等主要是无关紧要的，主要目的是让不熟悉代码的人可以辨认。

Answer 1

这是一个提案

#include <initializer_list>// pulled in by a lot of stuff

enum class options  { foo,bar,baz };
void test_func(options opt)
{

}
int main()
{
    auto test_vector = { options::foo, options::bar  };
    for (auto option : test_vector)
    {
        test_func(option);
    }
    return 0;
}

检查提供的测试向量是否包含它们应包含的内容稍微复杂一些：

#include <initializer_list>
#include <algorithm>
#include <stdexcept>

enum class options { foo, bar, baz, wuz };
void test_func(options)
{

}

template<typename AT, typename BT>
void assert_test_vectors(AT a, BT check_these_items)
{
    for (auto item : check_these_items)
    {
        auto test = std::find(a.begin(), a.end(), item) != a.end();
        if (!test)
        {
            return throw std::runtime_error("You suck");
        }
    }
}

template<typename T>
void run_tests(T tests)
{
    const auto better_have_these = { options::foo, options::bar };
    assert_test_vectors(tests, better_have_these);
    for (auto test : tests)
    {
        test_func(test);
    }
}

int main()
{
    const auto test_vectors = { options::foo, options::wuz };
    run_tests(test_vectors);
    return 0;
}

Answer 2

我不知道你是否仍然感兴趣但是......回答你原来的问题...如果你改变contain的模板参数的顺序......我的意思是

if( contains<foo, ????>() )

而不是

if( contains<????, foo>() )

您的contains（在以下示例中重命名为containsFB）可以从C ++ 14开始，一个简单的constexpr函数

template <foobar F0, foobar ... Fs>
constexpr bool containsFB ()
 {
   using unused = bool[];

   bool ret { false };

   (void)unused { false, ret |= F0 == Fs ... };

   return ret;
 }

从C ++ 17开始，你也可以使用模板折叠，constantFB可以写成继承自std::true_type或std::false_type的类型特征。

template <foobar F0, foobar ... Fs>
struct containsFB : public std::integral_constant<bool, ((F0 == Fs) || ...)>
 { };

以下是一个完整的C ++ 14示例

#include <iostream>
#include <utility>

enum foobar { foo, bar, baz };


template <foobar F0, foobar ... Fs>
constexpr bool containsFB ()
 {
   using unused = bool[];

   bool ret { false };

   (void)unused { false, ret |= F0 == Fs ... };

   return ret;
 }

/* C++17 alternative
template <foobar F0, foobar ... Fs>
struct containsFB : public std::integral_constant<bool, ((F0 == Fs) || ...)>
 { };
 */

template <foobar ... Fs>
void f ()
 {
   if( containsFB<foo, Fs...>() ) std::cout << "foo!";
   if( containsFB<bar, Fs...>() ) std::cout << "bar!";
   if( containsFB<baz, Fs...>() ) std::cout << "baz!";
 }

int main ()
 {
   f<foo,bar>();
 }

如果你想使containsFB（函数或结构）更通用一些，你可以模板化值的类型;所以

template <typename T, T F0, T ... Fs>

而不是

template <foobar F0, foobar ... Fs>

Answer 3

Variadic选项。正如预期的那样打印«foo！bar！baz！foo！»。

enum class foobar { foo, bar, baz };

void test() {}

template< typename F, typename... Fs >
void test( F Foo, Fs const&... args )
{
    switch( Foo )
    {
    case foobar::foo:
        std::cout << "foo!";
        break;
    case foobar::bar:
        std::cout << "bar!";
        break;
    case foobar::baz:
        std::cout << "baz!";
        break;
    }
    test( args... );
}

int main() {
    test( foobar::foo, foobar::bar, foobar::baz, foobar::foo );
}

枚举值的编译时列表

3 个答案: