Function in C++ returns by value or by reference?

When a function (callee) returns a quantity to the caller function, is it returned by value or by reference?

The thing is I have written a function which builds a very large vector of when called. I want to return this big vector to the calling function , ( in this case main() ) by constant reference so I can do some further processing on it.

I was in doubt because I was told that when a C++ function returns and terminates, all the variables/memory associated with that function, get wiped clean.

struct node{

string key;
int pnum;
node* ptr;
}

vector< vector<node> > myfun1(/*Some arguments*/)
{

/*Build the vector of vectors. Call it V*/

return开发者_开发问答 v;

}

int main(void)
{
a=myfun1(/* Some arguments */)
}

C++ functions can return by value, by reference (but don't return a local variable by reference), or by pointer (again, don't return a local by pointer).

When returning by value, the compiler can often do optimizations that make it equally as fast as returning by reference, without the problem of dangling references. These optimizations are commonly called "Return Value Optimization (RVO)" and/or "Named Return Value Optimization (NRVO)".

Another way to for the caller to provide an empty vector (by reference), and have the function fill it in. Then it doesn't need to return anything.

You definitely should read this blog posting: Want Speed? Pass by value.

By default, everything in C/C++ is passed by value, including return type, as in the example below:

T foo() ;

In C++, where the types are usually considered value-types (i.e. they behave like int or double types), the extra copy can be costly if the object's construction/destruction is not trivial.

With C++03

If you want to return by reference, or by pointer, you need to change the return type to either:

T & foo() ;  // return a reference
T * foo() ;  // return a pointer

but in both cases, you need to make sure the object returned still exists after the return. For example, if the object returned was allocated on stack in the body of the function, the object will be destroyed, and thus, its reference/pointer will be invalid.

If you can't guarantee the object still exists after the return, your only solution is to either:

1. accept the cost of an extra copy, and hope for a Return Value Optimization
2. pass instead a variable by reference as a parameter to the function, as in the following:

void foo(T & t) ;

This way, inside the function, you set the t value as necessary, and after the function returns, you have your result.

With C++11

Now, if you have the chance to work with C++0x/C++11, that is, with a compiler that supports r-values references/move semantics, if your object has the right constructor/operator (if your object comes from the standard library, then it's ok), then the extra temporary copy will be optimized away, and you can keep the notation:

T foo() ;

Knowing that the compiler will not generate an unnecessary temporary value.

C++ can return either by reference or by value. If you want to return a reference, you must specify that as part of the return type:

std::vector<int> my_func(); // returns value
std::vector<int>& my_func(); // returns reference
std::vector<int> const& my_func(); // returns constant reference

All local (stack) variables created inside of a function are destroyed when the function returns. That means you should absolutely not return locals by reference or const reference (or pointers to them). If you return the vector by value it may be copied before the local is destroyed, which could be costly. (Certain types of optimizations called "return value optimization" can sometimes remove the copy, but that's out of the scope of this question. It's not always easy to tell whether the optimization will happen on a particular piece of code.)

If you want to "create" a large vector inside of a function and then return it without copying, the easiest way is to pass the vector in to the function as a reference parameter:

void fill_vector(std::vector<int> &vec) {
    // fill "vec" and don't return anything...
}

Also note that in the recently ratified new version of the C++ standard (known as C++0x or C++11) returning a local vector by value from a function will not actually copy the vector, it will be efficiently moved into its new location. The code that does this looks identical to code from previous versions of C++ which could be forced to copy the vector. Check with your compiler to see whether it supports "move semantics" (the portion of the C++11 standard that makes this possible).

It's returned by whatever you declare the return type to be. vector<int> f(); and vector<int>& f(); return by value and reference respectively. However, it would be a grave error to return a reference to a local variable in the function as it will have been blown away when the function scope exits.

For good tips on how to efficiently return large vectors from a function, see this question (in fact this one is arguably a duplicate of that).

The function will return what you tell it to return. If you want to return a vector, then it will be copied to the variable hold by the caller. Unless you capture that result by const reference, in which case there is no need to copy it. There are optimizations that allow functions to avoid this extra copy-constructon by placing the result in the object that will hold the return value. You should read this before changing your design for performance:

http://cpp-next.com/archive/2009/08/want-speed-pass-by-value/

Like most things in C++, the answer is "it depends on how you defined the function".

The default for the language is return-by-value. A simple call like "double f()" is going to always return the floating-point number by value. However, you CAN return values by pointer or by reference- you just add the extra symbols '&' or '*' to the return type:

// Return by pointer (*)
T* f();

// Return by reference (a single '&')
T& f();

However, these are ridiculously unsafe in many situations. If the value the function is returning was declared within the function, the returned reference or pointer will point to random garbage instead of valid data. Even if you can guarantee that the pointed-to data is still around, this kind of return is usually more trouble than it is worth given the optimizations all modern C++ compilers will do for you. The idiomatic, safe way to return something by reference is to pass a named reference in as a parameter:

// Return by 'parameter' (a logical reference return)
void f(T& output);

Now the output has a real name, and we KNOW it will survive the call because it has to exist before the call to 'f' is even made. This is a pattern you will see often in C++, especially for things like populating a STL std::vector. Its ugly, but until the advent of C++11 it was often faster than simply returning the vector by value. Now that return by value is both simpler and faster even for many complex types, you will probably not see many functions following the reference return parameter pattern outside of older libraries.

All variables defined on the stack are cleaned upon exit. To return a variable you should allocate it on the heap, which you do with the new keyword (or malloc).

Classes and structs are passed around as pointers, while the primitive types are passed around as values.