Reinterpret_cast ne zaman kullanılır?

Ben küçük uygulanabilirliği ile karıştı reinterpret_castvs static_cast. Ne okudum genel kurallar türleri derleme zamanında dolayısıyla kelime yorumlanabilir zaman statik döküm kullanmaktır static. Bu, C ++ derleyicisinin dahili dökümler için dahili olarak kullandığı dökümdür.

reinterpret_casts iki senaryoda uygulanabilir:

• tamsayı türlerini işaretçi türlerine ve tam tersini dönüştürme
• bir işaretçi türünü diğerine dönüştürür. Anladığım kadarıyla genel fikir, bunun taşınabilir olmadığı ve kaçınılması gerektiğidir.

Biraz karışık nerede ihtiyacım olan bir kullanım, C + + C C deniyorum ve C kodu temelde bir tutar C ++ nesnesine tutunması gerekiyor void*. void *Sınıf türü arasında dönüştürme yapmak için hangi oyuncular kullanılmalıdır ?

İkisinin de kullanımını gördüm static_castve reinterpret_cast? Okuduğum şeyden static, döküm derleme zamanında olabileceğinden daha iyi görünüyor olsa da ? reinterpret_castBir işaretçi türünden diğerine dönüştürmek için kullanmasına rağmen ?

C ++ standardı aşağıdakileri garanti eder:

static_castvoid*adrese ve işaretçi kullanarak adres korunur. Yani, aşağıda olduğu a, bve caynı adrese işaret ediyor:

int* a = new int();
void* b = static_cast<void*>(a);
int* c = static_cast<int*>(b);

reinterpret_castyalnızca bir işaretçiyi farklı bir türe çevirirseniz ve daha sonra reinterpret_castorijinal türe geri döndürürseniz orijinal değeri elde edeceğinizi garanti eder . Yani aşağıda:

int* a = new int();
void* b = reinterpret_cast<void*>(a);
int* c = reinterpret_cast<int*>(b);

ave caynı değeri içerir, ancak değeri bbelirtilmez. (pratikte genellikle aynı adresi içerecek ave cfakat o standardında belirtilen değil ve daha karmaşık hafıza sistemleriyle makinelerde doğru olmayabilir.)

Ve yayın yapmak için void*, static_casttercih edilmelidir.

reinterpret_castGerektiğinde bir vaka opak veri tipleriyle arayüz oluştururken ortaya çıkar. Bu, programlayıcının üzerinde kontrolü olmayan satıcı API'larında sık sık görülür. Aşağıda, bir satıcının keyfi küresel verileri depolamak ve almak için bir API sağladığı anlaşmalı bir örnek verilmiştir:

// vendor.hpp
typedef struct _Opaque * VendorGlobalUserData;
void VendorSetUserData(VendorGlobalUserData p);
VendorGlobalUserData VendorGetUserData();

Bu API'yı kullanmak için programcı verilerini VendorGlobalUserDatatekrar tekrar yayınlamalıdır. static_castişe yaramazsa, kullanmanız gerekir reinterpret_cast:

// main.cpp
#include "vendor.hpp"
#include <iostream>
using namespace std;

struct MyUserData {
    MyUserData() : m(42) {}
    int m;
};

int main() {
    MyUserData u;

        // store global data
    VendorGlobalUserData d1;
//  d1 = &u;                                          // compile error
//  d1 = static_cast<VendorGlobalUserData>(&u);       // compile error
    d1 = reinterpret_cast<VendorGlobalUserData>(&u);  // ok
    VendorSetUserData(d1);

        // do other stuff...

        // retrieve global data
    VendorGlobalUserData d2 = VendorGetUserData();
    MyUserData * p = 0;
//  p = d2;                                           // compile error
//  p = static_cast<MyUserData *>(d2);                // compile error
    p = reinterpret_cast<MyUserData *>(d2);           // ok

    if (p) { cout << p->m << endl; }
    return 0;
}

Aşağıda örnek API'nın tutarlı bir uygulaması yer almaktadır:

// vendor.cpp
static VendorGlobalUserData g = 0;
void VendorSetUserData(VendorGlobalUserData p) { g = p; }
VendorGlobalUserData VendorGetUserData() { return g; }

