static_castđấu dynamic_castvớireinterpret_cast nội bộ xem trên một downcast / upcast
Trong câu trả lời này, tôi muốn so sánh ba cơ chế này trên một ví dụ upcast / downcast cụ thể và phân tích những gì xảy ra với các con trỏ / bộ nhớ / lắp ráp cơ bản để đưa ra một sự hiểu biết cụ thể về cách chúng so sánh.
Tôi tin rằng điều này sẽ mang đến một trực giác tốt về cách các diễn viên đó khác nhau:
static_cast: có một địa chỉ bù vào thời gian chạy (tác động thời gian chạy thấp) và không có kiểm tra an toàn nào cho thấy một downcast là chính xác.
dyanamic_cast: thực hiện cùng một địa chỉ bù vào thời gian chạy như thế nào static_cast, nhưng cũng như một kiểm tra an toàn đắt tiền rằng một downcast là chính xác bằng RTTI.
Kiểm tra an toàn này cho phép bạn truy vấn nếu một con trỏ lớp cơ sở thuộc loại đã cho trong thời gian chạy bằng cách kiểm tra trả về trong nullptrđó chỉ ra một downcast không hợp lệ.
Do đó, nếu mã của bạn không thể kiểm tra điều đó nullptrvà thực hiện hành động không hủy bỏ hợp lệ, bạn chỉ nên sử dụng static_castthay vì truyền động.
Nếu hủy bỏ là hành động duy nhất mà mã của bạn có thể thực hiện, có thể bạn chỉ muốn kích hoạt các dynamic_castbản dựng gỡ lỗi ( -NDEBUG) và sử dụng static_castkhác, ví dụ như được thực hiện ở đây , để không làm chậm quá trình chạy nhanh của bạn.
reinterpret_cast: không làm gì trong thời gian chạy, thậm chí không bù địa chỉ. Con trỏ phải trỏ chính xác đến đúng loại, thậm chí không có lớp cơ sở hoạt động. Bạn thường không muốn điều này trừ khi các luồng byte thô có liên quan.
Xem xét ví dụ mã sau:
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;
}
Biên dịch, chạy và tháo rời với:
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
nơi setarchđược sử dụng để vô hiệu hóa ASLR để giúp so sánh các lần chạy dễ dàng hơn.
Sản lượng có thể:
&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
Bây giờ, như đã đề cập tại: https://en.wikipedia.org/wiki/Virtual_method_table để hỗ trợ các cuộc gọi phương thức ảo một cách hiệu quả, cấu trúc dữ liệu bộ nhớ Dphải trông giống như:
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
Thực tế quan trọng là cấu trúc dữ liệu bộ nhớ Dchứa bên trong cấu trúc bộ nhớ tương thích với cấu trúc bộ nhớ trong B1và B2bên trong.
Vì vậy, chúng tôi đi đến kết luận quan trọng:
một upcast hoặc downcast chỉ cần thay đổi giá trị con trỏ theo một giá trị được biết tại thời điểm biên dịch
Theo cách này, khi Dđược chuyển đến mảng loại cơ sở, kiểu cast thực sự tính toán phần bù đó và chỉ ra thứ gì đó trông giống hệt như một giá trị B2trong bộ nhớ:
b2s[1] = &d;
ngoại trừ việc cái này có vtable Dthay cho B2, và do đó tất cả các cuộc gọi ảo hoạt động trong suốt.
Bây giờ, cuối cùng chúng ta có thể quay lại kiểu đúc và phân tích ví dụ cụ thể của chúng ta.
Từ đầu ra tiêu chuẩn, chúng ta thấy:
&d 0x7fffffffc930
b2s[1] 0x7fffffffc940
Do đó, ẩn static_castđược thực hiện ở đó đã tính toán chính xác phần bù từ Dcấu trúc dữ liệu đầy đủ tại 0x7fffffffc930 đến mức B2tương tự ở mức 0x7fffffffc940. Chúng tôi cũng suy luận rằng những gì nằm giữa 0x7fffffffc930 và 0x7fffffffc940 có thể là B1dữ liệu và vtable.
Sau đó, trên các phần downcast, giờ đây thật dễ hiểu làm thế nào những phần không hợp lệ thất bại và tại sao:
static_cast<D*>(b2s[0]) 0x7fffffffc910: trình biên dịch chỉ tăng 0x10 tại các byte thời gian biên dịch để thử và chuyển từ a B2sang chứaD
Nhưng vì b2s[0]không phải là mộtD nên giờ nó chỉ đến một vùng nhớ không xác định.
Việc tháo gỡ là:
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)
vì vậy chúng tôi thấy rằng GCC không:
- kiểm tra xem con trỏ có phải là NULL không và nếu có trả về NULL
- mặt khác, trừ 0x10 từ nó để đạt đến
Dcái không tồn tại
dynamic_cast<D*>(b2s[0]) 0: C ++ thực sự thấy rằng dàn diễn viên không hợp lệ và được trả lại nullptr!
Không có cách nào có thể được thực hiện tại thời điểm biên dịch và chúng tôi sẽ xác nhận điều đó từ quá trình tháo gỡ:
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)
Đầu tiên, có một kiểm tra NULL và nó trả về NULL nếu thông số đó là NULL.
Mặt khác, nó thiết lập một số đối số trong RDX, RSI và RDI và các cuộc gọi __dynamic_cast.
Bây giờ tôi không đủ kiên nhẫn để phân tích vấn đề này, nhưng như những người khác đã nói, cách duy nhất để làm việc này là __dynamic_casttruy cập vào một số cấu trúc dữ liệu trong bộ nhớ RTTI đại diện cho hệ thống phân cấp lớp.
Do đó, nó phải bắt đầu từ B2mục nhập cho bảng đó, sau đó đi theo cấu trúc phân cấp lớp này cho đến khi nhận thấy rằng vtable cho một Dkiểu chữ từb2s[0] .
Đây là lý do tại sao diễn viên reinterpret có khả năng đắt tiền! Dưới đây là một ví dụ trong đó một bản vá lót chuyển đổi dynamic_castthành một static_casttrong một dự án phức tạp đã giảm 33% thời gian chạy! .
reinterpret_cast<D*>(b2s[1]) 0x7fffffffc940Điều này chỉ tin tưởng chúng tôi một cách mù quáng: chúng tôi đã nói rằng có một Dđịa chỉ b2s[1]và trình biên dịch không tính toán bù.
Nhưng điều này là sai, bởi vì D thực sự ở 0x7fffffffc930, ở 0x7fffffffc940 là cấu trúc giống như B2 bên trong D! Vì vậy, rác được truy cập.
Chúng tôi có thể xác nhận điều này từ -O0hội đồng khủng khiếp chỉ di chuyển giá trị xung quanh:
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)
Câu hỏi liên quan:
Đã thử nghiệm trên Ubuntu 18.04 amd64, GCC 7.4.0.