c++ - 接受转换为相同类型的 N 个参数

Question

我目前正在尝试制作 vector C++中的类。
该类应该有一个构造函数，它接受与 vector 中的维度一样多的参数。维度在实例化 vector 时由模板定义。
所有扩充都应该能够转换为 vector 源自的相同数据类型(在模板中定义)。
这是我到目前为止所写的(我在这里使用了许多其他问题的片段):

// this section is to create an typedef struct all_same which checks if all elements are of the same type

template<typename ...T>  // head template
struct all_same : std::false_type { };

template<>  // accept if no elements are present
struct all_same<> : std::true_type { };

template<typename T>  // accept if only one element is present
struct all_same<T> : std::true_type { };

template<typename T, typename ...Ts>  // check if first and second value are the same type and recurse
struct all_same<T, T, Ts...> : all_same<T, Ts...> { };



template<typename T, size_t N>
class vec_abs {
public:
    vec_abs(const vec_abs &vec);  // construct from another vector
    explicit vec_abs(const std::array<T, N> &arr);  // construct from array

    template<typename ...Ts> requires // only compile if:
            all_same<typename std::decay<Ts>::type...>::type  // all are the same type (this might be optional, no sure)
            && std::conjunction<std::is_convertible<Ts, T>...>::value &&  // all can be converted to T
            (sizeof(Ts) == N)  // there are N arguments
    explicit vec_abs(const Ts&&... values);  // construct from multiple arguments

private:
    std::array<T, N> data;
};

代码的第一部分测试所有参数是否属于同一类型，取自此 question .
我对这个解决方案非常不确定(主要是因为它不起作用:D)并且希望得到任何关于改进的建议。
感谢您的帮助!

Answer 1

如果您不希望所有参数都属于同一类型，则可以删除该部分。除此之外，你在这里有一个错字:

(sizeof(Ts) == N) 

应该

(sizeof...(Ts) == N) 

修复该问题后，转发参数并添加构造函数的定义，您的代码似乎可以执行您想要的操作:

#include <type_traits>
#include <array>
#include <iostream>

template<typename T, size_t N>
struct vec_abs {
    template<typename ...Ts> requires // only compile if:
            std::conjunction<std::is_convertible<Ts, T>...>::value &&  // all can be converted to T
            (sizeof...(Ts) == N)  // there are N arguments
    explicit vec_abs(Ts&&... values) : data({std::forward<Ts>(values)...}) {}
    std::array<T, N> data;
};

int main() {
    auto foo = vec_abs<int,3>(1,2,3);
    foo = vec_abs<int,3>(1.0,2,3);    
    for (const auto& e : foo.data) std::cout << e;

    auto bar = vec_abs<std::string,3>("foo",std::string{"bar"},"moo");
    for (const auto& e : bar.data) std::cout << e;
    // bar = vec_abs<std::string,3>(123,1.2); // error wrong number
    //bar = vec_abs<std::string,3>(123,1.2,42); // error cannot be converted
}

Output: :

123foobarmoo

如果您确实想要所有参数都是相同类型的约束...
正如另一个答案所提到的，您的 all_same 中的递归可以避免。以下已经在 C++11 中工作。不幸的是，我再也找不到原始来源了。

template <typename T,typename...Ts>
struct all_same {
    static const bool value = std::is_same< all_same, all_same<Ts...,T>>::value;
};