Function returning two values in C & C++

Literally speaking no.
But nothing prohibits a value to be "composite" and have more values in it.
Not to mention the fact that parameters can be reference, and the referred objects may be used as return values.

It is always possible to return struct or pointer to struct from function. In C++ you can also return pair<first_type, second_type> ;)

Technically a function can only return one value. So if you ever get asked if it's possible tell the interviewer that you can only ever return one value but that value could be a composite type.

If it's C++ then std::pair is quick solution. Unfortunately pair's members are imaginatively named first and second so you keep having to remember what they mean. For this reason it can be an idea to declare your own composite type to return with better names.

Cheers,

Ash

PS: As this question has returned to the top of the pile I thought I'd add this...

When you return a structure (the composite type I alluded to above) EVERYTHING in the structure is copied. And I mean EVERYTHING. And that happens in C and C++ (if you don't have a copy constructor). So you can write things like this (in C, don't try it in C++, it's not the done thing):

#include <stdio.h>

struct message
{
    char text[128];
};

/* Not a creative name, sorry! */

struct message return_a_message()
{
    struct message msg = { "Oo, what's this then?" };
    return msg;
}

int main()
{
    struct message msg = return_a_message();
    printf( "%s", msg.text );

    return 0;
}

My usual caveat applies here - I'm not in practise with C so someone that knows what they're talking about may be able to pick great holes in it. It might be poisoned by Microsoftisms as well.

Interestingly the VC++2010 compiler doesn't create a temporary to return the object, so it looks like C++ style NRVO is kicking in here. Cool!

PPS: I first saw this technique in "Expert C Programming" by Peter van der Linden sometime in the late 90s. If you're a C programmer go and buy a copy. Oh and ignore the C++ chapter it's well out of date and not particularly knowledgeably written (although amusing and thought provoking in places). Ah, screw it, read that chapter as well.

How about this

int AddOne(int toThis)
{
  return toThis + 1;
}

...
int Value = 1;
Value = AddOne(Value); //Here it returns 2
Value = AddOne(Value); //Here it returns 3

The same function returned 2 different values. Hey, the question didn't say "at once", now did it? :)

But seriously, doesn't this kind of depends on the definition of 'value', if you e.g. have a function that returns a 4 byte integer, you could also say it returns 2x2 bytes values (e.g. 2 shorts) or 4x1 byte values (e.g. chars) packed into one integer. How about it?

No. And if you don't know something as basic as this, you have no business attending interviews.

Functions you write can return a maximumof a single value to their caller (you may write function that return no value when you use void ).

But if you wanna have a multiple values after calling the function you may use :

- structure or class as a return type ( a compmlex type holding more than one varialble).

- passing parameters by reference so the chnages will be kept even after function call.

No, literally a function return only one value.

Literally speaking of return where you use return keyword- NO.
But on common paradigms, yes - by pass by address.

In C#, its supported without the use of pointers. But still follows the concept of pass by address. Try to see, if not mistaken its with the use of out keyword

Sample code in c/c++:

int return2Values(float * fVal, int input)<br />
{<br />
    // 2nd parameter is optional<br />
    // do something with fVal; basically, it changes the value it points<br />
    return /*some int value*/<br />
}

Some functions
can also return two logical values by one physical value :-D :

_AFXWIN_INLINE HWND CWnd::GetSafeHwnd() const
{
  return this == NULL ? NULL : m_hWnd;
}

void TestWnd(CWnd* pcWnd)
{
  // Please note: no additional check of the pointer is needed
  if (pcWnd->GetSafeHwnd()) {
    // the window was created(2) at an allocated(1) pointer :)
    pcWnd->SetWindowText(_T("Checked"));
  }
}

Hi ,

you can make a function which will return one value and pass one parameter to it by reference and in function assign value to it.

Ex...

CString FunctionName(CString &strOut,int param1 , int param2 )
{
CString tempStr ;//Value to be assigned to ref parameter
CString strReturn;

..
.....
.......
//regular code

//at end

strout = tempStr;
return strReturn;

}

I can not understand why all the correct answers have been downvoted. The best answer to this question would be to read a manual, because people with basic knowledge of C++ this language would never post such questions. And even worse knowledge have those who downvoted all the correct answers.

I can not understand why all the correct answers have been downvoted. The best answer to this stupid question would be to read a manual, because people with basic knowledge of C++ this language would never post such questions. And even worse knowledge have those who downvoted all the correct answers.

A recursive function code can also
return a value for several times
by one call from outside...

...since there is no term "call" (but "function")
in your interview question... :-D

int main()
{
    //int a1[]={2,3,4};
    int *a=<pre lang="cs">oneOrMoreReturn();
    std::cout&lt;&lt;*(a+1)&lt;&lt;std::endl;
    std::cout&lt;&lt;*(a+0)&lt;&lt;std::endl;
    std::cout&lt;&lt;*(a+2)&lt;&lt;std::endl;
    int b;
    cin&gt;&gt;b;
}
int * oneOrMoreReturn()
{

    int a1[]={2,3,4};
    return a1;

 }</pre>

like this:
void func(type1* ret1, type2* ret2)
{
...
*ret1 = x;
*ret2 = y;
...
}

use function like this:
type1 var1;
type2 var2;

func(&var1, &var2)

Use pointers as input parameters