Kısa cevap: Ne anlama geldiğini bilmiyorsanız reinterpret_castkullanmayın. Gelecekte buna ihtiyacınız olacaksa, bileceksiniz.

Tam cevap:

Temel sayı türlerini ele alalım.

Örneğin dönüştürdüğünüzde int(12)için unsigned float (12.0f)hem sayı olarak bazı hesaplamalar çağırmak için işlemci ihtiyaçları farklı bit temsil edilmektedir. Bunun anlamı budur static_cast.

Öte yandan, reinterpret_castCPU çağırdığınızda herhangi bir hesaplama başlatmaz. Bellekteki başka bir bit gibi davranır. Dönüştürmek Yani int*için float*bu anahtar kelime ile, (işaretçi dereferecing sonra) yeni değer matematiksel anlam eski değerle ilgisi yoktur.

Örnek: Tekreinterpret_castbir nedenden dolayı (endianness) taşınabilir olmadığıdoğrudur. Ancak bu genellikle şaşırtıcı bir şekilde onu kullanmanın en iyi nedenidir. Örneği düşünelim: dosyadan ikili 32 bit numarasını okumak zorundasınız ve bunun büyük endian olduğunu biliyorsunuz. Kodunuzun genel olması ve büyük endian (örneğin bazı ARM) ve küçük endian (örn. X86) sistemlerinde düzgün çalışması gerekir. Yani bayt sırasını kontrol etmelisiniz. Derleme zamanında iyi bilinir, böylece constexprişlev yazabilirsiniz : Bunu başarmak için bir işlev yazabilirsiniz:

/*constexpr*/ bool is_little_endian() {
  std::uint16_t x=0x0001;
  auto p = reinterpret_cast<std::uint8_t*>(&x);
  return *p != 0;
}

Açıklama:x belleğinikili gösterimi0000'0000'0000'0001(büyük) veya0000'0001'0000'0000(küçük endian) olabilir. Yeniden yorumlama işleminden sonrapişaretçialtındaki baytsırasıyla0000'0000veyaolabilir0000'0001. Statik döküm kullanıyorsanız,0000'0001hangi endianite kullanılırsa kullanılsınher zaman olacaktır.

DÜZENLE:

