Prevent copying when initializing an non-const object from a const reference

Question

I am a little confused right now regarding C++ reference semantics. Suppose I have a class that returns a const reference:

class foo
{
private:
    std::map<int, int> stuff;
public:
    const std::map<int, int>& getStuff()
    {
        return stuff;
    }
};

And I use it as follows:

foo f;
const std::map<int, int>& s = f.getStuff();

which is fine, but if I were to use it as follows:

foo f;
std::map<int, int> s = f.getStuff();

What happens exactly?

If I understand correctly, a const reference to stuff was returned and a copy created into s on which I can wreak havoc. Would there be any way to avoid this?

edit:

So there is no way to avoid the copy constructor being called here, for std::map anyways...

Answer 1

Short answer: no, you can't prevent it. The client can't modify the original, but if you give the client read-access to the map, then the client is responsible for not doing stupid things with the information; the class can't possibly prevent that.

Longer answer: maybe, but not really. If you really want to make copying difficult, you can wrap the map in a class with private copy constructor and assignment operator. That way the s assignment will be illegal (rejected by the compiler). The client will still be able to read the elements of the map piecemeal and populate a new map with them -- a manual copy -- but the only way to prevent that is to restrict the read-access in the wrapper class, which kind of defeats the purpose of getStuff.

Answer 2

std::map<int, int> s = f.getStuff();

This invokes the std::map<int, int> copy constructor and makes a copy of the object. The contents of the stuff map are copied into the new map s.

You can't wreak havoc with the original object because s is a new object completely unrelated to the original object, aside from the fact that the original object and the new object have the same contents.

It is impossible to legitimately wreak havoc with the stuff map via the const reference returned by foo::getStuff(). The only way you could modify the map would be through a const_cast, and modifying an object via a pointer or reference obtained through a const_cast may yield undefined behavior.