static_castvs dynamic_castvs reinterpret_castinternal melihat pada downcast / upcast
Dalam jawaban ini, saya ingin membandingkan tiga mekanisme ini pada contoh konkret / downcast konkret dan menganalisis apa yang terjadi pada pointer / memori / perakitan yang mendasari untuk memberikan pemahaman konkret tentang bagaimana mereka membandingkan.
Saya percaya bahwa ini akan memberikan intuisi yang baik tentang bagaimana para pemain berbeda:
static_cast: apakah satu alamat offset pada saat runtime (dampak runtime rendah) dan tidak ada keamanan yang memeriksa bahwa downcast benar.
dyanamic_cast: apakah alamat yang sama diimbangi pada saat runtime suka static_cast, tetapi juga dan pemeriksaan keamanan yang mahal bahwa downcast benar menggunakan RTTI.
Pemeriksaan keamanan ini memungkinkan Anda untuk menanyakan apakah pointer kelas dasar adalah tipe yang diberikan saat runtime dengan memeriksa pengembalian nullptryang mengindikasikan downcast yang tidak valid.
Oleh karena itu, jika kode Anda tidak dapat memeriksa itu nullptrdan mengambil tindakan non-abort yang valid, Anda harus menggunakan static_castalih-alih pemeran dinamis.
Jika abort adalah satu-satunya tindakan yang dapat dilakukan oleh kode Anda, mungkin Anda hanya ingin mengaktifkan dynamic_castin debug builds ( -NDEBUG), dan gunakan static_castsebaliknya, mis. Seperti yang dilakukan di sini , untuk tidak memperlambat lari cepat Anda.
reinterpret_cast: tidak melakukan apa pun saat runtime, bahkan alamat tidak diimbangi. Pointer harus menunjuk tepat ke tipe yang benar, bahkan kelas dasar tidak berfungsi. Anda biasanya tidak menginginkan ini kecuali stream byte mentah terlibat.
Perhatikan contoh kode berikut:
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;
}
Kompilasi, jalankan, dan bongkar dengan:
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
mana setarchyang digunakan untuk ASLR menonaktifkan untuk membuatnya lebih mudah untuk membandingkan berjalan.
Output yang mungkin:
&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
Sekarang, seperti yang disebutkan di: https://en.wikipedia.org/wiki/Virtual_method_table untuk mendukung panggilan metode virtual secara efisien, struktur data memori Dharus terlihat seperti:
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
Fakta kuncinya adalah bahwa struktur data memori Dberisi di dalamnya struktur memori yang kompatibel dengan struktur internal B1dan B2internal.
Karena itu kami mencapai kesimpulan kritis:
upcast atau downcast hanya perlu menggeser nilai pointer dengan nilai yang diketahui pada waktu kompilasi
Dengan cara ini, ketika Dditeruskan ke array tipe dasar, pemeran tipe sebenarnya menghitung offset itu dan menunjukkan sesuatu yang tampak persis seperti yang valid B2dalam memori:
b2s[1] = &d;
kecuali bahwa ini memiliki vtable untuk Dbukan B2, dan karena itu semua panggilan virtual bekerja secara transparan.
Sekarang, kita akhirnya bisa kembali mengetik pengecoran dan analisis contoh konkret kami.
Dari output stdout kita melihat:
&d 0x7fffffffc930
b2s[1] 0x7fffffffc940
Oleh karena itu, implisit yang static_castdilakukan di sana benar menghitung offset dari Dstruktur data lengkap pada 0x7fffffffc930 ke yang B2sejenisnya yaitu pada 0x7fffffffc940. Kami juga menyimpulkan bahwa apa yang terletak antara 0x7fffffffc930 dan 0x7fffffffc940 kemungkinan adalah B1data dan vtable.
Kemudian, pada bagian yang tertekan, sekarang mudah untuk memahami bagaimana yang tidak valid gagal dan mengapa:
static_cast<D*>(b2s[0]) 0x7fffffffc910: kompiler baru saja naik 0x10 pada waktu kompilasi byte untuk mencoba dan pergi dari B2ke yang berisiD
Tetapi karena b2s[0]bukan D, itu sekarang menunjuk ke wilayah memori yang tidak ditentukan.
Pembongkarannya adalah:
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)
jadi kita melihat bahwa GCC tidak:
- periksa apakah pointer NULL, dan jika ya kembalikan NULL
- jika tidak, kurangi 0x10 dari itu untuk mencapai
Dyang tidak ada
dynamic_cast<D*>(b2s[0]) 0: C ++ sebenarnya menemukan bahwa para pemain tidak valid dan dikembalikan nullptr!
Tidak ada cara ini dapat dilakukan pada waktu kompilasi, dan kami akan mengkonfirmasi itu dari pembongkaran:
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)
Pertama ada cek NULL, dan mengembalikan NULL jika einput adalah NULL.
Kalau tidak, itu mengatur beberapa argumen dalam RDX, RSI dan RDI dan panggilan __dynamic_cast.
Saya tidak memiliki kesabaran untuk menganalisis ini lebih jauh sekarang, tetapi seperti yang orang lain katakan, satu-satunya cara agar ini bekerja adalah __dynamic_castdengan mengakses beberapa struktur data memori RTTI tambahan yang mewakili hirarki kelas.
Oleh karena itu harus dimulai dari B2entri untuk tabel itu, kemudian berjalan hirarki kelas ini sampai menemukan bahwa vtable untuk Dtypecast dari b2s[0].
Inilah sebabnya mengapa menafsirkan ulang pemain berpotensi mahal! Berikut adalah contoh di mana tambalan satu liner yang mengubah a dynamic_castmenjadistatic_cast dalam proyek kompleks mengurangi runtime sebesar 33%! .
reinterpret_cast<D*>(b2s[1]) 0x7fffffffc940yang ini hanya mempercayai kita secara membabi buta: kita mengatakan ada Dalamat b2s[1], dan kompiler tidak melakukan perhitungan offset.
Tapi ini salah, karena D sebenarnya di 0x7fffffffc930, apa yang ada di 0x7fffffffc940 adalah struktur seperti B2 di dalam D! Jadi sampah diakses.
Kami dapat mengkonfirmasi ini dari -O0majelis menghebohkan yang hanya memindahkan nilai sekitar:
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)
Pertanyaan-pertanyaan Terkait:
Diuji pada Ubuntu 18.04 amd64, GCC 7.4.0.