Const_cast безопасно?

Я не могу найти много информации по const_cast. Единственная информация, которую я смог найти (на Stack Overflow):

const_cast<>()Используется для добавления / удаления сопзЬ (Ness) (или летучего-ность) переменной.

Это заставляет меня нервничать. Могло ли использование const_castвызвать неожиданное поведение? Если так, то?

В качестве альтернативы, когда можно использовать const_cast?

const_castбезопасно, только если вы приводите переменную, которая изначально не была const. Например, если у вас есть функция, которая принимает параметр a const char *, и вы передаете изменяемый char *, можно безопасно const_castвернуть этот параметр обратно в a char *и изменить его. Однако, если исходная переменная была на самом деле const, то использование const_castприведет к неопределенному поведению.

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

Я могу вспомнить две ситуации, когда const_cast безопасен и полезен (могут быть и другие допустимые случаи).

Один из них - когда у вас есть константный экземпляр, ссылка или указатель, и вы хотите передать указатель или ссылку на API, который не является константно-правильным, но вы НЕОБХОДИМО не будете изменять объект. Вы можете const_cast указатель и передать его API, полагая, что он ничего не изменит. Например:

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

Другой - если вы используете более старый компилятор, который не реализует «изменяемый», и вы хотите создать класс, который является логически константным, но не побитовым. Вы можете const_cast 'this' внутри метода const и изменять члены вашего класса.

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

Мне трудно поверить, что это единственная информация, которую вы могли найти о const_cast. Цитата из второго хита Google :

Если вы откажетесь от константности объекта, который был явно объявлен как const, и попытаетесь изменить его, результаты не будут определены.

Однако, если вы отказываетесь от константности объекта, который не был явно объявлен как const, вы можете безопасно его изменить.

Что говорит Адам. Другой пример, в котором может быть полезно const_cast:

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

Сначала мы добавляем const к типу, на который thisуказывает, затем мы вызываем константную версию getT, а затем мы удаляем const из возвращаемого типа, который действителен, поскольку tдолжен быть неконстантным (в противном случае неконстантная версия getTне могла иметь был назван). Это может быть очень полезно, если у вас большое тело функции и вы хотите избежать избыточного кода.

Короткий ответ - нет, это небезопасно.

Длинный ответ таков: если вы знаете достаточно, чтобы использовать его, это должно быть безопасно.

Когда вы выполняете приведение, вы, по сути, говорите: «Я знаю то, чего не знает компилятор». В случае const_cast вы говорите: «Даже если этот метод принимает неконстантную ссылку или указатель, я знаю, что он не изменит параметр, который я ему передаю».

Так что, если вы действительно знаете, что вы утверждаете, что знаете, используя приведение, то это нормально.

Вы уничтожаете любую возможность обеспечения безопасности потоков, если начинаете изменять вещи, которые компилятор считал константными.