static_castvs dynamic_castvs reinterpret_castinternals ดูบน downcast / upcast
ในคำตอบนี้ฉันต้องการเปรียบเทียบกลไกทั้งสามนี้ในตัวอย่างที่เป็นรูปธรรม upcast / downcast และวิเคราะห์สิ่งที่เกิดขึ้นกับพอยน์เตอร์ / หน่วยความจำ / แอสเซมบลีพื้นฐานเพื่อให้เข้าใจอย่างเป็นรูปธรรมเกี่ยวกับวิธีเปรียบเทียบ
ฉันเชื่อว่าสิ่งนี้จะให้สัญชาตญาณที่ดีในการปลดเปลื้องเหล่านั้นแตกต่างกัน
static_cast: ทำการชดเชยหนึ่งแอดเดรสที่รันไทม์ (ผลกระทบจากรันไทม์ต่ำ) และไม่มีการตรวจสอบความปลอดภัยว่าดาวน์ไลท์นั้นถูกต้องหรือไม่
dyanamic_cast: ที่อยู่เดียวกันตรงข้ามกับรันไทม์เช่นstatic_castกัน แต่ยังรวมถึงการตรวจสอบด้านความปลอดภัยที่มีราคาแพงว่า downcast นั้นถูกต้องโดยใช้ RTTI
การตรวจสอบความปลอดภัยนี้ช่วยให้คุณสามารถสอบถามได้ว่าตัวชี้คลาสพื้นฐานเป็นประเภทที่กำหนดเมื่อใช้งานจริงหรือไม่โดยการตรวจสอบการส่งคืนnullptrซึ่งบ่งชี้ว่าการดาวน์สตรีมที่ไม่ถูกต้อง
ดังนั้นหากรหัสของคุณไม่สามารถตรวจสอบได้nullptrและดำเนินการไม่ยกเลิกที่ถูกต้องคุณควรใช้static_castแทนการส่งแบบไดนามิก
หากการยกเลิกเป็นการกระทำเดียวที่โค้ดของคุณสามารถทำได้คุณอาจต้องการเปิดใช้งานการdynamic_castดีบักบิวด์ ( -NDEBUG) และใช้static_castอย่างอื่นเช่นที่ทำที่นี่เพื่อไม่ให้การรันเร็วของคุณช้าลง
reinterpret_cast: ไม่ทำอะไรเลยขณะรันไทม์หรือแม้แต่ออฟเซ็ตที่อยู่ ตัวชี้ต้องชี้ไปที่ประเภทที่ถูกต้องไม่แม้แต่คลาสพื้นฐานทำงาน โดยทั่วไปคุณไม่ต้องการสิ่งนี้เว้นแต่ว่ามีการสตรีมข้อมูลดิบไบต์
พิจารณาตัวอย่างรหัสต่อไปนี้:
main.cpp
#include <iostream>
struct B1 {
B1(int int_in_b1) : int_in_b1(int_in_b1) {}
virtual ~B1() {}
void f0() {}
virtual int f1() { return 1; }
int int_in_b1;
};
struct B2 {
B2(int int_in_b2) : int_in_b2(int_in_b2) {}
virtual ~B2() {}
virtual int f2() { return 2; }
int int_in_b2;
};
struct D : public B1, public B2 {
D(int int_in_b1, int int_in_b2, int int_in_d)
: B1(int_in_b1), B2(int_in_b2), int_in_d(int_in_d) {}
void d() {}
int f2() { return 3; }
int int_in_d;
};
int main() {
B2 *b2s[2];
B2 b2{11};
D *dp;
D d{1, 2, 3};
// The memory layout must support the virtual method call use case.
b2s[0] = &b2;
// An upcast is an implicit static_cast<>().
b2s[1] = &d;
std::cout << "&d " << &d << std::endl;
std::cout << "b2s[0] " << b2s[0] << std::endl;
std::cout << "b2s[1] " << b2s[1] << std::endl;
std::cout << "b2s[0]->f2() " << b2s[0]->f2() << std::endl;
std::cout << "b2s[1]->f2() " << b2s[1]->f2() << std::endl;
// Now for some downcasts.
// Cannot be done implicitly
// error: invalid conversion from ‘B2*’ to ‘D*’ [-fpermissive]
// dp = (b2s[0]);
// Undefined behaviour to an unrelated memory address because this is a B2, not D.
dp = static_cast<D*>(b2s[0]);
std::cout << "static_cast<D*>(b2s[0]) " << dp << std::endl;
std::cout << "static_cast<D*>(b2s[0])->int_in_d " << dp->int_in_d << std::endl;
// OK
dp = static_cast<D*>(b2s[1]);
std::cout << "static_cast<D*>(b2s[1]) " << dp << std::endl;
std::cout << "static_cast<D*>(b2s[1])->int_in_d " << dp->int_in_d << std::endl;
// Segfault because dp is nullptr.
dp = dynamic_cast<D*>(b2s[0]);
std::cout << "dynamic_cast<D*>(b2s[0]) " << dp << std::endl;
//std::cout << "dynamic_cast<D*>(b2s[0])->int_in_d " << dp->int_in_d << std::endl;
// OK
dp = dynamic_cast<D*>(b2s[1]);
std::cout << "dynamic_cast<D*>(b2s[1]) " << dp << std::endl;
std::cout << "dynamic_cast<D*>(b2s[1])->int_in_d " << dp->int_in_d << std::endl;
// Undefined behaviour to an unrelated memory address because this
// did not calculate the offset to get from B2* to D*.
dp = reinterpret_cast<D*>(b2s[1]);
std::cout << "reinterpret_cast<D*>(b2s[1]) " << dp << std::endl;
std::cout << "reinterpret_cast<D*>(b2s[1])->int_in_d " << dp->int_in_d << std::endl;
}
รวบรวมเรียกใช้และถอดแยกชิ้นส่วนด้วย:
g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp
setarch `uname -m` -R ./main.out
gdb -batch -ex "disassemble/rs main" main.out
ที่setarchจะใช้ในการปิดการใช้งาน ASLRเพื่อให้ง่ายต่อการเปรียบเทียบการทำงาน
เอาต์พุตที่เป็นไปได้:
&d 0x7fffffffc930
b2s[0] 0x7fffffffc920
b2s[1] 0x7fffffffc940
b2s[0]->f2() 2
b2s[1]->f2() 3
static_cast<D*>(b2s[0]) 0x7fffffffc910
static_cast<D*>(b2s[0])->int_in_d 1
static_cast<D*>(b2s[1]) 0x7fffffffc930
static_cast<D*>(b2s[1])->int_in_d 3
dynamic_cast<D*>(b2s[0]) 0
dynamic_cast<D*>(b2s[1]) 0x7fffffffc930
dynamic_cast<D*>(b2s[1])->int_in_d 3
reinterpret_cast<D*>(b2s[1]) 0x7fffffffc940
reinterpret_cast<D*>(b2s[1])->int_in_d 32767
ตอนนี้ดังที่กล่าวไว้ที่: https://en.wikipedia.org/wiki/Virtual_method_tableเพื่อสนับสนุนการเรียกใช้เมธอดเสมือนอย่างมีประสิทธิภาพโครงสร้างข้อมูลหน่วยความจำของDต้องมีลักษณะดังนี้:
B1:
+0: pointer to virtual method table of B1
+4: value of int_in_b1
B2:
+0: pointer to virtual method table of B2
+4: value of int_in_b2
D:
+0: pointer to virtual method table of D (for B1)
+4: value of int_in_b1
+8: pointer to virtual method table of D (for B2)
+12: value of int_in_b2
+16: value of int_in_d
ความจริงที่สำคัญคือโครงสร้างข้อมูลของหน่วยความจำDที่มีอยู่ข้างในโครงสร้างหน่วยความจำที่เข้ากันได้กับที่ของB1และของB2ภายใน
ดังนั้นเราถึงข้อสรุปที่สำคัญ:
upcast หรือ downcast เพียงต้องการเปลี่ยนค่าตัวชี้โดยค่าที่รู้จักในเวลารวบรวม
ด้วยวิธีนี้เมื่อDถูกส่งผ่านไปยังอาเรย์ประเภทฐานนักแสดงประเภทจะคำนวณว่าออฟเซ็ตและชี้บางสิ่งที่ดูเหมือนว่าถูกต้องB2ในหน่วยความจำ:
b2s[1] = &d;
ยกเว้นว่าอันนี้มี vtable สำหรับDแทนB2และดังนั้นการโทรเสมือนทั้งหมดทำงานอย่างโปร่งใส
ตอนนี้ในที่สุดเราก็สามารถกลับไปพิมพ์แบบหล่อและวิเคราะห์ตัวอย่างที่เป็นรูปธรรมของเราได้
จากเอาต์พุต stdout เราเห็น:
&d 0x7fffffffc930
b2s[1] 0x7fffffffc940
ดังนั้นการstatic_castกระทำโดยปริยายจึงทำการคำนวณออฟเซ็ตจากDโครงสร้างข้อมูลแบบเต็มอย่างถูกต้องที่ 0x7fffffffc930 ไปยังสิ่งที่B2คล้ายกันซึ่งอยู่ที่ 0x7fffffffcc940 นอกจากนี้เรายังอนุมานว่าสิ่งที่อยู่ระหว่าง 0x7fffffffc930 และ 0x7fffffffc940 นั้นน่าจะเป็นB1ข้อมูลและ vtable
จากนั้นในส่วน downcast ตอนนี้มันง่ายที่จะเข้าใจว่าสิ่งที่ไม่ถูกต้องล้มเหลวและทำไม:
static_cast<D*>(b2s[0]) 0x7fffffffc910: คอมไพเลอร์เพิ่งเพิ่มขึ้น 0x10 ที่ไบต์เวลารวบรวมเพื่อลองจากB2ไปยังที่มีD
แต่เนื่องจากb2s[0]ไม่ใช่ a Dตอนนี้จึงชี้ไปยังขอบเขตหน่วยความจำที่ไม่ได้กำหนด
ถอดชิ้นส่วนคือ:
49 dp = static_cast<D*>(b2s[0]);
0x0000000000000fc8 <+414>: 48 8b 45 d0 mov -0x30(%rbp),%rax
0x0000000000000fcc <+418>: 48 85 c0 test %rax,%rax
0x0000000000000fcf <+421>: 74 0a je 0xfdb <main()+433>
0x0000000000000fd1 <+423>: 48 8b 45 d0 mov -0x30(%rbp),%rax
0x0000000000000fd5 <+427>: 48 83 e8 10 sub $0x10,%rax
0x0000000000000fd9 <+431>: eb 05 jmp 0xfe0 <main()+438>
0x0000000000000fdb <+433>: b8 00 00 00 00 mov $0x0,%eax
0x0000000000000fe0 <+438>: 48 89 45 98 mov %rax,-0x68(%rbp)
ดังนั้นเราจึงเห็นว่า GCC ทำ:
- ตรวจสอบว่าตัวชี้เป็น NULL และถ้าใช่คืน NULL
- ไม่เช่นนั้นให้ลบ 0x10 จากนั้นถึงสิ่ง
Dที่ไม่มีอยู่
dynamic_cast<D*>(b2s[0]) 0: C ++ พบจริงว่าตัวละครนั้นไม่ถูกต้องและกลับมาแล้วnullptr!
ไม่มีวิธีนี้สามารถทำได้ในเวลารวบรวมและเราจะยืนยันว่าจากการถอดชิ้นส่วน:
59 dp = dynamic_cast<D*>(b2s[0]);
0x00000000000010ec <+706>: 48 8b 45 d0 mov -0x30(%rbp),%rax
0x00000000000010f0 <+710>: 48 85 c0 test %rax,%rax
0x00000000000010f3 <+713>: 74 1d je 0x1112 <main()+744>
0x00000000000010f5 <+715>: b9 10 00 00 00 mov $0x10,%ecx
0x00000000000010fa <+720>: 48 8d 15 f7 0b 20 00 lea 0x200bf7(%rip),%rdx # 0x201cf8 <_ZTI1D>
0x0000000000001101 <+727>: 48 8d 35 28 0c 20 00 lea 0x200c28(%rip),%rsi # 0x201d30 <_ZTI2B2>
0x0000000000001108 <+734>: 48 89 c7 mov %rax,%rdi
0x000000000000110b <+737>: e8 c0 fb ff ff callq 0xcd0 <__dynamic_cast@plt>
0x0000000000001110 <+742>: eb 05 jmp 0x1117 <main()+749>
0x0000000000001112 <+744>: b8 00 00 00 00 mov $0x0,%eax
0x0000000000001117 <+749>: 48 89 45 98 mov %rax,-0x68(%rbp)
ครั้งแรกที่มีการตรวจสอบเป็นโมฆะและมันกลับเป็นโมฆะถ้า einput ที่เป็นโมฆะ
มิฉะนั้นจะตั้งค่าการขัดแย้งบางอย่างใน RDX, RSI และ RDI __dynamic_castและบริการโทร
ฉันไม่มีความอดทนที่จะวิเคราะห์สิ่งนี้เพิ่มเติมในขณะนี้ แต่อย่างที่คนอื่นพูดวิธีเดียวที่จะใช้งานได้คือ__dynamic_castการเข้าถึงโครงสร้างข้อมูลในหน่วยความจำ RTTI พิเศษที่แสดงถึงลำดับชั้นของชั้นเรียน
ดังนั้นจึงต้องเริ่มต้นจากB2รายการสำหรับตารางที่แล้วเดินลำดับชั้นนี้จนกว่าจะพบว่า vtable สำหรับDtypecast b2s[0]จาก
นี่คือเหตุผลที่นักแปลตีความซ้ำอาจมีราคาแพง! ที่นี่คือตัวอย่างที่แพทช์ซับหนึ่งแปลง a dynamic_castเป็น a static_castในโปรเจ็กต์ที่ซับซ้อนลดรันไทม์ 33%! .
reinterpret_cast<D*>(b2s[1]) 0x7fffffffc940อันนี้แค่เชื่อว่าเราสุ่มสี่สุ่มห้า: เราบอกว่ามีDที่อยู่b2s[1]และคอมไพเลอร์ไม่มีการคำนวณออฟเซ็ต
แต่นี่เป็นสิ่งที่ผิดเพราะ D จริงๆแล้วที่ 0x7fffffffc930 สิ่งที่อยู่ที่ 0x7fffffffc940 คือโครงสร้าง B2 ที่เหมือนภายใน D! ดังนั้นการเข้าถึงถังขยะ
เราสามารถยืนยันสิ่งนี้จากความสยดสยอง -O0ชุมนุมที่ที่เพิ่งจะย้ายค่าไปรอบ ๆ :
70 dp = reinterpret_cast<D*>(b2s[1]);
0x00000000000011fa <+976>: 48 8b 45 d8 mov -0x28(%rbp),%rax
0x00000000000011fe <+980>: 48 89 45 98 mov %rax,-0x68(%rbp)
คำถามที่เกี่ยวข้อง:
ทดสอบกับ Ubuntu 18.04 amd64, GCC 7.4.0