C++核心准则编译边学-F.21 如果需要返回多个输出值，最好返回结构体或者tuple

F.21: To return multiple "out" values, prefer returning a struct or tuple（如果需要返回多个输出值，最好返回结构体或者tuple）

Reason（原因）

A return value is self-documenting as an "output-only" value. Note that C++ does have multiple return values, by convention of using a tuple (including pair), possibly with the extra convenience of tie at the call site. Prefer using a named struct where there are semantics to the returned value. Otherwise, a nameless tuple is useful in generic code.

返回值本身就表明了自己是一个只用作输出的值。注意C++是可以同时返回多个值的，通常是使用tuple(包括pair)，调用者还可以利用tie获得额外的便利性。如果返回值有特定的含义时使用命名的结构体会更好。否则无名的tuple会更适合一般的代码。

译者注：tie是C++11导入的新特性，可以用于解构tuple元素。具体示例可以参照http://www.cplusplus.com/reference/tuple/tie/

Example（示例）

// BAD: output-only parameter documented in a comment
int f(const string& input, /*output only*/ string& output_data)
{
    // ...
    output_data = something();
    return status;
}

// GOOD: self-documenting
tuple<int, string> f(const string& input)
{
    // ...
    return make_tuple(status, something());
}

译者注：类似的返回多值的做法在其他语言（例如Python）中已经广泛使用。

C++98's standard library already used this style, because a pair is like a two-element tuple. For example, given a set<string> my_set, consider:

C++98的标准库中已经使用这种风格，因为pair就像2个元素的tuple。例如，假设有一个set<string> my_set，考虑下面的代码：

// C++98
result = my_set.insert("Hello");
if (result.second) do_something_with(result.first);    // workaround

With C++11 we can write this, putting the results directly in existing local variables:

使用C++11你可以这样写，直接将结果放入已经存在的局部变量。

Sometype iter;                                // default initialize if we haven't already
Someothertype success;                        // used these variables for some other purpose

tie(iter, success) = my_set.insert("Hello");   // normal return value
if (success) do_something_with(iter);

With C++17 we are able to use "structured bindings" to declare and initialize the multiple variables:

使用C++17，我们可以使用结构化绑定功能定义和初始化多个值：

if (auto [ iter, success ] = my_set.insert("Hello"); success) do_something_with(iter);

Exception（例外）

Sometimes, we need to pass an object to a function to manipulate its state. In such cases, passing the object by reference T& is usually the right technique. Explicitly passing an in-out parameter back out again as a return value is often not necessary. For example:

有时我们需要向函数传递一个对象以便控制这个对象的状态。在这种情况下，使用引用T&传递对象通常是正确的方式。一般不需要一方面明确地传递一个输入/输出参数，另一方面却通过返回值输出。例如：

istream& operator>>(istream& is, string& s);    // much like std::operator>>()

for (string s; cin >> s; ) {
    // do something with line
}

译者注：这里说的应该是s。is由于需要支持连续的>>,需要作为返回值返回。

Here, both s and cin are used as in-out parameters. We pass cin by (non-const) reference to be able to manipulate its state. We pass s to avoid repeated allocations. By reusing s (passed by reference), we allocate new memory only when we need to expand s's capacity. This technique is sometimes called the "caller-allocated out" pattern and is particularly useful for types, such as string and vector, that needs to do free store allocations.

这里s和cin都用作输入/输出参数。我们通过（非常量）引用传递cin以便控制它的状态。我们传递s以避免重复申请内存。通过重用s(通过引用传递)，我们只是在需要扩充s的容量时重新申请内存。这个技术有时被称为“用户申请的输出”模式，这种方式特别适用于类似string和vector那样的类型，它们需要释放申请到的存储空间。

To compare, if we passed out all values as return values, we would something like this:

作为比较，如果我们使用返回值传出所有值，差不多需要这样做：

pair<istream&, string> get_string(istream& is);  // not recommended
{
    string s;
    is >> s;
    return {is, s};
}

for (auto p = get_string(cin); p.first; ) {
    // do something with p.second
}

We consider that significantly less elegant with significantly less performance.

我们认为这种做法明显不够优雅，也不够高效。

For a truly strict reading of this rule (F.21), the exception isn't really an exception because it relies on in-out parameters, rather than the plain out parameters mentioned in the rule. However, we prefer to be explicit, rather than subtle.

如果真正严格地理解这条准则(F.21), 这个例外并不是真的例外，因为它依赖于输入/输出参数，而不是本准则提到的简单的输出参数。然而我们强调的是

明确而不是隐含地传递的情况。

Note（注意）

In many cases, it may be useful to return a specific, user-defined type. For example:

很多情况下，传递一个明确的，用户定义的类型可能是有用的。例如：

struct Distance {
    int value;
    int unit = 1;   // 1 means meters
};

Distance d1 = measure(obj1);        // access d1.value and d1.unit
auto d2 = measure(obj2);            // access d2.value and d2.unit
auto [value, unit] = measure(obj3); // access value and unit; somewhat redundant
                                    // to people who know measure()
auto [x, y] = measure(obj4);        // don't; it's likely to be confusing

译者注：代码中[x,y]的用法是C++17中引入的结构化绑定（structred binding）

The overly-generic pair and tuple should be used only when the value returned represents independent entities rather than an abstraction.

一般的pair和tuple应该只被用于返回值表现独立实体（数据之间没什么内在联系）的情况，而不是表现某种抽象。

Another example, use a specific type along the lines of variant<T, error_code>, rather than using the generic tuple.

另外一个例子，使用和variant<T, error_code>类似的特定类型，而不是使用一般的tuple。

译者注：variant是C++17引入的新特性。这个例子可以看做抽象之外的另一种包含明确意义的情况。

Enforcement（实施建议）

• Output parameters should be replaced by return values. An output parameter is one that the function writes to, invokes a non-const member function, or passes on as a non-const. 应该使用返回值代替输出参数。输出参数可以是函数写入动作的对象，调用一个非常量成员函数，或者作为一个非常量传递。