Const_cast có an toàn không?

Tôi không thể tìm thấy nhiều thông tin về const_cast. Thông tin duy nhất tôi có thể tìm thấy (trên Stack Overflow) là:

Các const_cast<>()được sử dụng để Add / Remove const (Ness) (hoặc không ổn định-Ness) của một biến.

Điều này khiến tôi lo lắng. Việc sử dụng có thể const_castgây ra hành vi không mong muốn không? Nếu vậy thì sao?

Ngoài ra, khi nào thì sử dụng được const_cast?

const_castchỉ an toàn nếu bạn đang truyền một biến ban đầu không phải const. Ví dụ: nếu bạn có một hàm nhận tham số là a const char *và bạn chuyển vào một tham số có thể sửa đổi char *, thì sẽ an toàn khi const_castquay lại tham số đó về a char *và sửa đổi nó. Tuy nhiên, nếu thực tế là biến ban đầu const, thì việc sử dụng const_castsẽ dẫn đến hành vi không xác định.

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

Tôi có thể nghĩ đến hai tình huống mà const_cast an toàn và hữu ích (có thể có những trường hợp hợp lệ khác).

Một là khi bạn có một cá thể, tham chiếu hoặc con trỏ const và bạn muốn chuyển một con trỏ hoặc tham chiếu đến một API không đúng hằng số, nhưng bạn CHẮC CHẮN sẽ không sửa đổi đối tượng. Bạn có thể const_cast con trỏ và chuyển nó đến API, tin tưởng rằng nó sẽ không thực sự thay đổi bất cứ điều gì. Ví dụ:

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

Trường hợp khác là nếu bạn đang sử dụng trình biên dịch cũ hơn không triển khai 'có thể thay đổi' và bạn muốn tạo một lớp theo logic const nhưng không phải const bit. Bạn có thể const_cast 'this' trong một phương thức const và sửa đổi các thành viên trong lớp của bạn.

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

Tôi khó tin rằng đó là thông tin duy nhất bạn có thể tìm thấy về const_cast. Trích dẫn từ lần truy cập thứ hai của Google :

Nếu bạn loại bỏ hằng số của một đối tượng đã được khai báo rõ ràng là const và cố gắng sửa đổi nó, kết quả là không xác định.

Tuy nhiên, nếu bạn loại bỏ hằng số của một đối tượng chưa được khai báo rõ ràng là const, bạn có thể sửa đổi nó một cách an toàn.

Adam nói gì. Một ví dụ khác mà const_cast có thể hữu ích:

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

Đầu tiên chúng ta thêm const vào kiểu thistrỏ tới, sau đó chúng ta gọi phiên bản const của getTvà sau đó chúng ta xóa const khỏi kiểu trả về, kiểu này hợp lệ vì tphải không phải là const (nếu không, phiên bản không phải const của getTkhông thể có được gọi). Điều này có thể rất hữu ích nếu bạn có một nội dung hàm lớn và bạn muốn tránh mã thừa.

Câu trả lời ngắn gọn là không, nó không an toàn.

Câu trả lời dài là nếu bạn biết đủ để sử dụng nó, thì nó sẽ an toàn.

Khi bạn đang truyền, những gì bạn đang nói về cơ bản là, "Tôi biết điều gì đó mà trình biên dịch không biết." Trong trường hợp của const_cast, những gì bạn đang nói là, "Mặc dù phương thức này nhận tham chiếu hoặc con trỏ không phải const, tôi biết rằng nó sẽ không thay đổi tham số tôi truyền vào."

Vì vậy, nếu bạn thực sự biết những gì bạn đang tuyên bố biết trong việc sử dụng diễn viên, thì bạn có thể sử dụng nó.

Bạn đang phá hủy bất kỳ cơ hội nào về an toàn luồng, nếu bạn bắt đầu sửa đổi những thứ mà trình biên dịch nghĩ là 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;
}

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