How do you return by reference in C plus plus?

Answer 1

Returning by reference implies that the reference will not fall from scope when the function returns (because references must never be NULL). Thus you cannot return a reference to a variable that was declared local to the function.

int& foo()

{

int local;

return(( int & ) local); // Error: cannot return a reference to a local variable.

}

However, you can return a reference to a parameter that was itself passed by reference, since that reference is guaranteed to exist (it can't be NULL).

const int& GetMax( const int& byRef1, const int& byRef2 )

{

return( byRef1 > byRef2 ? byRef1 : byRef2 ); // this is fine.

}

Generally, the only time you will return by reference is when returning a class instance member or a reference to the class instance itself, since they always remain in scope after the function call.

class bar

{

public:

bar():m_num(0){}

const int& GetIntRef()const{return((const int&)m_num);} // constant reference to instance member.

int& GetIntRef(){return((int&)m_num);} // non-constant reference to instance member.

const bar& AsRef()const( return((const bar& )*this );} // constant reference to this instance.

bar& AsRef()( return((bar&)*this );} // non-constant reference to this instance.

private:

int m_num;

};

Note that use of const is not obligatory when returning references. However, when values must not be changed, it's good policy to enlist the help of the compiler wherever possible. The previous example returns both constant and non-constant references. The function that makes a call to GetIntRef() or AsRef() will determine whether the returned reference should be constant or not. By implementing both methods, we cater for both scenarios.

Answer 2

A reference is an alias for a variable. Unlike a pointer variable, which must occupy memory in order to store the memory address of the object it points to, a reference consumes no memory other than that used by the object it references.

An array name is a typical example of a reference. It is an alias to the memory allocated to the array.

Answer 3

No. Automatic and local function variables are allocated on the heap and will fall from scope when a function returns. You cannot refer to an out of scope variable. To get around this, allocate new memory to a local pointer variable on the free store and return the pointer by value (which returns a copy of the memory address of the allocation). The only problem with this is that the calling function is then responsible for assigning the returned pointer and freeing the allocation when it is no longer required.

Another option is to declare the local function variable static, thus it won't fall from scope when the function returns. However, if the function is called more than once you will then end up with multiple references to the same memory, which may be altered by the last call to the function.

The safest way to return by reference is to pass a reference to the function (the return reference needn't be the address of the reference that was passed, but must be a reference within the referred allocation). If the function is a class member, returning a reference to another member of the same class is also acceptable, so long as the class instance remains in scope for the lifetime of the returned reference.