_{İlk versiyonunda benim örnek işlevi yapılmış is_little_endianolması constexpr. En yeni gcc'de (8.3.0) iyi derlenir, ancak standart yasadışı olduğunu söylüyor. Clang derleyicisi onu derlemeyi reddeder (bu doğrudur).}

Anlamı reinterpret_castC ++ standardı tarafından tanımlanmamıştır. Bu nedenle, teorik olarak a reinterpret_castprogramınızı çökertebilir. Pratikte derleyiciler beklediğiniz şeyi yapmaya çalışırlar, bu da geçmekte olduğunuz şeylerin parçalarını, yayınlamakta olduğunuz türdeymiş gibi yorumlamaktır. Kullanacağınız derleyicilerin ne yapacağını biliyorsanız, reinterpret_cast bunu kullanabilirsiniz, ancak taşınabilir olduğunu söylemek yalan söylemek olacaktır.

Açıkladığınız vaka ve düşünebileceğiniz hemen hemen her durumda bunun yerine veya başka bir alternatif reinterpret_castkullanabilirsiniz static_cast. Diğer şeylerin yanı sıra, standardın beklentileriniz hakkında şunları söylemesi gerekir static_cast(§5.2.9):

“Pointer to cv void” türünün bir değeri açıkça bir işaretçiye nesne türüne dönüştürülebilir. “Pointer to cv void” e dönüştürülen ve orijinal işaretçi tipine geri döndürülen nesne tipi tip değerinin orijinal değeri olacaktır.

Bu nedenle, kullanım durumunuz için, standardizasyon komitesinin kullanmanız için tasarlandığı oldukça açık görünüyor static_cast.

Reinterpret_cast'in bir kullanımı da (IEEE 754) şamandıralara bitsel işlemler uygulamak istemenizdir. Buna bir örnek Hızlı Ters Karekök hüneriydi:

https://en.wikipedia.org/wiki/Fast_inverse_square_root#Overview_of_the_code

Şamandıranın ikili temsilini bir tamsayı olarak ele alır, sağa kaydırır ve bir sabitten çıkarır, böylece üssü yarıya indirir ve reddeder. Bir şamandıraya dönüştükten sonra, bu yaklaşımı daha kesin hale getirmek için Newton-Raphson yinelemesine tabi tutulur:

float Q_rsqrt( float number )
{
    long i;
    float x2, y;
    const float threehalfs = 1.5F;

    x2 = number * 0.5F;
    y  = number;
    i  = * ( long * ) &y;                       // evil floating point bit level hacking
    i  = 0x5f3759df - ( i >> 1 );               // what the deuce? 
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
//  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

    return y;
}

Bu başlangıçta C dilinde yazılmıştır, bu nedenle C dökümleri kullanır, ancak benzer C ++ dökümü reinterpret_cast'tir.

Derleme zamanında miras durumunu kontrol etmek için reinterprete_cast kullanabilirsiniz.
Buraya bakın: Derleme zamanında mirası kontrol etmek için reinterpret_cast kullanma

template <class outType, class inType>
outType safe_cast(inType pointer)
{
    void* temp = static_cast<void*>(pointer);
    return static_cast<outType>(temp);
}

Sonuçlandırmaya çalıştım ve şablonlar kullanarak basit bir güvenli döküm yazdım. Bu çözümün, işlevlere işaretçi atmayı garanti etmediğini unutmayın.

Öncelikle int gibi belirli bir türde bazı verileriniz var:

int x = 0x7fffffff://==nan in binary representation

Sonra float gibi başka bir değişkenle aynı değişkene erişmek istersiniz:

float y = reinterpret_cast<float&>(x);

//this could only be used in cpp, looks like a function with template-parameters

veya

float y = *(float*)&(x);

//this could be used in c and cpp

KISA: Bu, aynı belleğin farklı bir tip olarak kullanıldığı anlamına gelir. Böylece, yukarıdaki gibi int türü olan şamandıraların ikili temsillerini şamandıralara dönüştürebilirsiniz. Örneğin 0x80000000 -0'dır (mantis ve üs boştur ancak msb işareti birdir. Bu aynı zamanda çiftler ve uzun çiftler için de geçerlidir.

OPTIMIZE: c-döküm pointeraritmetik tarafından yapılırken reinterpret_cast birçok derleyici optimize olacağını düşünüyorum (değer belleğe kopyalanması gerekir, çünkü işaretçiler işlemci kayıt olamazdı).

NOT: Her iki durumda da, dökümden önce döküm değerini bir değişkene kaydetmelisiniz! Bu makro yardımcı olabilir:

#define asvar(x) ({decltype(x) __tmp__ = (x); __tmp__; })

Kullanmanın bir nedeni reinterpret_cast, bir temel sınıfın bir vtable içermediği, ancak türetilmiş bir sınıfın olmasıdır. Bu durumda static_castve reinterpret_castfarklı işaretçi değerleriyle sonuçlanacaktır (bu yukarıdaki jalf tarafından belirtilen atipik durum olacaktır ). Bir feragatname olarak, bunun standardın bir parçası olduğunu değil, birkaç yaygın derleyicinin uygulanmasını belirtiyorum.

Örnek olarak, aşağıdaki kodu alın:

#include <cstdio>

class A {
public:
    int i;
};

class B : public A {
public:
    virtual void func() {  }
};

int main()
{
    B b;
    const A* a = static_cast<A*>(&b);
    const A* ar = reinterpret_cast<A*>(&b);

    printf("&b = %p\n", &b);
    printf(" a = %p\n", a);
    printf("ar = %p\n", ar);
    printf("difference = %ld\n", (long int)(a - ar));

    return 0;
}

Hangi gibi bir çıktı üretir:

& b = 0x7ffe10e68b38
a = 0x7ffe10e68b40
ar = 0x7ffe10e68b38
fark = 2

Denediğim tüm derleyicilerde (MSVC 2015 ve 2017, clang 8.0.0, gcc 9.2, icc 19.0.1 - son 3 için godbolt'a bakın ) sonucu 2'den (MSVC için 4) static_castfarklıdır reinterpret_cast. Fark hakkında uyarmak için tek derleyici clang'dı:

17:16: uyarı: 'B *' sınıfından sıfır olmayan ofset 'A *' da tabanına 'reinterpret_cast' 'static_cast' [-Wreinterpret-base-class]
const A * ar = reinterpret_cast (& b) ;
^ ~~~~~~~~~~~~~~~~~~~~~~~
17:16: not:
const A * ar = reinterpret_cast (& b) uyandırırken işaretçiyi doğru ayarlamak için 'static_cast' kullanın ;
^ ~~~~~~~~~~~~~~~
static_cast

Son bir uyarı, temel sınıfın veri üyesi yoksa (örn. int i;) Clang, gcc ve icc , olduğu reinterpret_castgibi aynı adresi döndürürken static_castMSVC hala yoktur.

İşte Avi Ginsburg'un reinterpret_castChris Luengo, flodin ve cmdLP tarafından bahsedilen özelliğini açıkça gösteren bir çeşidi: derleyicinin sivri hafıza konumuna yeni tipte bir nesne gibi davranması:

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

class A
{
public:
    int i;
};

class B : public A
{
public:
    virtual void f() {}
};

int main()
{
    string s;
    B b;
    b.i = 0;
    A* as = static_cast<A*>(&b);
    A* ar = reinterpret_cast<A*>(&b);
    B* c = reinterpret_cast<B*>(ar);

    cout << "as->i = " << hex << setfill('0')  << as->i << "\n";
    cout << "ar->i = " << ar->i << "\n";
    cout << "b.i   = " << b.i << "\n";
    cout << "c->i  = " << c->i << "\n";
    cout << "\n";
    cout << "&(as->i) = " << &(as->i) << "\n";
    cout << "&(ar->i) = " << &(ar->i) << "\n";
    cout << "&(b.i) = " << &(b.i) << "\n";
    cout << "&(c->i) = " << &(c->i) << "\n";
    cout << "\n";
    cout << "&b = " << &b << "\n";
    cout << "as = " << as << "\n";
    cout << "ar = " << ar << "\n";
    cout << "c  = " << c  << "\n";

    cout << "Press ENTER to exit.\n";
    getline(cin,s);
}

Bunun sonucu şöyle olur:

as->i = 0
ar->i = 50ee64
b.i   = 0
c->i  = 0

&(as->i) = 00EFF978
&(ar->i) = 00EFF974
&(b.i) = 00EFF978
&(c->i) = 00EFF978

&b = 00EFF974
as = 00EFF978
ar = 00EFF974
c  = 00EFF974
Press ENTER to exit.

B nesnesinin bellekte önce B'ye özgü veriler, ardından gömülü A nesnesi olarak oluşturulduğu görülebilir. static_castDoğru katıştırılmış bir nesnenin adresini geri yarattığı ve gösterici static_castdoğru veri alanının değerini verir. İşaretçi tarafından oluşturulan işaretçi , düz A nesnesi gibi reinterpret_castdavranır bve böylece işaretçi veri alanını almaya çalıştığında, bu alanın içeriğiymiş gibi B'ye özgü bazı veriler döndürür.

Bunun bir kullanımı, reinterpret_castbir işaretçiyi işaretsiz bir tam sayıya dönüştürmektir (işaretçiler ve işaretsiz tamsayılar aynı boyutta olduğunda):

int i; unsigned int u = reinterpret_cast<unsigned int>(&i);

Hızlı cevap: static_castderlenirse kullanın , aksi takdirde başvurunuz reinterpret_cast.

SSS bölümünü okuyun ! C ++ verilerinin C'de tutulması riskli olabilir.

C ++ 'da, bir nesneye yönelik bir işaretçi void *hiçbir döküm olmadan dönüştürülebilir . Ama bunun tersi doğru değil. static_castOrijinal işaretçiyi geri almak için a'ya ihtiyacınız vardır .