static_castඑදිරිව dynamic_castඑදිරිව reinterpret_castඅභ්‍යන්තරිකයන් පහත් / ඉහළ මට්ටමේ දර්ශනයක්
මෙම පිළිතුරේ දී, මට අවශ්ය වන්නේ මෙම යාන්ත්‍රණ තුන කොන්ක්‍රීට් උඩු යටිකුරු / පහත් උදාහරණයකින් සංසන්දනය කර ඒවා සංසන්දනය කරන ආකාරය පිළිබඳ ස්ථිර අවබෝධයක් ලබා දීම සඳහා යටි පොයින්ටර්ස් / මතකය / එකලස් කිරීම සඳහා කුමක් සිදුවේද යන්න විශ්ලේෂණය කිරීමයි.
මෙම කුලයන් වෙනස් වන්නේ කෙසේද යන්න පිළිබඳව මෙය හොඳ අවබෝධයක් ලබා දෙනු ඇතැයි මම විශ්වාස කරමි:
static_cast: එක් ලිපිනයක් ධාවන වේලාවේදී (අඩු ධාවන කාල බලපෑම) ඕෆ්සෙට් කරන අතර පහත වැටීමක් නිවැරදි දැයි ආරක්ෂිත පරීක්ෂා නොකරයි.
dyanamic_cast: ක්රියාත්මක වන වේලාවේදී එකම ලිපිනය ඕෆ්සෙට් static_castකරනවාද, එසේම 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තුළ මතක ව්යුහය අඩංගු වේB1B2 අභ්‍යන්තරව හා අභ්‍යන්තරව වීමයි .
එබැවින් අපි තීරණාත්මක නිගමනයකට එළඹෙමු:
උඩු යටිකුරු කළ හෝ පහත් වූ විට අවශ්ය වන්නේ දර්ශක අගය සම්පාදනය කරන වේලාවේ දන්නා අගයකින් මාරු කිරීමයි
මේ ආකාරයෙන්, Dමූලික වර්ගයේ අරාව වෙත ගිය විට , වාත්තු වර්ගය ඇත්ත වශයෙන්ම එම ඕෆ්සෙට් ගණනය කර B2මතකයේ වලංගු යැයි පෙනෙන දෙයක් පෙන්වා දෙයි :
b2s[1] = &d;
මේ සඳහා vtable ඇති බව හැර Dඒ වෙනුවට අතර B2, එබැවින් සියලු අථත්ය ඇමතුම් විනිවිදභාවයෙන් ක්‍රියා කරයි.
දැන්, අපට අවසාන වශයෙන් යතුරු ලියනය කිරීම සහ අපගේ සංයුක්ත උදාහරණය විශ්ලේෂණය කිරීම වෙත ආපසු යා හැකිය.
Stdout නිමැවුමෙන් අපට පෙනෙන්නේ:
&d 0x7fffffffc930
b2s[1] 0x7fffffffc940
එම නිසා, එහි static_castසිදු කර ඇති ව්‍යංගයෙන් D0x7fffffffc930 හි සම්පූර්ණ දත්ත ව්‍යුහයේ සිට 0x7fffffffc940 හි ඇති ඕෆ්සෙට් එක නිවැරදිව ගණනය කර B2ඇත. 0x7fffffffc930 සහ 0x7fffffffc940 අතර ඇති දේ B1දත්ත සහ vtable විය හැකි බව අපි අනුමාන කරමු .
පසුව, පහත් කොට ඇති කොටස් වල, අවලංගු ඒවා අසමත් වන්නේ කෙසේද සහ ඇයි යන්න තේරුම් ගැනීම දැන් පහසුය:
static_cast<D*>(b2s[0]) 0x7fffffffc910: සම්පාදකයා ටයිම් බයිට් 0x10 කින් ඉහළට ගොස් උත්සාහ කර බැලීමට උත්සාහ B2කරයිD
නමුත් නිසා b2s[0] එය නොවූ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 ආපසු එවන්න
- එසේ නොමැති නම්,
Dනොපවතින ස්ථානයට ළඟා වීමට 0x10 එයින් අඩු කරන්න
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)
පළමුව NULL චෙක්පතක් ඇති අතර, අයින්පුට් NULL නම් එය NULL ලබා දෙයි.
එසේ නොමැති නම්, එය RDX, RSI සහ RDI සහ ඇමතුම් වල යම් තර්ක විතර්ක කරයි __dynamic_cast.
මෙය තවදුරටත් විශ්ලේෂණය කිරීමට මට ඉවසීමක් නැත, නමුත් අනෙක් අය පැවසූ පරිදි, මෙය ක්රියාත්මක වීමට ඇති එකම ක්‍රමය __dynamic_castපන්ති ධූරාවලිය නියෝජනය කරන අතිරේක RTTI මතකයේ දත්ත ව්‍යුහයන් වෙත ප්‍රවේශ වීමයි.
එම නිසා එය B2එම වගුව සඳහා වන ප්‍රවේශයෙන් ආරම්භ විය යුතු අතර, ඒ සඳහා වන විචල්‍යතාවය සොයා ගන්නා තෙක් මෙම පන්ති ධූරාවලියෙහි ගමන් කරන්නD සිට typecast b2s[0].
නැවත අර්ථ නිරූපණය කිරීම මිල අධික විය හැක්කේ මේ නිසා ය! මෙතන ඇති පරිවර්තනය එක් නෞකාවක් ලප එහිදී උදාහරණයක් dynamic_castවෙත static_castසංකීර්ණ ව්යාපෘතිය 33% කින් ධාවන අඩු! .
reinterpret_cast<D*>(b2s[1]) 0x7fffffffc940මේ තැනැත්තා අපව අන්ධ ලෙස විශ්වාස කරයි: අපි කිව්වේ Dලිපිනයක් ඇති බවයිb2s[1] , සම්පාදකයා ඕෆ්සෙට් ගණනය කිරීම් නොකරන බවත්ය.
නමුත් මෙය වැරදියි, D ඇත්ත වශයෙන්ම 0x7fffffffc930 හි ඇති නිසා, 0x7fffffffc940 හි ඇති දෙය D තුළ ඇති B2 වැනි ව්‍යුහයයි! එබැවින් කුණු කූඩයට ප්‍රවේශ වේ.
-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)
අදාළ ප්‍රශ්න:
උබුන්ටු 18.04 amd64, GCC 7.4.0 හි පරීක්ෂා කරන ලදී.