确保模板参数类型与其可变参数构造函数的类型匹配

为什么不简单地使用std::initialize_list:？

#include <iostream>
#include <type_traits>
#include <vector>
template <class T>
struct Foo
{
std::vector<T> data_;
explicit Foo(std::initializer_list<T> data) : data_(data)
{
std::cout << "1";
};
template <typename... Ts,
typename ENABLE=std::enable_if_t<(std::is_same_v<T,Ts> && ...)> >
explicit Foo(Ts... ts) : Foo(std::initializer_list<T>{ts...})
{
std::cout << "2";
}
};
int main()
{
Foo<int> f1{1, 3, 5, 7}; // prints 1
Foo<int> f2(1, 3, 5, 7); // prints 1 then 2
return 0;
}

如果某些Ts与T不同，则会收到编译时错误。

跟

gcc -std=c++17  prog.cpp  

你会得到：

Foo<int> f1{1, 3, 5., 7};

错误：将"5.0e+0"从"双精度"到"int"的转换范围缩小到内部 { } [-Wnarrowing] Foo f1{1， 3， 5.， 7}; ^

和

Foo<int> f2(1, 3, 5., 7);

你得到

错误：调用 'Foo：：Foo(int， int， double， int)' Foo f2(1， 3， 5.， 7); ^ 注：候选者：'模板Foo：：Foo(Ts ...)' 显式 Foo(Ts... ts) ： Foo(std：：initializer_list{ts...})

。

更新：如果你真的想使用像原始指针这样的东西，这里有一个完整的工作示例：

#include <iostream>
#include <memory>
#include <type_traits>
#include <vector>
template <class T>
struct Foo
{
size_t n_;
std::unique_ptr<T[]> data_;
explicit Foo(std::initializer_list<T> data) : n_(data.size()), data_(new T[n_])
{
std::copy(data.begin(), data.end(), data_.get());
std::cout << "1";
};
template <typename... Ts, typename ENABLE = std::enable_if_t<(std::is_same_v<T, Ts> && ...)> >
explicit Foo(Ts... ts) : Foo(std::initializer_list<T>{ts...})
{
std::cout << "2";
}
friend std::ostream& operator<<(std::ostream& out, const Foo<T>& toPrint)
{
for (size_t i = 0; i < toPrint.n_; i++)
std::cout << "n" << toPrint.data_[i];
return out;
}
};
int main()
{
Foo<int> f1{1, 3, 5, 7};  // prints 1
Foo<int> f2(1, 3, 5, 7);  // prints 1,2
std::cout << f1;
std::cout << f2;
return 0;
}

我让你用原始指针替换unique_ptr，并完成所有额外的工作：删除[]等...

>std::is_same只比较两种类型，并且不能使用包扩展来声明多个模板参数。 这意味着您需要将所有std::is_same检查拉出到另一个检查中：

template <typename T, typename... Ts>
struct all_same : std::bool_constant<(std::is_same<T, Ts>::value && ...)> {};
template <typename T>
struct Foo
{
std::vector<T> data_;
template <typename... Ts, std::enable_if_t<all_same<T, std::decay_t<Ts>...>::value>* = nullptr>
Foo(Ts&&... ts)
: data_{std::forward<Ts>(ts)...}
{
}
};

现场演示

您还需要为data_阵列分配内存。 在这里，我用std::vector为我处理分配，但如果你真的愿意，你可以使用new[]和delete[]自己管理它。

enable_if和is_same不会在任何地方存储任何内容，它们只是编译时构造，不会屈服于二进制可执行文件中的任何代码。

无论语法如何，您的代码本质上所做的是尝试获取构造函数参数的地址(这是一个临时参数)。一旦构造函数退出，这将是一个悬空的指针。

要么Foo拥有内存区域，必须在构造函数中分配并在析构函数中删除(如果有疑问：使用std::vector！)，要么它为一些外部存储器提供别名，并且必须接收指向该内存的指针。

现在关于语法：

• std::is_same是一个模板，它提供了一个value布尔常量，可以这样使用：std::is_same<T1, T2>::value。或者，您可以使用std::is_same_v<T1, T2>.
std::enable_if仅当
• 常量表达式(第一个模板参数)为 true 时才提供type类型成员。像std::enable_if<expr, T>::type一样使用它.如果expr为真，则type是要T的类型定义。否则，它未定义并产生替换失败。或者，您可以使用std::enable_if_t<expr, T>

你可以在这里看看你的类似方法。

但您也可以通过使用成员向量来简化所有这些。在这种情况下，向量构造函数确保所有参数都具有兼容的类型。下面是一个完整的示例：

#include <string>
#include <vector>
#include <iostream>
#include <type_traits>
using namespace std;
template<typename T>
struct Foo {
vector<T> data_;
template<typename ...Ts>
explicit Foo(Ts... ts) : data_{ ts... } {}
void print() {
for (const auto &v : data_) {
cout << v << " ";
}
cout << endl;
}
};
int main() {
Foo<int> ints { 1, 2, 3, 4, 5 };
Foo<string> strings { "a", "b", "c", "d", "e"};
// Foo<string> incorrect { "a", 2, "c", 4, "e"};
ints.print();
strings.print();
// incorrect.print();
return 0;
}

在 C++17 中执行此操作的最惯用方法是使用std::cunjunction_v。它懒惰地计算后续值，并允许您避免折叠表达式。此外，编译器生成的消息对于您在编辑的代码段中提到的两种情况都是相同的。

此外，通过 const-rvalue-ref 传递数据是没有意义的，因为不可能从 const 对象移动数据。此外，您正在将一堆论点移动到指针上。我不知道该怎么办，所以只是删除了它。

此外，看看std::decay_t- 没有它，它将无法工作，因为有时Ts不是被推断为int而是const int &或int &。这导致std::is_same_v是假的。

下面的代码在 godbolt 上编译得很好：

template<typename T>
struct Foo {
T* data_;
template<
typename... Ts,
std::enable_if_t<
std::conjunction_v<
std::is_same<T, std::decay_t<Ts>>...
>
> * = nullptr
>
explicit Foo( Ts&&... ts ) : data_{ } {}
};