returning &const or *const? (c++)

Question

i have my own class "SomeObject" with a few members.

now, i have another class "WorkingClass" containg this object as privat member.

My Question is: i want to create a Getter for the "SomeObject", but i don't want anyone to modify it.

which way is better, 1 or 2?

class WorkingClass
{
private:
    SomeObject sObj;

public:
    //... 1)
    const SomeObject &const GetSomeObject()
    {
        return mousePosition;
    }

    //... 2)
    const SomeObject *const GetSomeObject()
    {
        return &mouseMovement;
    }
}

i know you can always cast away const, but still, i'm just trying to get my code clean and fail-safe

EDIT:

then i have a further question. when i have a smart-pointer member and use it a lot inside the class, and then suddenly want someone to have acces to read some values but nothing more, would this be a good solution or is that verbose again?

class X
{
private:
    boost::shared_ptr<SomeObject> sob

public:
    const const & GetSomeObject()
    {
        return *sob.get();
    }
}

and how about returning a "const boost::shared_ptr<...> GetX()" ? it may not be really neccessary, but still not useless, as the compiler would forbid GetX().reset(..) in such a case, and without the const boost::... declaration this useless operation would be permitted. or am i wrong?

Answer 1

Neither is good:

• const SomeObject &const is ill-formed. You cannot const-qualify a reference. (You can, of course, qualify the referent type.)

• const SomeObject *const is unnecessarily verbose. A function call expression o.GetSomeObject() is an rvalue expression and only class-type rvalues can be const-qualified. You may as well just say const SomeObject*. (const SomeObject *const can actually lead to issues with template instantiation, though such issues are rare.)

As for whether you choose to return by pointer or by reference, it depends on how you are using the return value. Both can make sense in different circumstances. Regardless, you want to return a reference or pointer to a const object, not a const reference or a const pointer:

const SomeObject& GetSomeObject() { ... }
const SomeObject* GetSomeObject() { ... }

Usually, returning a reference is preferable.

Answer 2

Writing & const is pointless. References are always constant. Omit the const keyword there.

Using a reference is better if you want to return a constant non-null object. If you want to return either an object or a null pointer then use a pointer instead.

See also When should I use references, and when should I use pointers?

Use references when you can, and pointers when you have to.

References are usually preferred over pointers whenever you don't need "reseating". This usually means that references are most useful in a class's public interface. References typically appear on the skin of an object, and pointers on the inside.

The exception to the above is where a function's parameter or return value needs a "sentinel" reference — a reference that does not refer to an object. This is usually best done by returning/taking a pointer, and giving the NULL pointer this special significance (references should always alias objects, not a dereferenced NULL pointer).