Czy const_cast jest bezpieczne?

Nie mogę znaleźć zbyt wielu informacji const_cast. Jedyne informacje, które udało mi się znaleźć (na temat przepełnienia stosu) to:

const_cast<>()Jest stosowany do dodawania / usuwania const (Ness) (lub lotny-ności) o zmiennej.

To mnie denerwuje. Czy użycie jakiegoś const_castpowodu może spowodować nieoczekiwane zachowanie? Jeśli tak to co?

Ewentualnie, kiedy można go używać const_cast?

const_castjest bezpieczny tylko wtedy, gdy rzutujesz zmienną, która pierwotnie była inna niż const. Na przykład, jeśli masz funkcję, która przyjmuje parametr a const char *i przekazujesz modyfikowalną wartość char *, możesz bezpiecznie const_castprzywrócić ten parametr z powrotem do a char *i zmodyfikować go. Jeśli jednak oryginalna zmienna była w rzeczywistości const, użycie const_castspowoduje niezdefiniowane zachowanie.

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

Przychodzą mi do głowy dwie sytuacje, w których const_cast jest bezpieczne i przydatne (mogą istnieć inne ważne przypadki).

Jeden z nich to sytuacja, w której masz instancję stałej, odwołanie lub wskaźnik i chcesz przekazać wskaźnik lub odwołanie do interfejsu API, który nie jest zgodny ze stałą stałą, ale jesteś PEWNY, że nie zmodyfikujesz obiektu. Możesz const_cast wskaźnik i przekazać go do API, ufając, że tak naprawdę niczego nie zmieni. Na przykład:

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()));
}

Druga to sytuacja, gdy używasz starszego kompilatora, który nie implementuje opcji „mutable” i chcesz utworzyć klasę, która jest logicznie stała, ale nie bitowa. Możesz const_cast „this” w ramach metody const i modyfikować członków swojej klasy.

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];
    }
};

Trudno mi uwierzyć, że to jedyna informacja, jaką można znaleźć o const_cast. Cytując z drugiego hitu Google :

Jeśli odrzucisz stałość obiektu, który został jawnie zadeklarowany jako stała, i spróbujesz go zmodyfikować, wyniki będą niezdefiniowane.

Jeśli jednak odrzucisz stałość obiektu, który nie został jawnie zadeklarowany jako const, możesz go bezpiecznie zmodyfikować.

Co mówi Adam. Inny przykład, w którym const_cast może być pomocne:

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;
};

Najpierw dodajemy const do typu, na który thiswskazuje typ , następnie wywołujemy wersję const getT, a następnie usuwamy const z typu zwracanego, który jest prawidłowy, ponieważ tmusi być inny niż const (w przeciwnym razie wersja non-const getTnie mogłaby został wezwany). Może to być bardzo przydatne, jeśli masz dużą treść funkcji i chcesz uniknąć nadmiarowego kodu.

Krótka odpowiedź brzmi: nie, to nie jest bezpieczne.

Długa odpowiedź jest taka, że ​​jeśli wiesz wystarczająco dużo, aby go używać, powinno być bezpieczne.

Podczas przesyłania zasadniczo mówisz: „Wiem coś, czego kompilator nie wie”. W przypadku const_cast mówisz: „Nawet jeśli ta metoda przyjmuje odniesienie lub wskaźnik inne niż const, wiem, że nie zmieni parametru, który ją przekazuję”.

Więc jeśli naprawdę wiesz, co twierdzisz, że wiesz, używając obsady, możesz jej użyć.

Niszczysz wszelkie szanse na bezpieczeństwo wątków, jeśli zaczniesz modyfikować rzeczy, które kompilator uważał za 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;
}

źródło: http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Fkeyword_const_cast.htm