Чи безпечний const_cast?

Я не можу знайти багато інформації про const_cast. Єдину інформацію, яку я зміг знайти (про переповнення стека), це:

const_cast<>()Використовується для додавання / видалення сопзЬ (Ness) (або летючого-ність) змінної.

Це мене нервує. Чи може використання const_castпричини несподіваної поведінки? Якщо так, то що?

Як варіант, коли це нормально використовувати const_cast?

const_castбезпечно, лише якщо ви передаєте змінну, яка спочатку була не- const. Наприклад, якщо у вас є функція, яка приймає параметр а const char *, і ви передаєте модифікуваний char *, безпечно повернути const_castцей параметр до а 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 є безпечним та корисним (можуть бути й інші дійсні випадки).

Одне - це коли у вас є екземпляр const, посилання або вказівник, і ви хочете передати вказівник або посилання на API, який не є правильним для const, але що ви ЗАЯВКИ не зміните об’єкт. Ви можете 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, але не побітовий const. Ви можете 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 :

Якщо ви відкинете constness об'єкта, який був явно оголошений як const, і спробуєте змінити його, результати не визначені.

Однак, якщо ви відкидаєте constness об'єкта, який не був явно оголошений як 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;
};

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

Коротка відповідь - ні, це не безпечно.

Довга відповідь полягає в тому, що якщо ви знаєте достатньо, щоб ним користуватися, то це повинно бути безпечним.

Під час кастингу ви по суті говорите: "Я знаю те, що компілятор не знає". У випадку const_cast, ви говорите: "Хоча цей метод приймає посилання або вказівник, що не є const, я знаю, що це не змінить параметр, який я передаю".

Отже, якщо ви насправді знаєте, про що ви стверджуєте, що знаєте, використовуючи акторський склад, тоді добре використовувати його.

Ви знищуєте будь-який шанс на безпеку потоків, якщо ви починаєте модифікувати речі, які компілятор вважав 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;
}

джерело: http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Fkeyword_const_cast.htm