在我使用的所有现代C编译器中,以下是合法的：
std::array<float,4> a = {1,2,3,4};
我正在尝试创建具有类似构造语义的我自己的类,但我遇到了一个恼人的问题.考虑以下尝试：
#include <array>
#include <cstddef>
template<std::size_t n>
class float_vec
{
private:
std::array<float,n> underlying_array;
public:
template<typename... Types>
float_vec(Types... args)
: underlying_array{{args...}}
{
}
};
int main()
{
float_vec<4> v = {1,4}; // error here
}
当使用上面的int文字时,编译器抱怨它不能隐式地将int转换为float.我认为它在std :: array示例中有效,因为给出的值是已知在float域内的编译时常量.另一方面,可变参数模板使用int作为参数类型,转换发生在构造函数的初始化列表中,其中值在编译时是未知的.
我不想在构造函数中进行显式强制转换,因为即使它们不能用float表示,它也允许所有数值.
我能想到得到我想要的唯一方法是以某种方式具有可变数量的参数,但具有特定类型(在这种情况下,我想要浮动).我知道std :: initializer_list,但我希望能够在编译时强制执行参数的数量.
有任何想法吗？ C 11是我想要的吗？为C 14提出的任何新建议都能解决这个问题吗？
解决方法
一个小技巧是使用构造函数继承.只需让你的类派生自另一个具有一包你想要的参数的类.
template <class T,std::size_t N,class Seq = repeat_types<N,T>>
struct _array_impl;
template <class T,class... Seq>
struct _array_impl<T,N,type_sequence<Seq...>>
{
_array_impl(Seq... elements) : _data{elements...} {}
const T& operator[](std::size_t i) const { return _data[i]; }
T _data[N];
};
template <class T,std::size_t N>
struct array : _array_impl<T,N>
{
using _array_impl<T,N>::_array_impl;
};
int main() {
array<float,4> a {1,4};
for (int i = 0; i < 4; i++)
std::cout << a[i] << std::endl;
return 0;
}
以下是repeat_types实用程序的示例实现.此示例使用对数模板递归,与线性递归相比,它实现起来不太直观.
template <class... T>
struct type_sequence
{
static constexpr inline std::size_t size() noexcept { return sizeof...(T); }
};
template <class,class>
struct _concatenate_sequences_impl;
template <class... T,class... U>
struct _concatenate_sequences_impl<type_sequence<T...>,type_sequence<U...>>
{ using type = type_sequence<T...,U...>; };
template <class T,class U>
using concatenate_sequences = typename _concatenate_sequences_impl<T,U>::type;
template <std::size_t N,class T>
struct _repeat_sequence_impl
{ using type = concatenate_sequences<
typename _repeat_sequence_impl<N/2,T>::type,typename _repeat_sequence_impl<N - N/2,T>::type>; };
template <class T>
struct _repeat_sequence_impl<1,T>
{ using type = T; };
template <class... T>
struct _repeat_sequence_impl<0,type_sequence<T...>>
{ using type = type_sequence<>; };
template <std::size_t N,class... T>
using repeat_types = typename _repeat_sequence_impl<N,type_sequence<T...>>::type;