C++ 仅初始化c++；11元组

最简单的工作示例：

#include <tuple>

struct example
{
    example(int, char) {}
};

int main()
{
    std::tuple<example, int, double>
        my_tuple(example(0, 'x'), 42, .0);
    // std::tuple t = make_my_tuple(0, 'x');
    return 0;
}

#包括
结构示例
{
示例（int，char）{}
};
int main（）
{
std:：tuple
我的元组（例如（0，'x'），42，.0）；
//std:：tuple t=make_my_tuple（0，'x'）；
返回0；
}

这很有效

是否有一种更优雅的方式来初始化第一个成员，就像我在评论中所描述的那样？一个只接受参数来构造第一个元组成员而不初始化其他元组成员的元组

---

我问的原因是什么？我只是对语言的语义感兴趣。

你说没有必要为其他两个成员提供值-你担心性能吗？或者这些成员可能没有合适的价值

如果是后者，您可以使用tuple hold boost:：optionals。e、 g

#include <tuple>
#include <boost/optional.hpp>

using namespace boost;

struct example
{
    example(int, char) {}
};

typedef std::tuple<example, optional<int>, optional<double>> MyTuple;

int main()
{
   MyTuple my_tuple(example(0, 'x'), optional<int>(), optional<double>());
   return 0;
}

#包括
#包括
使用名称空间boost；
结构示例
{
示例（int，char）{}
};
typedef std:：tuple MyTuple；
int main（）
{
MyTuple my_tuple（例如（0，'x'），optional（），optional（））；
返回0；
}

现在，在语义上，int和float是“未初始化”的，并且可以查询它们的值

为了使这一点更加优雅，您可以将其封装到函数中，对参数使用完美的转发习惯用法（通常；在这种情况下，您的参数复制成本很低，因此这样做不会带来速度方面的好处）：

模板
MyTuple make_MyTuple（Args&&…Args）
{
返回MyTuple（例如（std:：forward（args）…）、optional（）、optional您可以使用统一初始化。遗憾的是，您无法定义默认值，参数将使用默认构造函数或0进行初始化

#include <iostream>
#include <tuple>

enum class Result {Full, Partial, Empty};
std::tuple<bool, int, double> get_tuple(Result type)
{
    if (type == Result::Full)
        return {true, 42, 3.14159};
    else if (type == Result::Partial)
        return {true, 42, {}};
    else
        return {};
}

int main()
{
    bool b;
    int i;
    double d;

    std::tie(b, i, d) = get_tuple(Result::Full);
    std::cout << b << " " << i << " " << d << std::endl;

    std::tie(b, i, d) = get_tuple(Result::Partial);
    std::cout << b << " " << i << " " << d << std::endl;

    std::tie(b, i, d) = get_tuple(Result::Empty);
    std::cout << b << " " << i << " " << d << std::endl;

    return 0;
}

tuple怎么知道第二个参数是42？@it wasntpet我还不想初始化第二个和第三个参数。好的，但是第一个参数应该是一个例子吗？你可以假设它现在总是
struct example
类型，是的。你是说你想为除了第一个？如果是这样的话，我看不到你将如何使用一个元组来做这件事（不管怎么说，没有你自己的）。至少std:：tuple将初始化未指定的成员，我看不到你会以任何方式绕过这一步（至少不是很明显），这不是我能理解你想要的原因。谢谢，但我不担心找到好的起始值。我只是希望构造函数调用起来更“舒适”。好的，谢谢，尽管它仍然对第二个和第三个成员进行不必要的初始化。但至少，它有助于解决这个问题。：）确实如此，但如果是可选的，则默认初始化的成本与初始化布尔值的成本相同，因此，如果要使用比int或double更昂贵的初始化类型，则速度会更快。此外，它还提供了询问“此元素是否已初始化”的语义
#include <iostream>
#include <tuple>

enum class Result {Full, Partial, Empty};
std::tuple<bool, int, double> get_tuple(Result type)
{
    if (type == Result::Full)
        return {true, 42, 3.14159};
    else if (type == Result::Partial)
        return {true, 42, {}};
    else
        return {};
}

int main()
{
    bool b;
    int i;
    double d;

    std::tie(b, i, d) = get_tuple(Result::Full);
    std::cout << b << " " << i << " " << d << std::endl;

    std::tie(b, i, d) = get_tuple(Result::Partial);
    std::cout << b << " " << i << " " << d << std::endl;

    std::tie(b, i, d) = get_tuple(Result::Empty);
    std::cout << b << " " << i << " " << d << std::endl;

    return 0;
}

1 42 3.14159
1 42 0
0 0 0