const_cast ปลอดภัยหรือไม่?

const_castฉันไม่สามารถหาข้อมูลมากใน ข้อมูลเดียวที่ฉันพบ (ใน Stack Overflow) คือ:

const_cast<>()จะใช้ในการเพิ่ม / ลบ const (เนส) (หรือระเหย-Ness) ของตัวแปร

นี่ทำให้ฉันกังวล อาจconst_castทำให้เกิดพฤติกรรมที่ไม่คาดคิดได้หรือไม่? ถ้าเป็นเช่นนั้นคืออะไร?

อีกวิธีหนึ่งคือใช้เมื่อconst_castใด

const_castconstมีความปลอดภัยเท่านั้นถ้าคุณกำลังหล่อตัวแปรที่เป็นไม่ใช่เดิม ตัวอย่างเช่นหากคุณมีฟังก์ชันที่รับพารามิเตอร์ของ 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 ปลอดภัยและมีประโยชน์ (อาจมีกรณีอื่น ๆ ที่ถูกต้อง)

หนึ่งคือเมื่อคุณมีอินสแตนซ์การอ้างอิงหรือตัวชี้ const และคุณต้องการส่งผ่านตัวชี้หรือการอ้างอิงไปยัง API ที่ไม่ถูกต้อง แต่คุณ CERTAIN จะไม่แก้ไขวัตถุ คุณสามารถ 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()));
}

อีกอย่างคือถ้าคุณใช้คอมไพเลอร์รุ่นเก่าที่ไม่ได้ใช้ 'mutable' และคุณต้องการสร้างคลาสที่มีตรรกะ แต่ไม่ใช่ 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 hit ครั้งที่สอง :

หากคุณละทิ้งความมั่นคงของวัตถุที่ได้รับการประกาศอย่างชัดเจนว่าเป็น 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 ให้กับ type thispoint จากนั้นเราเรียกเวอร์ชัน const ของgetTจากนั้นเราจะลบ const ออกจากประเภท return ซึ่งถูกต้องเนื่องจากtต้องไม่ใช่ const (มิฉะนั้นเวอร์ชันที่ไม่ใช่ const getTจะไม่มี ถูกเรียก) สิ่งนี้จะมีประโยชน์มากหากคุณมีฟังก์ชันขนาดใหญ่และคุณต้องการหลีกเลี่ยงโค้ดซ้ำซ้อน

คำตอบสั้น ๆ คือไม่มันไม่ปลอดภัย

คำตอบยาว ๆ คือถ้าคุณรู้จักพอที่จะใช้มันก็น่าจะปลอดภัย

เมื่อคุณแคสต์สิ่งที่คุณพูดเป็นหลักคือ "ฉันรู้ว่ามีอะไรที่คอมไพเลอร์ไม่รู้" ในกรณีของ const_cast สิ่งที่คุณกำลังพูดคือ "แม้ว่าวิธีนี้จะใช้การอ้างอิงหรือตัวชี้ที่ไม่ใช่ const แต่ฉันรู้ว่าจะไม่เปลี่ยนพารามิเตอร์ที่ฉันส่งผ่านไป"

ดังนั้นหากคุณรู้จริงในสิ่งที่คุณอ้างว่ารู้ในการใช้นักแสดงก็ใช้ได้ดี

คุณกำลังทำลายโอกาสใด ๆ ในเรื่องความปลอดภัยของเธรดหากคุณเริ่มแก้ไขสิ่งที่คอมไพเลอร์คิดว่าเป็น const