Returning an object confusion

Question

I've been learning C++ but I'm having trouble understanding the way objects are returned by a member function/method. I'm following the 'Teach yourself C++ in 21 days' book.

So, I understand classes and objects, just not much about returning an object. I'll provide an example (currently learning operator overloading).

const Counter& Counter::operator++()
{
    ++itsVal;
    return *this;
}

I'm just really confused about the return type. This method says it should return a reference to a counter object, but when the object is dereferenced with

return *this;

Aren't we just returning an object of the class Counter? Why does the function header say we're returning a reference to a counter object? Why doesn't the method header just say that the return type is an object of type Counter? This is where I get confused :\

The way I'm thinking about it is that since a reference is basically an alias to something, returning a dereferenced pointer would be like returning the objects alias as objects have names which help us identify them. I dont really know, I hope someone here can explain this to me.

Answer 1

Aren't we just returning an object of the class Counter?

Yes, we're returning an object. But, it's returned by reference, or by value, is determined by the return type in function declaration, we can't determine (or distinguish) them in return statement.

const Counter& Counter::operator++() // return by reference (to const)
{
    ++itsVal;
    return *this;
}

Counter Counter::operator++()        // return by value. Note the body of function is the same.
{
    ++itsVal;
    return *this;
}

BTW: Returning by reference to const (and by value, the above sample is just used for illustration) for prefix operator++ doesn't make sense. It should return reference to non-const actually. Such as

Counter& Counter::operator++() // return by reference (to non-const)
{
    ++itsVal;
    return *this;
}

Answer 2

The way I'm thinking about it is that since a reference is basically an alias to something, returning a dereferenced pointer would be like returning the objects alias

Yes, that is exactly right. The function returns an alias to the object the function was called on. It does not make a copy of that object to return.

The calling code might look like:

Counter c;
do_something( ++c + 5 );

Since ++c returned an alias to c, this code will behave like:

++c;
do_something( c + 5 );

without making any unnecessary copies of c.

Answer 3

return *this;

Aren't we just returning an object of the class Counter?

No, this returns a reference to the object.

The * operator is the dereference operator. The result of this operator is a reference to the object the pointer is pointing to. this is a pointer.

The thing about references is that when used in a non-reference context, they automatically end up getting "converted" to the referenced object.

T *t;

// ...

T u = *t;

The result of the * operator is, as I said, a reference. Then, the result is used in a non-reference context, namely assignment to another object that, itself, is not a reference. This ends up resolving to the referenced object, resulting in a copy.

Introductory C++ primers will often state that '*p' resolves to the object the pointer is pointing to. This is just a small white lie. This is true only in a non-reference context. This leaves the intermediate step of resolving to a reference, and then resolving the reference to the referenced object.

At this point, in a typical introductory C++ primer references have not yet been brought up as a topic. So this intermediate step is left out in order to avoid confusion. But now that you know something about references, you need to do some mental gear realignment:

* gives you a reference to the object the pointer is pointing to. When used in a reference context: that is, assigning the result to a reference, passing the result as a parameter to a function that's a reference, or returning a reference from a function, you get that reference. In all other, non-reference contexts, you will end up getting the object the reference is referring to, which will typically involve making a copy of the object.

Answer 4

The method returns the class object itself after the object being modified with itsVal plus 1.

You can use counter_object++ to self-Increment, then call some function else. Such as (counter_object++).func(), without creating another object.