在我使用的所有现代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;
