Section 24.5: Using a Function Object Consumer

Section 24.6: Using std::pair

The struct template std::pair can bundle together exactly two return values, of any two types:

#include <utility>

std::pair<int, int> foo(int a, int b) { return std::make_pair(a+b, a-b);

}

With C++11 or later, an initializer list can be used instead of std::make_pair:

Version ≥ C++11

#include <utility>

std::pair<int, int> foo(int a, int b) { return {a+b, a-b};

}

The individual values of the returned std::pair can be retrieved by using the pair's first and second member objects:

std::pair<int, int> mrvs = foo(5, 12);

std::cout << mrvs.first + mrvs.second << std::endl;

Output:

10

Section 24.7: Using std::array

Version ≥ C++11

The container std::array can bundle together a fixed number of return values. This number has to be known at compile-time and all return values have to be of the same type:

std::array<int, 4> bar(int a, int b) { return { a + b, a - b, a * b, a / b };

}

This replaces c style arrays of the form int bar[4]. The advantage being that various c++ std functions can now be used on it. It also provides useful member functions like at which is a safe member access function with bound checking, and size which allows you to return the size of the array without calculation.

Section 24.8: Using Output Iterator

Several values of the same type can be returned by passing an output iterator to the function. This is particularly common for generic functions (like the algorithms of the standard library).

Example:

template<typename Incrementable, typename OutputIterator>

void generate_sequence(Incrementable from, Incrementable to, OutputIterator output) { for (Incrementable k = from; k != to; ++k)

*output++ = k;

}

Example usage:

std::vector<int> digits;

generate_sequence(0, 10, std::back_inserter(digits)); // digits now contains {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

Section 24.9: Using std::vector

A std::vector can be useful for returning a dynamic number of variables of the same type. The following example uses int as data type, but a std::vector can hold any type that is trivially copyable:

#include <vector> #include <iostream>

//the following function returns all integers between and including 'a' and 'b' in a vector

//(the function can return up to std::vector::max_size elements with the vector, given that

//the system's main memory can hold that many items)

std::vector<int> fillVectorFrom(int a, int b) { std::vector<int> temp;

for (int i = a; i <= b; i++) { temp.push_back(i);

}

return temp;

}

int main() {

//assigns the filled vector created inside the function to the new vector 'v' std::vector<int> v = fillVectorFrom(1, 10);

//prints "1 2 3 4 5 6 7 8 9 10 "

for (int i = 0; i < v.size(); i++) { std::cout << v[i] << " ";

}

std::cout << std::endl; return 0;

}