ควรใช้ reinterpret_cast เมื่อใด

ฉันกำลังสับสนเล็กน้อยกับการบังคับใช้ของVSreinterpret_cast จากสิ่งที่ฉันได้อ่านกฎทั่วไปที่ใช้งานหล่อแบบคงที่เมื่อชนิดสามารถตีความที่รวบรวมเวลาด้วยเหตุนี้คำว่าstatic_cast staticนี่คือ cast คอมไพเลอร์ C ++ ที่ใช้ภายในสำหรับการร่ายโดยปริยายด้วย

reinterpret_casts ใช้งานได้ในสองสถานการณ์:

• แปลงประเภทจำนวนเต็มเป็นประเภทของตัวชี้และในทางกลับกัน
• แปลงประเภทตัวชี้หนึ่งเป็นประเภทอื่น แนวคิดทั่วไปที่ฉันได้รับคือสิ่งนี้ไม่สามารถพูดได้และควรหลีกเลี่ยง

ฉันอยู่ที่ไหนน้อยสับสนเป็นหนึ่งในการใช้งานที่ฉันต้องการฉันโทร c ++ จากซีและความต้องการรหัส C จะยึดมั่นในการ C ++ void*วัตถุดังนั้นโดยทั่วไปมันถือ คาสต์ใดที่ควรใช้เพื่อแปลงระหว่างvoid *และประเภทคลาส

ฉันได้เห็นการใช้งานของทั้งสองstatic_castและreinterpret_cast? แม้ว่าจากสิ่งที่ฉันได้อ่านดูเหมือนstaticจะดีกว่าที่นักแสดงสามารถเกิดขึ้นได้ในเวลารวบรวม? แม้ว่ามันจะบอกว่าจะใช้reinterpret_castในการแปลงจากประเภทตัวชี้หนึ่งไปสู่อีกประเภทหนึ่ง?

มาตรฐาน C ++ รับประกันดังต่อไปนี้:

static_castไอเอ็นจีตัวชี้ไปยังและจากการvoid*รักษาที่อยู่ นั่นคือในต่อไปนี้a, bและcทุกจุดที่อยู่เดียวกัน:

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

reinterpret_castรับประกันได้ว่าหากคุณชี้ตัวชี้ไปยังประเภทอื่นแล้วreinterpret_castกลับไปเป็นประเภทดั้งเดิมคุณจะได้รับค่าดั้งเดิม ดังนั้นในต่อไปนี้:

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

aและcมีค่าเหมือนกัน แต่ค่าของการbเป็นพลรบ (โดยทั่วไปจะมีที่อยู่เดียวกับaและcแต่ไม่ได้ระบุไว้ในมาตรฐานและอาจไม่เป็นจริงในเครื่องที่มีระบบหน่วยความจำที่ซับซ้อนมากขึ้น)

สำหรับการหล่อไปและกลับจากvoid*, static_castควรได้รับการแนะนำ

กรณีหนึ่งที่reinterpret_castจำเป็นเมื่อมีการเชื่อมต่อกับชนิดข้อมูลทึบแสง สิ่งนี้เกิดขึ้นบ่อยครั้งใน API ของผู้ขายซึ่งโปรแกรมเมอร์ไม่สามารถควบคุมได้ ต่อไปนี้เป็นตัวอย่างที่วางแผนไว้โดยที่ผู้ขายได้จัดทำ API สำหรับการจัดเก็บและเรียกใช้ข้อมูลส่วนกลางโดยพลการ:

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

ในการใช้ API นี้โปรแกรมเมอร์จะต้องส่งข้อมูลไปVendorGlobalUserDataและกลับมาอีกครั้ง static_castจะไม่ทำงานต้องใช้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;
}

ด้านล่างนี้เป็นการใช้งาน API ตัวอย่างที่วางแผนไว้:

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

คำตอบสั้น ๆ : ถ้าคุณไม่รู้ว่าอะไรreinterpret_castคือสิ่งที่ควรทำอย่าใช้มัน หากคุณต้องการในอนาคตคุณจะรู้

คำตอบแบบเต็ม:

ลองพิจารณาประเภทหมายเลขพื้นฐาน

