功能的一个整数

Question

我有一个类与接受的整数的模板来确定的参数的固定量：

template <unsigned int N> 
class Example {}; 

我在寻找一种方法来定义一个（部件）函数接受一些数量为Example对象作为参数。量是由N来决定，因此功能会像这样使用：

Function(Example<2>(), Example<2>()); 
Function(Example<3>(), Example<3>(), Example<3>()); 

我试了一下，到目前为止：

使用的初始化列表，一个是能够通过一组对象的功能：

template <unsigned int N> 
void Function(std::initializer_list<Example<N>> list); 
//... 
Function({Example<2>(), Example<2>()}); 

然而，除了那真的只有一个参数传递（列表）的事实，问题是，这种方法可以使用任意数量的参数：

Function({Example<2>()}); 

我使用可变参数函数也试过：

template <unsigned int N> 
void Function(Example<N> e...) 
{ 
    va_list args; 
    va_start(args, e); 
    //... 
} 
Function(Example<2>(), Example<2>()); 

这使得可以使用真正的参数，但使用任意数量的参数的问题仍然存在，而这是不可能知道有多少争论实际上已通过。

Answer 1

假设你想要的参数从Example<N>类型推断的数量，并且所有Example<I>应该共享相同的这种N，一个C++ 17的解决方案可能是

template <unsigned int... I> 
auto Function(Example<I>...) -> 
    std::enable_if_t<((I == sizeof...(I)) && ...)> 
{ 
    // or static_assert() if you always want an error 
} 

Answer 2

让Function一个可变参数模板和使用std::enable_if_t来约束你的吧：

• 一些IsExample特性可用于确保所有参数都是Example

• sizeof...(pack)可实例用于获取参数包的大小

template <unsigned int N, typename... Ts> 
auto Function(Ts... xs) 
    -> std::enable_if_t<(IsExample<Ts>::value && ...) 
        && (sizeof...(Ts) == N)> 
{ 
} 

live example on wandbox

Answer 3

您应该在static_assert中使用可变参数函数模板。与涉及enable_if的方法不同，如果传递了不正确的参数，则此方法将产生一个可读的错误消息。

template<unsigned int ... I> 
void Function(Example<I>... items) 
{ 
    static_assert 
    (
     true && (... && (static_cast<unsigned int>(sizeof...(I)) == I)) 
    , "This function accepts N arguments of type Example<N>" 
    ); 
} 

Online compiler

Answer 4

+1为的Massimiliano简氏优雅的解决方案。

不幸的是使用折叠因此只适用于C++ 17。

为了测试，用C++ 11/C++ 14，即所有I是等于sizeof...(I)（这也许sizeof...(I)等于N，其中N是类模板参数），这是足够的测试，一个可变参数类型，它接收无符号值，是具有不同值的顺序的相同类型。

我的意思是：宣布一个微不足道的结构作为

template <std::size_t ... Is> 
struct IList; 

测试可以

std::is_same<IList<N, sizeof...(Is), Is...>, 
      IList<sizeof...(Is), Is..., N>>::value 

从C++ 14有可能开始使用std::index_sequence而不是IList。

所以Example可以写成

template <unsigned int N> 
struct Example 
{ 
    template <unsigned int ... Is> 
    auto Function (Example<Is> ...) 
     -> typename std::enable_if< 
      std::is_same<IList<N, sizeof...(Is), Is...>, 
         IList<sizeof...(Is), Is..., N>>::value>::type 
    { /* do something */ } 
}; 

下面是使用的例子（但要记住，<type_traits>）

int main() 
{ 
    Example<1U> e1; 
    Example<2U> e2; 

    // e1.Function(); // error 
    e1.Function(Example<1>{}); // compile 
    //e1.Function(Example<1>{}, Example<1>{}); // error 

    // e2.Function(); // error 
    //e2.Function(Example<2>{}); // error 
    e2.Function(Example<2>{}, Example<2>{}); // compile 
    //e2.Function(Example<2>{}, Example<2>{}, Example<2>{}); // error 
} 

Answer 5

有覆盖SFINAE友好的基于约束的很多答案，但我不喜欢把我的SFINAE放在返回值中：

template <unsigned int... Is, 
    std::enable_if_t<((Is == sizeof...(Is)) && ...), bool> = true 
> 
void Function(Example<Is>... examples) 
{ 
    // code 
} 

或

template<bool b> 
using test_requirement = std::enable_if_t<b, bool>; 

template <unsigned int... Is, 
    test_requirement<((Is == sizeof...(Is)) && ...)> = true 
> 
void Function(Example<Is>... examples) 
{ 
    // code 
} 

可能感兴趣的