`std::make_tuple` 的原因是什么？答案

【问题标题】：What is the reason for `std::make_tuple`?`std::make_tuple` 的原因是什么？
【发布时间】：2016-03-14 20:00:51
【问题描述】：

我的意思是为什么std::make_tuple 存在？我知道在某些情况下，该函数会减少您必须输入的字符数量，因为您可以避免使用模板参数。但这是唯一的原因吗？是什么让std::tuple 特别之处在于该函数存在而其他类模板没有这样的功能？仅仅是因为在这种情况下你可能会更频繁地使用std::tuple吗？

以下是std::make_tuple 减少字符数量的两个示例：

// Avoiding template parameters in definition of variable.
// Consider that template parameters can be very long sometimes.
std::tuple<int, double> t(0, 0.0); // without std::make_tuple
auto t = std::make_tuple(0, 0.0);  // with std::make_tuple

// Avoiding template parameters at construction.
f(std::tuple<int, double>(0, 0.0)); // without std::make_tuple
f(std::make_tuple(0, 0.0));         // with std::make_tuple

但就像上面写的那样，对于许多其他类模板，您没有这样的功能。

【问题讨论】：

类似的功能还有很多，但最明显的直接对比是std::make_pair。我认为经验法则可能是，如果您可能只想将这些对象构造为另一个表达式的一部分、调用函数等，它们可能存在。
您希望make_* 函数用于哪些其他类？我们已经获得了 make_shared、make_unique 等。
唯一的区别是类型推导。但是类型推断可能很有用，所以这就是原因。
并非所有类型都可以命名。例如。 make_tuple([&](){ f(x); }, std::mem_fn(&X::foo)).
make_tuple 属于make_tuple、tie 和forward_as_tuple 家族，它们分别为您提供prvalues、lvalues 和forwarded-values。

标签： c++ c++11 stdtuple

【解决方案1】：

因为你不能对构造函数使用参数推导。你需要明确写std::tuple<int, double>(i,d);。

它使创建元组并将其一次性传递给另一个函数更加方便。

takes_tuple(make_tuple(i,d)) 与 takes_tuple(tuple<int,double>(i,d)).

当i 或d 的类型发生变化时，需要更改的地方更少了，尤其是在新旧类型之间可能进行转换的情况下。

如果可以写 std::tuple(i,d);，make_* 将（可能）是多余的。

（不要在这里问为什么。也许出于类似的原因，语法 A a(); 不调用默认构造函数。有一些令人痛苦的 c++ 语法特性。）

更新说明： 正如Daniel 正确指出的那样，c++17 将得到增强，因此模板参数推导将适用于构造函数，而这种委托将变得过时。

【讨论】：

从C++17开始，可以使用类模板推演，即写std::tuple t(1, 1.0, 'a');或auto t = std::tuple(1, 1.0, 'a');。详情请参阅here。
将您的更新说明包含在答案中。感谢您致电。
@luk32 "这样的委托将变得过时" 我不同意：std::make_tuple 将使用 X& 如果你在 std::ref() 调用中包装一些东西，这在 C++17 中仍然有用，因为deduction guides for std::tuple 似乎没有处理这种情况。

【解决方案2】：

我们可以在提案 N3602: Template parameter deduction for constructors 中找到为什么我们需要 make_tuple 和各种其他 make_* 实用程序的理由（强调我的）：

本文提出将函数的模板参数推导扩展到模板类的构造函数。描述问题和解决方案的最清晰方法是举一些例子。

假设我们定义了以下内容。
vector<int> vi1 = { 0, 1, 1, 2, 3, 5, 8 }; 
vector<int> vi2; template<class Func> 
    class Foo() { 
        public: Foo(Func f) : func(f) {} 
        void operator()(int i) { os << "Calling with " << i << endl; f(i); } 
        private: 
        Func func;
    };
目前，如果我们想实例化模板类，我们需要要么指定模板参数，要么使用“make_*”包装器，利用函数的模板参数推导，或者完全弃用：
pair<int, double> p(2, 4.5); 
auto t = make_tuple(4, 3, 2.5); 
copy_n(vi1, 3, back_inserter(vi2)); // Virtually impossible to pass a lambda to a template class' constructor
for_each(vi.begin(), vi.end(), Foo<???>([&](int i) { ...}));

请注意，该提案正在通过EWG issue 60 进行跟踪。

【讨论】：

@black 我刚刚添加到我的答案中的 EWG 问题暗示了一些问题，但这项工作受到了鼓励。尚未从 Kona 更新 EWG 活动列表，所以这可能已经改变。

【解决方案3】：

我认为巧妙地使用这类函数是作为参数传递。
类似的东西：

std::bind_front(&std::make_tuple, 1, "test", true);

这可能很有用，因为如果我没记错的话，我们不能直接调用构造函数。

auto obj = Object::Object(3); // error: cannot call constructor ‘Object::Object’ directly [-fpermissive]

【讨论】：

【解决方案4】：

仅用于模板参数推导。但是，这是一个（人为的）示例，其中需要使用 lambda：

class A
{
public:
    template<typename F>
    A(const std::tuple<F> &t)
    {
        // e.g.
        std::get<0>(t)();
    }
};

class B : public A
{
public:
     B(int i) : A(std::make_tuple([&i]{ ++i; }))
     {
         // Do something with i
     }
};

std::tuple<decltype([&i]{ ++i; })>([&i]{ ++i; }) 不能使用，因为这两个 lambda 表达式具有不同的类型。像std::function 这样的多态包装器会增加运行时开销。具有用户定义的operator () 的命名类将起作用（它可能还需要成为B 的朋友，具体取决于操作符主体的内容）。这就是我们在 C++11 之前的日子里使用的东西。

【讨论】：