Re: Multiple return values (was Re: Const Considerations)
Yechezkel Mett wrote:
James Kanze wrote:
Mulitple return values would change a lot if we also had
multiple assigns, like some languages. But we don't, and I
can't quite see how to make them fit into the C++ grammar.
It occurred to me recently that auto variables and the
proposed extension to initializer lists (both expected to be
in the next standard) could provide most of what is necessary
for multiple return values. Consider (not currently legal):
template<class FwdIt, class Ty>
struct {
FwdIt lower_bound;
FwdIt upper_bound;
} equal_range(
FwdIt first,
FwdIt last,
const Ty& val)
{
FwdIt lower;
FwdIt upper;
... calculate lower and upper ...
return { lower, upper };
}
int main()
{
std::vector<int> v;
... fill v with ordered values ...
auto equal = equal_range(v.begin(), v.end(), 5)
std::cout << "lower = " << equal.lower_bound
<< ", upper = " << equal.upper_bound << std::endl;
}
What's the difference between this and the current return type
for equal_range (std::pair< Iter, Iter >)?
The return statement will be legal in the next standard. So will the
assignment in main.
Something along those lines will probably be legal. I don't
think the exact syntax has been finalized in either case. (And
of course, there is no assignment in main---the auto only works
in declarations with initialization.)
Note that this is NOT multiple return values. To emulate
multiple return values in C++, you'd need some sort of tuple of
references, and write something like:
int a;
double b ;
tuple_ref( a, b ) = f( x ) ;
where f returns a tuple (initialized with whatever syntax), and
tuple_ref is a function (to get type induction) which returns an
object with references of the correct type to a and b, and whose
assignment operator takes a tuple and assigns the values it
contains to the references variables.
Given such a framework, swap could be written:
tuple_ref( a, b ) = tuple( b, a ) ;
In a language which supports multiple returns and assignments,
of course, you don't need the tuple nor the tuple_ref; you could
just write:
a, b := b, a ;
(I use := to stress that this is NOT C++. "a, b = b, a" is a
legal C++ expression today, but it doesn't do what is wanted
here.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]