Const_cast güvenli mi?

Hakkında fazla bilgi bulamıyorum const_cast. Bulabildiğim tek bilgi (Stack Overflow'da):

const_cast<>()/ Bir değişkenin kaldırma const (lık) (veya uçucu-lık) eklemek için kullanılır.

Bu beni endişelendiriyor. Bir kullanarak Could const_castnedeni beklenmeyen davranışlarla? Öyleyse ne olmuş?

Alternatif olarak, ne zaman kullanmak uygun olur const_cast?

const_castyalnızca orijinal olmayan bir değişkeni atıyorsanız güvenlidir const. Örneğin, bir a parametresini alan bir fonksiyonunuz varsa const char *ve bir değiştirilebilir parametresini iletirseniz char *, o const_castparametreye geri dönüp onu değiştirmek güvenlidir char *. Ancak, orijinal değişken gerçekte ise const, o zaman kullanmak const_casttanımsız davranışla sonuçlanacaktır.

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'in güvenli ve kullanışlı olduğu iki durum düşünebilirim (başka geçerli durumlar olabilir).

Birincisi, bir const örneğiniz, başvurunuz veya işaretçiniz olduğunda ve const-doğru olmayan bir API'ye bir işaretçi veya başvuru iletmek istediğinizde, ancak CERTAIN'in nesneyi değiştirmeyeceğidir. İşaretçiyi sabitleyebilir ve gerçekten hiçbir şeyi değiştirmeyeceğine güvenerek API'ye iletebilirsiniz. Örneğin:

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

Diğeri, 'mutable' uygulamayan eski bir derleyici kullanıyorsanız ve mantıksal olarak sabit olan ancak bitsel sabit olmayan bir sınıf oluşturmak istiyorsanız. Bir const yöntemi içinde "this" i sabitleyebilir ve sınıfınızın üyelerini değiştirebilirsiniz.

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 hakkında bulabileceğiniz tek bilginin bu olduğuna inanmakta zorlanıyorum. İkinci Google isabetinden alıntı :

Açıkça const olarak bildirilmiş bir nesnenin sabitliğini atarsanız ve onu değiştirmeye çalışırsanız, sonuçlar tanımsız olur.

Ancak, açık bir şekilde const olarak bildirilmemiş bir nesnenin sabitliğini atarsanız, onu güvenli bir şekilde değiştirebilirsiniz.

Adam ne diyor. Const_cast'in yardımcı olabileceği başka bir örnek:

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

Önce tür thisişaretlerine const ekleriz , sonra const sürümünü çağırırız getTve sonra const'ı döndürme türünden kaldırırız, çünkü bu geçerli t, const olmayan olmalıdır (aksi takdirde, const olmayan sürüm getTolamazdı çağrıldı). Büyük bir işlev gövdeniz varsa ve gereksiz kodlardan kaçınmak istiyorsanız, bu çok yararlı olabilir.

Kısa cevap hayır, güvenli değil.

Uzun cevap, eğer onu kullanacak kadar biliyorsanız, o zaman güvenli olması gerektiğidir.

Oyuncu yayınlarken, aslında söylediğiniz şey, "Derleyicinin bilmediği bir şeyi biliyorum." Const_cast durumunda, söylediğiniz şu: "Bu yöntem const olmayan bir başvuru veya işaretçi alsa da, ilettiğim parametreyi değiştirmeyeceğini biliyorum."

Dolayısıyla, oyuncu kadrosunu kullanırken gerçekten neyi bildiğinizi iddia ettiğinizi biliyorsanız, onu kullanmakta sorun yok.

Derleyicinin sabit olduğunu düşündüğü şeyleri değiştirmeye başlarsanız, iş parçacığı güvenliğindeki herhangi bir şansı yok edersiniz.