Question

我是c ++模板元编程的新手。

我试图从枚举数组中生成constexpr特殊类的元组。

我正在使用c ++ 14。

这是我的示例代码。

我尝试使用http://en.cppreference.com/w/cpp/utility/integer_sequence但是专门的课程存在问题。

#include <iostream>
#include <utility>
#include <tuple>

enum class ClassType{  kA,  kB,  kC };

template<ClassType Type>
class Event;

template<>
class Event<ClassType::kA>{ void func() { std::cout << "A" << std::endl; } };

template<>
class Event<ClassType::kB>{ void func() { std::cout << "B" << std::endl; } };

template<>
class Event<ClassType::kC>{ void func() { std::cout << "C" << std::endl; } };

class EventList
{
 public:
  constexpr EventList() : size_(0), list_{ClassType::kA,} {}
  ClassType list_[255];
  int size_;
};
template <std::size_t Index, EventList&& List>
                             constexpr auto GetEvent()
{
  return Event<List.list_[Index]>();
}

constexpr auto CreateEventList()
{
  EventList list;
  list.list_[0] = ClassType::kA;
  list.list_[1] = ClassType::kB;
  list.list_[2] = ClassType::kC;
  list.size_ = 3;
  return list;
}

int main()
{
  constexpr auto eventlist =CreateEventList();

  constexpr std::tuple<Event<eventlist.list_[0]>,
                       Event<eventlist.list_[1]>,
                       Event<eventlist.list_[2]>
                       // ... until i==listsize-1
                       > gentuple;
  constexpr auto t = CreateTupleFromArray(eventlist);
}

我也试过这样的另一种方式。

template<std::size_t SIZE>
constexpr auto CreateArray()
{
  std::array<ClassType, SIZE> array = {ClassType::kA,};

  for( auto i=0 ; i<SIZE ; ++i )
    array[i] = static_cast<ClassType>(i % 3);

  return array;
}
template<typename Array, std::size_t... I>
decltype(auto) a2t_impl(const Array& a, std::index_sequence<I...>)
{
  return std::make_tuple(Event<a[I]>()...);
}

template<typename T, std::size_t N, typename Indices = std::make_index_sequence<N>>
decltype(auto) a2t(const std::array<T, N>& a)
{
  return a2t_impl(a, Indices{});
}

int main()
{
  auto arr = CreateArray<15>();
  auto tu = a2t(arr);
}

但是有这样的编译错误。

main.cc:70:32: error: non-type template argument is not a constant expression
  return std::make_tuple(Event<a[I]>()...);
                               ^
main.cc:76:10: note: in instantiation of function template specialization
      'a2t_impl<std::array<ClassType, 15>, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
      13, 14>' requested here
  return a2t_impl(a, Indices{});
         ^
main.cc:82:13: note: in instantiation of function template specialization
      'a2t<ClassType, 15, std::integer_sequence<unsigned long, 0, 1, 2, 3, 4, 5, 6,
      7, 8, 9, 10, 11, 12, 13, 14> >' requested here
  auto tu = a2t(arr);

我认为Array＆amp; a应该是一个模板参数，但是还存在关于“cv-qualification上的冲突”的编译错误。

Answer 1

我理解你的问题，如果你传入ClassType::kA, ClassType::kB, ClassType::kC, ClassType::kA，你希望调用一个返回例如main.cc:70:32: error: non-type template argument is not a constant expression return std::make_tuple(Event<a[I]>()...);的函数。这里的挑战如下：函数的返回类型（必须在编译时知道）取决于您传入的信息。但是，参数'值你传递给constexpr函数是不是常量表达式。

考虑到这一点，人们可以理解编译器的抱怨

template<typename Array, std::size_t... I>
auto a2t_impl(const Array& a, std::index_sequence<I...>) {
  return std::make_tuple(Event<a[I]>()...);
}

在上下文中

constexpr auto eventlist = CreateEventList();
constexpr auto tuple_of_events = create_tuple_from_array([=] { return eventlist;});

C ++ 17解决方案是将参数包装在constexpr lambda中：

namespace detail {

template<class WrappedEventList, size_t... is>
constexpr auto create_tuple_from_array_impl(
  WrappedEventList wel, std::index_sequence<is...>
) {
  constexpr auto list = wel();
  return std::make_tuple(Event<list[is]>{}...);
}

}// detail

template<class WrappedEventList>
constexpr auto create_tuple_from_array(WrappedEventList wel) {
  return detail::create_tuple_from_array_impl(
    wel, std::make_index_sequence<wel().size()>{}
  );
}

允许编译器在编译时推导出返回类型：

doesLoginExist

Quick and dirty C++17 online demo - 我没有阅读您的所有代码，只是“让它成功”

在 C ++ 14及以下中，可能会尝试将枚举作为非类型模板参数传递。

在c ++中从enum数组生成各种专用类的constexpr元组

1 个答案: