Const_cast est-il sûr?

Je ne trouve pas beaucoup d'informations sur const_cast. La seule information que j'ai pu trouver (sur Stack Overflow) est:

Le const_cast<>()est utilisé pour ajouter / supprimer const (ness) (ou volatile-ness) d'une variable.

Cela me rend nerveux. L'utilisation d'un const_castcomportement pourrait-elle provoquer un comportement inattendu? Si oui, quoi?

Sinon, quand est-il possible de l'utiliser const_cast?

const_castest sûr uniquement si vous lancez une variable qui n'était pas à l'origine const. Par exemple, si vous avez une fonction qui prend un paramètre d'unconst char * et que vous transmettez un modifiable char *, vous pouvez const_castretourner ce paramètre en toute sécurité à a char *et le modifier. Cependant, si la variable d'origine était en fait const, alors l'utilisation const_castentraînera un comportement indéfini.

void func(const char *param, size_t sz, bool modify)
{
    if(modify)
        strncpy(const_cast<char *>(param), sz, "new string");
    printf("param: %s\n", param);
}

...

char buffer[16];
const char *unmodifiable = "string constant";
func(buffer, sizeof(buffer), true);  // OK
func(unmodifiable, strlen(unmodifiable), false); // OK
func(unmodifiable, strlen(unmodifiable), true);  // UNDEFINED BEHAVIOR

Je peux penser à deux situations où const_cast est sûr et utile (il peut y avoir d'autres cas valides).

La première est lorsque vous avez une instance, une référence ou un pointeur const, et que vous souhaitez passer un pointeur ou une référence à une API qui n'est pas constante, mais que vous êtes CERTAIN que vous ne modifiez pas l'objet. Vous pouvez const_cast le pointeur et le transmettre à l'API, en sachant que cela ne changera vraiment rien. Par exemple:

void log(char* text);   // Won't change text -- just const-incorrect

void my_func(const std::string& message)
{
    log(const_cast<char*>(&message.c_str()));
}

L'autre est si vous utilisez un compilateur plus ancien qui n'implémente pas «mutable» et que vous souhaitez créer une classe qui est logiquement const mais pas au niveau du bit. Vous pouvez const_cast 'this' dans une méthode const et modifier les membres de votre classe.

class MyClass
{
    char cached_data[10000]; // should be mutable
    bool cache_dirty;        // should also be mutable

  public:

    char getData(int index) const
    {
        if (cache_dirty)
        {
          MyClass* thisptr = const_cast<MyClass*>(this);
          update_cache(thisptr->cached_data);
        }
        return cached_data[index];
    }
};

J'ai du mal à croire que ce soit la seule information que vous puissiez trouver sur const_cast. Citant le deuxième hit de Google :

Si vous rejetez la constness d'un objet qui a été explicitement déclaré comme const et que vous essayez de le modifier, les résultats ne sont pas définis.

Cependant, si vous rejetez la constness d'un objet qui n'a pas été explicitement déclaré comme const, vous pouvez le modifier en toute sécurité.

Ce que dit Adam. Un autre exemple où const_cast peut être utile:

struct sample {
    T& getT() { 
        return const_cast<T&>(static_cast<const sample*>(this)->getT()); 
    }

    const T& getT() const { 
       /* possibly much code here */
       return t; 
    }

    T t;
};

Nous ajoutons d'abord const au type thissur getTlequel pointe, puis nous appelons la version const de , puis nous supprimons const du type de retour, qui est valide car tdoit être non-const (sinon, la version non-const de getTne pourrait pas avoir été appelé). Cela peut être très utile si vous avez un corps de fonction volumineux et que vous souhaitez éviter le code redondant.

La réponse courte est non, ce n'est pas sûr.

La réponse longue est que si vous en savez assez pour l'utiliser, alors il devrait être sûr.

Lorsque vous lancez un casting, vous dites essentiellement: "Je sais quelque chose que le compilateur ne sait pas." Dans le cas de const_cast, ce que vous dites est: "Même si cette méthode prend une référence ou un pointeur non-const, je sais que cela ne changera pas le paramètre que je lui passe."

Donc, si vous savez vraiment ce que vous prétendez savoir en utilisant le casting, alors vous pouvez l'utiliser.

Vous détruisez toute chance de sécurité des threads, si vous commencez à modifier des choses que le compilateur pensait const.

#include <iostream>
using namespace std;

void f(int* p) {
  cout << *p << endl;
}

int main(void) {
  const int a = 10;
  const int* b = &a;

  // Function f() expects int*, not const int*
  //   f(b);
  int* c = const_cast<int*>(b);
  f(c);

  // Lvalue is const
  //  *b = 20;

  // Undefined behavior
  //  *c = 30;

  int a1 = 40;
  const int* b1 = &a1;
  int* c1 = const_cast<int*>(b1);

  // Integer a1, the object referred to by c1, has
  // not been declared const
  *c1 = 50;

  return 0;
}

source: http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Fkeyword_const_cast.htm