C++ 如何初始化c+中返回元组的变量+；？

我有一个函数xyz（），它返回一个

元组。
当我单独调用此函数时，我可以执行以下操作：

auto [tresh, loss] = xyz(i);

这不会导致错误，但是如果我想在if-else块中使用xyz（）函数，那么我就不能在下面的代码中再使用
tresh
和
loss
变量。例如：

if (boolX) {
        auto [tresh, loss] = xyz(i);
    } else {
        auto [tresh, loss] = xyz(j);
    }
std::cout << tresh << std::endl;

if（boolX）{
自动[tresh，损耗]=xyz（i）；
}否则{
自动[tresh，损耗]=xyz（j）；
}
std：：cout根据确切的代码，您可以用三元

auto [tresh, loss] = boolX ? xyz(a) : xyz(b);
std::cout << tresh << std::endl;

auto[tresh，loss]=boolX？xyz（a）：xyz（b）；
std：：cout您可以使用lambda：

auto [tresh, loss] = [&boolX, &i, &j](){
    if (boolX) {
        return xyz(i);
    } else {
        return xyz(j);
    }
}();
std::cout << tresh << std::endl;

auto[tresh，loss]=[&boolX，&i，&j]（）{
if（boolX）{
返回xyz（i）；
}否则{
返回xyz（j）；
}
}();
在创建结构化绑定之前，std:：cout是解包元组的解决方案

std::string tresh;
double loss;
if (boolX) {
    std::tie(tresh, loss) = xyz(i);
} else {
    std::tie(tresh, loss) = xyz(i);
}
std::cout << tresh << std::endl;

std:：字符串树；
双重损失；
if（boolX）{
标准：：tie（tresh，损耗）=xyz（i）；
}否则{
标准：：tie（tresh，损耗）=xyz（i）；
}
std：：cout您可以这样做：

std::tuple<std::string, double> results;
if (boolX) {
    results = xyz(i);
}
else {
    results = xyz(j);
}
auto [tresh, loss] = results;
std::cout << tresh << std::endl;

std:：元组结果；
if（boolX）{
结果=xyz（i）；
}
否则{
结果=xyz（j）；
}
自动[tresh，损失]=结果；
std：：cout您需要在个别案例之外声明这两个变量，以便在外部访问它们。您可以使用
std:：tie
将两者“绑定”在一起：

#include <iostream>
#include <tuple>
#include <string>
std::tuple<std::string,double> xyz() { return {"foo",1.0}; }

int main() {
    std::string a;
    double b;
    bool condition = false;
    if (condition) {
        std::tie(a,b) = xyz();
    } else {
        std::tie(a,b) = xyz();
    }
    std::cout << a << " " << b;
}

#包括
#包括
#包括
std:：tuple xyz（）{return{“foo”，1.0}；}
int main（）{
std：：字符串a；
双b；
布尔条件=假；
如果（条件）{
std:：tie（a，b）=xyz（）；
}否则{
std:：tie（a，b）=xyz（）；
}
std：：cout您可以重新构造代码，因此您可以在其分支中执行此工作：

if (boolX) {
    auto [tresh, std::ignore] = xyz(i);
    std::cout << tresh << std::endl;
} else {
    auto [tresh, std::ignore] = xyz(j);
    std::cout << tresh << std::endl;
}

if（boolX）{
auto[tresh，std:：ignore]=xyz（i）；
std:：你难道不知道变量的作用域吗？你需要使用std:：tie。只要在
if
之外声明
tresh，loss
，我讨厌有人这样使用lambda。这应该只是定义一个函数。@MarekR这是你的意见。我不会为此定义函数，你会在不同的公司发现这种风格。是的，这是我的意见，这就是为什么我写了“我恨”我多次碰到这个模式，它总是使代码更难读，更难重用重复的部分。@ MarekR，因为你习惯了旧的代码，你绊倒了。人们开始学习C++，例如C++ 14或C++ 17，或者来自其他语言的人习惯于这种风格。在JavaScript中很常见。作为任何工具，它们可能是误用。我看到人们滥用lambda：他们一遍又一遍地重复相同的lambda，而它可能是一个函数（甚至是一个命名的（全局）lambda）。这里
丢失
似乎是不必要的，这使得这个构造在我看来很奇怪。甚至可以使用：
std:：tie（tresh，std:：ignore）=xyz（I）；
“但这正是你想要的”—更像“这就是你在这里要解决的问题”。甚至
auto[tresh，loss]=xyz（boolX？a:b）；
。
const auto do_job = [](auto&& p)
{
    auto [tresh, std::ignore] = p;
    std::cout << tresh << std::endl;
}
if (boolX) {
    do_job(xyz(i));
} else {
    do_job(xyz(j));
}