const_cast vs static_cast

Question

Pour ajouter const à un objet non-const, qui est la méthode preferred? const_cast<T> ou static_cast<T>. Dans une question récente, quelqu'un a dit qu'ils préfèrent utiliser static_cast, mais j'aurais pensé que const_cast ferait l'intention du code plus clair. Alors, quel est l'argument pour l'utilisation de static_cast pour faire une variable const?

Answer 1

Ne pas utiliser non plus. Initialiser une référence const qui fait référence à l'objet:

T x;
const T& xref(x);

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

Ou, utilisez un modèle de fonction implicit_cast, comme celui fourni dans Boost :

T x;

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

Étant donné le choix entre static_cast et const_cast, static_cast est certainement préférable: const_cast ne doit être utilisé pour rejettera constness parce qu'il est le casting seulement peut le faire, et jetant constness est intrinsèquement dangereux . Modification d'un objet par l'intermédiaire d'un pointeur ou référence obtenue par coulée à une distance constness peut entraîner un comportement non défini.

Answer 2

Je dirais que static_cast est préférable car il ne vous permettra de jeter de la non-const à const (ce qui est sûr), et non dans l'autre sens (ce qui est nécessairement sans danger).

Answer 3

Ceci est un bon cas d'utilisation pour un modèle de fonction implicit_cast .

Answer 4

Vous pouvez écrire votre propre casting:

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