const_cast vs static_cast

Question

To add const to a non-const object, which is the prefered method? const_cast or static_cast. In a recent question, s

Answer 1

You could write your own cast:

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

Answer 2

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

Answer 3

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 4

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).