Why methods can not return multiple values

Question

Just curious is there any technical limitation in having multiple return values for methods in languages like java, c, c++ or limitation is just by spec? In assembly language I understand callee can pop one value to register.

Answer 1

1. Because in the days of C there is/was a single register used to hold the return value.
2. Because if you need more values, you can just return a struct, reference (in Java/C#), or pointer.
3. Because you can use an out parameter.

Allowing multiple return values would add complexity, and it's simply worked around. There's no reason for it to be there. (Indeed, in C++ you can return a tuple (from TR1, C++11, or boost) which effectively is multiple return values)

Answer 2

Its by design, because there is no need to allow multiple values in return statement. You can always define a struct with all the needed members, and create an instance of the struct and return it. Simple!

Example,

struct Person
{
   std::string Name;
   int Age;
   std::string Qualification;
   //...
};

Person GetInfo()
{
    Person person;
    //fill person's members ...
    return person;
}

You can use std::pair, std::vector, std::map, std::list and so on. In C++0x, you can use std::tuple as well.

Answer 3

If the Genie gave you only one wish, you could just wish to have any number of wishes. It's the same with just one return value from a method. You can use your return value as a pointer to an address where an object full of attributes resides and then query those attributes (properties)... This way there really is no limitation. :-)

Fun coding and many happy returns :-)

Answer 4

It's just a decision and because people are used to it. In principle there wouldn't be anything preventing a language designer from implementing a syntax like this:

(int, int, int) call(int x, int y, int z);

and a function call could look like this:

(a, b, c) = call(1, 2, 3);

or whatever syntax they would choose for this task. Though one could discuss if it would add to readability. And as others have pointed out, some languages implement this by tuples or similar constructs.

Sure, the return statement:

(int, int, int) call(int x, int y, int z);
{
  return x+1, y+1, z+1
}

You could even think of useful applications like:

(err, filehandle) = OpenFileDialog(...)

where the function can return either a detailed error code or a valid file handle. Though exceptions take this place nowadays. But exceptions are in some sense a way to return at least two alternating values, either the requested function return value or the raised exception.

Answer 5

Because good programming languages encourage programmers to do the right thing. If a method needs to return multiple values, those values probably are related, and thus should be group together in something like a struc.

Just my 2 cents.

Answer 6

It's mostly due to historical reasons having to do with machine calling conventions. Also because C doesn't have a pattern matching syntax on the callee side to retrieve the results. Note that languages like ML or Haskell have a syntactically lightweight tuple type that is perfectly usable for returning multiple values.

Edited:

Actually thinking about it a little bit, I guess if you wanted to split hairs, ML and Haskell still have a "single" return value. It's just that tuples are so lightweight syntactically that it's convenient to think about functions returning multiple values rather than a single tuple.

To be totally rigorous, there are two languages that I can think of that have "proper" multiple-values returns that are not just tuples in some shape. One is Scheme, (c.f call-with-values), and the other is MATLAB:

function [x,y] = myFunc(a, b)
   ...
end

[p, q] = myFunc(3,4)

In both of these languages, there is a special syntactic distinction between a single value that happens to be an aggregate (cons cell, array, respectively) and multiple values.

Answer 7

It's just a decision made by the language and/or ABI designers. No more, no less. In assembly language, you can make those decisions yourself, though - I'm not sure what your last comment means.

Answer 8

It is useful to support this, and given how people find it convenient in other languages, C and Java may move that way too.

C++ is already standardising on the kind of convenient, intuitive handling of return values familiar from e.g. Ruby and python for the function-caller side, which is more important than at the return itself, because a single function is likely called from a great many call sites.

Specifically, the C++17 paper here (see also wording here) documents a notation...

auto [x,y,z] = expression;

...where expression can be a function returning - or any other expression evaluating to - an array, a tuple, or a struct with all public members. The above can be preceded by const to make the local variables const.

The feature also documents this...

for (const auto& [key,value] : mymap)
    ...

...which avoids repeated use of the less-expressive ->first and ->second.

With C++ moving in this direction, it's likely C and other C-derived languages will look carefully at doing likewise.

Answer 9

We don't need the ability to return multiple values built into the C++ language, because the library works just fine:

std::tuple<int,float> func()
{
    return std::make_tuple(1, 2.f);
}

int i;
float f;

std::tie(i, f) = func();

Most other languages have similar functionality in their standard library.

Answer 10

Actually, there are at least 2 ways to return multiple values.

First is to return create a struct or class, put all the return data, and return it.

second is to pass parameters by reference (non-const) and put the values in there.