Thread: Functions which return a reference

I can't seem to get my head around functions which return a reference, what is it a reference to? It seems they are commonly used when writing operators. Here's a couple of examples I've found.

The first is the assignment operator from Steve Heller's string class

Code:

string& string::operator = (const string& Str)
{
char* temp = new char[Str.m_Length];

m_Length = Str.m_Length;
memcpy(temp,Str.m_Data,m_Length);
delete [ ] m_Data;

m_Data = temp;

return *this;
}

The second is taken from this well known pointer tutorial

Code:

class array {
 4   int base[5];
 5 public:
 6   int& operator[] ( int i )
 7   {
 8     return base[i];
 9   }
10 };

In both cases I just can't see why we need to return a reference, or even what it's a reference to.

Regards,

Stonehambey

Thanks for the reply.

I'm still unsure how the program would fail to work properly if the assignment operator function returned string instead of string&. Say it returned just string, then in the example

s = s2 = s3 = "blah"

the first assignment would return a string, then the second assignment would be invoked, which has a reference in the argument. Doesn't that tell the compiler that we want to use a reference of the string class? I might not be sounding clear, maybe this will help, say I have a function

Code:

void f( int& ) 
{
    //do something with the int
}

Now this function can be called like this

Code:

int i = 1;

f(i);

But we don't need to specifically pass a reference to the function, we can just pass i, because the function has a reference in the argument then it knows that's what we want.

So we don't need to do something like this

Code:

int i = 1;
int& j = i;    //make reference of i

f(j);   //specifically pass that reference as the argument.

So to sum up, even if the string operator returned a string, then if we wanted to invoke the assignment operator again using the returned string, I don't see how it would matter since the argument for the operator knows we want to use it as a reference anyway.

I have no doubt that I am missing something, as here's another quote from the article

By returning a reference, two nifty tricks are allowed. First, you can return a reference and chain calls of a function together as long as they take that reference as an argument:

I just can't see what I'm missing

Hey thanks for that, I think I'm beginning to understand it a bit now, but still a little shaky. Here's what the program shows.

Default ctor called.
Default ctor called.
Default ctor called.
Copy assingment operator called.
Copy assingment operator called.
Dtor called.
Dtor called.
Dtor called.

I get this fine. You create 3 instances of the class, invoking the default constructor. You then perform two assingments, and finally the default constructor is called for each of them.

So I change the program as you suggest and I see this


Default ctor called.
Default ctor called.
Default ctor called.
Copy assingment operator called.
Copy ctor called.
Copy assingment operator called.
Copy ctor called.
Dtor called.
Dtor called.
Dtor called.
Dtor called.
Dtor called.

So now after the copy assignment operators are called we are also somehow invoking the copy constructor as well.

So could it be that when if we return simply X in our assignment operator, then we are creating a new instance of the class created by the function (sounds reasonable)? And so we need a constructor, since the arguments for operator= and the copy constructor are the same, it induces the copy constructor?

Also, what does the reference returned actually reference? We return *this, which by definition is a dereferenced pointer to this instance of the class. So by declaring the function returns a reference are we saying "return a reference to this".

Sorry if I'm confusing everyone, maybe I'm having a slow day today or something, for some reason this isn't quite clicking for me yet

Originally Posted by laserlight

I am not sure what you mean, but the act of returning by value invokes the copy constructor, at least if return value optimisation is not applied.

I just mean that in order to make this new object, the program needs to use a constructor. So presumably it goes through its list of constructors and picks the right one. I'm wondering why it picks the copy constructor. My initial reasoning was that it shares the same arguments as the copy assignment operator.

It refers to the current object itself.

Ok cool, so would the following function return a reference to a?

Code:

int& f(int a)
{
    return a;
}

I think it's slowly starting to fall into place now, thanks for your patience.

With regards to your last comment. What difference would this make? Comments are just me thinking out loud

Code:

int& f(int& x) //pass a reference to an integer x as the argument. 
{
    return x; //function now deals with x rather than a copy of x (so exists outside
                   //of the function scope), so it's ok to return it as a 
                   // reference?
}

Are there any general rules for when one should return a reference?

That looks like a pretty cool FAQ, and thanks for the help