เมื่อคุณแปลงตัวอย่างint(12)ที่จะunsigned float (12.0f)ตอบสนองความต้องการประมวลผลของคุณจะก่อให้เกิดการคำนวณบางส่วนเป็นตัวเลขทั้งมีการแสดงแตกต่างกันเล็กน้อย นี่คือสิ่งที่static_castหมายถึง

ในทางกลับกันเมื่อคุณเรียกreinterpret_castใช้ CPU จะไม่เรียกใช้การคำนวณใด ๆ มันแค่ตั้งค่าบิตในหน่วยความจำเช่นถ้ามันมีประเภทอื่น ดังนั้นเมื่อคุณแปลงint*เป็นfloat*คำหลักนี้ค่าใหม่ (หลังจากตัวชี้การยกเลิกการลงทะเบียน) จะไม่เกี่ยวข้องกับค่าเก่าในความหมายทางคณิตศาสตร์

ตัวอย่าง:มันเป็นความจริงที่reinterpret_castไม่สามารถพกพาได้เนื่องจากเหตุผลหนึ่งข้อ - สั่งไบต์ (endianness) แต่นี่เป็นเหตุผลที่ดีที่สุดที่จะใช้ ลองนึกภาพตัวอย่าง: คุณต้องอ่านเลขฐานสอง 32 บิตจากไฟล์และคุณรู้ว่ามันเป็น endian ที่ยิ่งใหญ่ รหัสของคุณจะต้องเป็นแบบทั่วไปและทำงานอย่างถูกต้องในระบบ endian ขนาดใหญ่ (เช่น ARM บางตัว) และระบบ endian ขนาดเล็ก (เช่น x86) ดังนั้นคุณต้องตรวจสอบลำดับไบต์ มันเป็นที่รู้จักกันดีในเวลารวบรวมเพื่อให้คุณสามารถเขียนconstexprฟังก์ชั่น:คุณสามารถเขียนฟังก์ชั่นเพื่อให้บรรลุนี้:

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

คำอธิบาย:การเป็นตัวแทนไบนารีxในหน่วยความจำอาจเป็น0000'0000'0000'0001(ใหญ่) หรือ0000'0001'0000'0000(endian น้อย) หลังจากแปลหล่อไบต์ภายใต้pตัวชี้อาจเป็นตามลำดับหรือ0000'0000 0000'0001หากคุณใช้การหล่อแบบคงที่จะเกิดขึ้นเสมอ0000'0001ไม่ว่าจะใช้งานแบบ endianness ใดก็ตาม

แก้ไข:

_{ในรุ่นแรกที่ผมทำเช่นฟังก์ชั่นที่จะเป็นis_little_endian constexprมันรวบรวมได้ดีใน gcc ใหม่ล่าสุด (8.3.0) แต่มาตรฐานบอกว่าผิดกฎหมาย คอมไพเลอร์เสียงดังกราวปฏิเสธที่จะรวบรวมมัน (ซึ่งถูกต้อง)}

ความหมายของreinterpret_castไม่ได้ถูกกำหนดโดยมาตรฐาน C ++ ดังนั้นในทางทฤษฎีแล้วreinterpret_castอาจทำให้โปรแกรมของคุณพังได้ ในทางปฏิบัติคอมไพเลอร์พยายามที่จะทำสิ่งที่คุณคาดหวังซึ่งก็คือการตีความบิตของสิ่งที่คุณกำลังส่งผ่านราวกับว่าพวกเขาเป็นประเภทที่คุณหล่อ ถ้าคุณรู้ว่าคอมไพเลอร์ที่คุณจะใช้ทำอะไรกับreinterpret_cast คุณสามารถใช้มัน แต่จะบอกว่ามันเป็นแบบพกพาที่จะโกหก

สำหรับกรณีที่คุณอธิบายและกรณีใด ๆ ที่คุณอาจพิจารณาreinterpret_castคุณสามารถใช้static_castหรือทางเลือกอื่นแทน เหนือสิ่งอื่นใดมาตรฐานได้กล่าวถึงสิ่งที่คุณคาดหวังได้static_cast(§5.2.9):

