const_cast vs static_cast

Question

To add const to a non-const object, which is the prefered method? const_cast<T> or static_cast<T>. In a recent question, someone mentioned that they prefer to use static_cast, but I would have thought that const_cast would make the intention of the code more clear. So what is the argument for using static_cast to make a variable const?

Answer 1

Don't use either. Initialize a const reference that refers to the object:

T x;
const T& xref(x);

x.f();     // calls non-const overload
xref.f();  // calls const overload

Or, use an implicit_cast function template, like the one provided in Boost:

T x;

x.f();                           // calls non-const overload
implicit_cast<const T&>(x).f();  // calls const overload

Given the choice between static_cast and const_cast, static_cast is definitely preferable: const_cast should only be used to cast away constness because it is the only cast that can do so, and casting away constness is inherently dangerous. Modifying an object via a pointer or reference obtained by casting away constness may result in undefined behavior.

Answer 2

I'd say static_cast is preferable since it will only allow you to cast from non-const to const (which is safe), and not in the other direction (which is not necessarily safe).

Answer 3

This is a good use case for an implicit_cast function template.

Answer 4

You could write your own cast:

template<class T>
const T & MakeConst(const T & inValue)
{
    return inValue;
}