Is it possible to take a parameter by const reference, while banning conversions so that temporaries aren't passed instead?

Question

Sometimes we like to take a large parameter by reference, and also to make the reference const if possible to advertize that it is an input parameter. But by making the refe

Answer 1

This is pretty simple to solve: stop taking values by reference. If you want to ensure that a parameter is addressable, then make it an address:

void bar_const(const long *) { }

That way, the user must pass a pointer. And you can't get a pointer to a temporary (unless the user is being terribly malicious).

That being said, I think your thinking on this matter is... wrongheaded. It comes down to this point.

perhaps I will take it's address, not realizing that I am, in effect, taking the address of a temporary.

Taking the address of a const& that happens to be a temporary is actually fine. The problem is that you cannot store it long-term. Nor can you transfer ownership of it. After all, you got a const reference.

And that's part of the problem. If you take a const&, your interface is saying, "I'm allowed to use this object, but I do not own it, nor can I give ownership to someone else." Since you do not own the object, you cannot store it long-term. This is what const& means.

Taking a const* instead can be problematic. Why? Because you don't know where that pointer came from. Who owns this pointer? const& has a number of syntactic safeguards to prevent you from doing bad things (so long as you don't take its address). const* has nothing; you can copy that pointer to your heart's content. Your interface says nothing about whether you are allowed to own the object or transfer ownership to others.

This ambiguity is why C++11 has smart pointers like unique_ptr and shared_ptr. These pointers can describe real memory ownership relations.

If your function takes a unique_ptr by value, then you now own that object. If it takes a shared_ptr, then you now share ownership of that object. There are syntactic guarantees in place that ensure ownership (again, unless you take unpleasant steps).

In the event of your not using C++11, you should use Boost smart pointers to achieve similar effects.