ค่า rvalue ของชนิด“ pointer to cv void” สามารถแปลงเป็นตัวชี้ไปยังชนิดของวัตถุได้อย่างชัดเจน ค่าประเภทตัวชี้ไปยังวัตถุที่แปลงเป็น“ ตัวชี้ไปยังช่องว่าง” และกลับไปเป็นประเภทตัวชี้ดั้งเดิมจะมีค่าเดิม

static_castดังนั้นสำหรับกรณีการใช้งานของคุณดูเหมือนว่าค่อนข้างชัดเจนว่าคณะกรรมการมาตรฐานที่มีไว้สำหรับคุณที่จะใช้

การใช้ reinterpret_cast ครั้งเดียวคือหากคุณต้องการใช้การดำเนินการระดับบิตกับลอย (IEEE 754) ตัวอย่างหนึ่งของสิ่งนี้คือเคล็ดลับ Square-Root ที่ตรงกันข้าม:

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

มันทำหน้าที่เป็นตัวแทนไบนารีของการลอยเป็นจำนวนเต็มเลื่อนไปทางขวาและลบมันออกจากค่าคงที่จึงลดลงครึ่งหนึ่งและลบล้างเลขชี้กำลัง หลังจากแปลงกลับเป็นทุ่นก็ต้องผ่านการทำซ้ำของ Newton-Raphson เพื่อให้การประมาณนี้แม่นยำยิ่งขึ้น:

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

สิ่งนี้เขียนขึ้นเป็นภาษา C ดังนั้นใช้ C casts แต่การใช้ C ++ แบบอะนาล็อกคือ reinterpret_cast

คุณสามารถใช้ reinterprete_cast เพื่อตรวจสอบการสืบทอดในเวลารวบรวม
ดูที่นี่: การใช้ reinterpret_cast เพื่อตรวจสอบการสืบทอดในเวลารวบรวม

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

ฉันพยายามที่จะสรุปและเขียน cast ปลอดภัยอย่างง่ายโดยใช้แม่แบบ โปรดทราบว่าวิธีนี้ไม่รับประกันว่าจะใช้งานพอยน์เตอร์ในฟังก์ชั่น

ก่อนอื่นคุณมีข้อมูลบางประเภทเช่น int ที่นี่:

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

จากนั้นคุณต้องการเข้าถึงตัวแปรเดียวกับประเภทอื่นเช่น float: คุณสามารถเลือกได้

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

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

หรือ

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

//this could be used in c and cpp

