CODEWITHSUNDEEP
c++functionpointersreturn
ProtectedVoid
ProtectedVoid

Reputation: 1315

C++ Functions returnings vs Functions setting a pointer

I would like to know the difference between functions that return a value and functions that set a value to a pointer, for example:

Pointer:

int myVal;
ptr_multiply(5, 5, &myVal);
cout << myVal << endl; //Output: 25

Return:

int myVal = rtn_multiply(5, 5);
cout << myVal << endl; //Output: 25

My question focuses in what method to choose when creating functions and why, as well as what advantages/disadvantages can we find in each of them.

Upvotes: 2

Views: 93

Answers (6)

Bernhard Heinrich
Bernhard Heinrich

Reputation: 120

Another difference is stack or heap.

A return-value lies on top of the stack. The pointer-variant lies in heap.

For instance (sensless recursive code to demonstrate return on stack):

typedef std::array<int,1000> KByte;
KByte tmp;

KByte f(int nr) {
    if (nr == 1) { tmp[nr]=nr; return tmp; }
    else { tmp[nr]=nr; return f(nr-1); };
}

void f2(int nr, KByte& ret) {
    if (nr == 1) { ret[1]=1; }
    else { ret[nr]=nr; f2( nr-1, ret ); }
};

Calling

KByte t = f(999); /* Stack error */

shoud give you an stack-size error, since 1000 KByte (1GB) on the stack is to much.

Calling 

KByte t2;
f2( 999, t2 );

should work without stack problem. (It also uses recursion depth 1000, but does not lie the return value on the stack.

Upvotes: 0

Daniel
Daniel

Reputation: 8441

Return the value. With modern compilers there should be almost no difference in performance between the two, but returning the value has several advantages:

  • By definition, it's what a function should do (i.e. a function maps from a domain to a codomain).
  • It's self-documenting; if I'm using an unfamiliar API, unless there is good documentation, it can get confusing what is input/output if values are returned in the parameter set. With a returned value there is no ambiguity, and requires less documenting.

  • It's easier to use - can half the number of lines needed! Compare

    int r = f();

    to 

    int r;
f(&r);

  • It could make you a better programmer; you have to put more effort into returning multiple values from a function (e.g. via a struct or pair, as opposed to adding another parameter). If you find you need to do this often, the additional effort may force you to think more carefully about your code design - it's usually better for a function to just do/return one thing.

Upvotes: 0

Dave Emberton
Dave Emberton

Reputation: 86

You can return a success/failure:

int v = -1;
if(ToInt("wibble",&v)){
  // do something with v
}

Would fail as "wibble" can't be converted to an int.

The other useful thing is that the function doesn't have to change v:

int v = previousValue;
UpdateIfNewValueFound( &v )

Upvotes: 0

user2209008
user2209008

Reputation:

One advantage to use the "pointer" method is that you can have multiple "return" values by passing in non-const references or pointers. For example:

int output1;
int output2;
get_values("input", &output1, &output2)

Upvotes: 0

mbed_dev
mbed_dev

Reputation: 1470

If you have big pieces of data to return, then you might come across to performance-bottlenceks. The reason is that that the returning value must be copied.

But in the most cases you don't have to worry about that, because modern compilers are capable of auto-inline things like that.

Side note: In C++ try to avoid naked pointers as much as possible (use references, smart-pointers)

Upvotes: 0

Luchian Grigore
Luchian Grigore

Reputation: 258618

Readability is the main reason functions typically return what you expect them to return. However, as this is highly subjective, I suggest you strive for consistency within your project.

When you want a function to return multiple things and not group them all together in a structure just so you can return them, an alternative is to return them in output parameters.

Upvotes: 1

Related Questions