โดยย่อ: มันหมายความว่าหน่วยความจำเดียวกันถูกใช้เป็นประเภทที่แตกต่างกัน ดังนั้นคุณสามารถแปลงการแทนเลขฐานสองของโฟลตเป็นชนิด int เช่นด้านบนเป็นโฟลต 0x80000000 เป็น -0 เช่น (mantissa และ exponent นั้นเป็นโมฆะ แต่เครื่องหมาย, msb เป็นหนึ่งสิ่งนี้ใช้ได้กับคู่ผสมและคู่ยาว

OPTIMIZE: ฉันคิดว่า reinterpret_cast จะได้รับการปรับให้เหมาะสมที่สุดในคอมไพเลอร์หลาย ๆ ตัวในขณะที่ c-casting นั้นทำขึ้นโดยตัวชี้เลขคณิต (ค่าจะต้องคัดลอกไปยังหน่วยความจำทำให้พอยน์เตอร์ชี้ไม่ได้

หมายเหตุ: ในทั้งสองกรณีคุณควรบันทึกค่า casted ในตัวแปรก่อนร่าย! มาโครนี้สามารถช่วย:

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

เหตุผลหนึ่งที่ใช้reinterpret_castคือเมื่อคลาสพื้นฐานไม่มี vtable แต่คลาสที่ได้รับมา ในกรณีนั้นstatic_castและreinterpret_castจะส่งผลให้มีค่าพอยน์เตอร์ที่แตกต่างกัน (นี่อาจเป็นกรณีที่ผิดปกติที่jalf ด้านบน ) เช่นเดียวกับข้อจำกัดความรับผิดชอบฉันไม่ได้ระบุว่านี่เป็นส่วนหนึ่งของมาตรฐาน แต่เป็นการใช้งานคอมไพเลอร์ที่แพร่หลายหลายตัว

ตัวอย่างใช้รหัสด้านล่าง:

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

ซึ่งแสดงผลเช่น:

& b = 0x7ffe10e68b38
a = 0x7ffe10e68b40
ar = 0x7ffe10e68b38
ความแตกต่าง = 2

ในคอมไพเลอร์ทั้งหมดที่ฉันลองใช้ (MSVC 2015 และ 2017, เสียงดังกราว 8.0.0, gcc 9.2, icc 19.0.1 - ดูgodbolt ในช่วง 3 ) ผลลัพธ์ของความstatic_castแตกต่างจากที่reinterpret_cast2 (4 สำหรับ MSVC) คอมไพเลอร์เดียวที่จะเตือนเกี่ยวกับความแตกต่างคือเสียงดังกราวด้วย:

17:16: คำเตือน: 'reinterpret_cast' จากคลาส 'B *' ถึงฐานที่ออฟเซ็ตที่ไม่เป็นศูนย์ 'A *' จะทำงานแตกต่างจาก 'static_cast' [-Wreinterpret-base-class]
const A * ar = reinterpret_cast (& b) ;
^ ~~~~~~~~~~~~~~~~~~~~~~
17:16: หมายเหตุ: ใช้ 'static_cast' เพื่อปรับตัวชี้อย่างถูกต้องในขณะที่ upcasting
const A * ar = reinterpret_cast (& b) ;
^ ~~~~~~~~~~~~~~~~
static_cast

หนึ่งข้อแม้สุดท้ายคือถ้าชั้นฐานไม่มีสมาชิกข้อมูล (เช่นint i;) ดังนั้นเสียงดังกราว, gcc และ icc ส่งกลับที่อยู่เดียวกันสำหรับreinterpret_castในstatic_castขณะที่ MSVC ยังไม่

นี่คือความแตกต่างของโปรแกรมของ Avi Ginsburg ซึ่งแสดงให้เห็นอย่างชัดเจนถึงคุณสมบัติของreinterpret_castChris Luengo, flodin และ cmdLP ที่คอมไพเลอร์ปฏิบัติต่อตำแหน่งหน่วยความจำแบบแหลมถึงราวกับว่ามันเป็นวัตถุประเภทใหม่:

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

ซึ่งผลลัพธ์ในผลลัพธ์เช่นนี้:

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 นั้นสร้างขึ้นในหน่วยความจำเป็นข้อมูลเฉพาะ B ก่อนตามด้วยวัตถุ A ที่ฝังตัว การstatic_castส่งคืนที่อยู่ของวัตถุ A ที่static_castถูกต้องและตัวชี้ที่สร้างขึ้นอย่างถูกต้องจะให้ค่าของเขตข้อมูล ตัวชี้ที่สร้างขึ้นโดยreinterpret_castใช้bหน่วยความจำของสถานที่ตั้งราวกับว่ามันเป็นวัตถุ A ธรรมดาและเมื่อตัวชี้พยายามรับเขตข้อมูลมันจะส่งคืนข้อมูลเฉพาะ B บางอย่างราวกับว่าเป็นเนื้อหาของเขตข้อมูลนี้

การใช้หนึ่งreinterpret_castคือการแปลงตัวชี้เป็นจำนวนเต็มที่ไม่ได้ลงชื่อ (เมื่อพอยน์เตอร์และจำนวนเต็มที่ไม่ได้ลงชื่อมีขนาดเท่ากัน):

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

คำตอบด่วน: ใช้static_castถ้ามันรวบรวมมิฉะนั้นหันไปreinterpret_castใช้

อ่านคำถามที่พบบ่อย ! การเก็บข้อมูล C ++ ใน C อาจมีความเสี่ยง

ใน C ++ ตัวชี้ไปยังวัตถุสามารถแปลงเป็นvoid *โดยไม่ต้องปลดเปลื้องใด ๆ แต่มันไม่เป็นความจริงเลย คุณต้องการ a static_castเพื่อให้ได้ตัวชี้ดั้งเดิมกลับมา