static_castबनाम dynamic_castबनाम reinterpret_castआंतरिक एक डाउनकास्ट / upcast पर देखें
इस उत्तर में, मैं इन तीन तंत्रों की तुलना एक ठोस अपकास्ट / डाउनकास्ट उदाहरण पर करता हूं और विश्लेषण करता हूं कि अंतर्निहित बिंदुओं / मेमोरी / असेंबली का क्या होता है, इसकी ठोस समझ देने के लिए कि वे कैसे तुलना करते हैं।
मेरा मानना है कि इससे उन जातियों के अलग होने का एक अच्छा अंतर्ज्ञान होगा:
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में आंतरिक मेमोरी शामिल होती B1है जो B2आंतरिक रूप से और उस के साथ संगत होती है ।
इसलिए हम महत्वपूर्ण निष्कर्ष पर पहुँचते हैं:
अपस्टॉक या डाउनकास्ट को केवल संकलक समय पर ज्ञात मूल्य द्वारा सूचक मान को स्थानांतरित करना होगा
इस प्रकार, जब Dबेस प्रकार सरणी में पास हो जाता है, तो टाइप कास्ट वास्तव में गणना करता है कि ऑफसेट और कुछ ऐसा दिखता है जो B2स्मृति में बिल्कुल मान्य जैसा दिखता है :
b2s[1] = &d;
सिवाय इसके कि Dइसके बजाय इसके लिए व्यवहार्य है B2, और इसलिए सभी आभासी कॉल पारदर्शी रूप से काम करते हैं।
अब, हम आखिरकार टाइपिंग कास्टिंग और हमारे ठोस उदाहरण के विश्लेषण के लिए वापस आ सकते हैं।
स्टडआउट आउटपुट से हम देखते हैं:
&d 0x7fffffffc930
b2s[1] 0x7fffffffc940
इसलिए, static_castवहां किए गए निहितार्थ ने D0x7fffffc930 पर पूर्ण डेटा संरचना से ऑफसेट की गणना ठीक उसी B2तरह की है जो 0x7fffffc940 पर है। हम यह भी अनुमान लगाते हैं कि 0x7fffffc930 और 0x7fffffffc940 के बीच जो निहित है, वह संभवतः B1डेटा और वाइब्रेट हो सकता है ।
फिर, डाउनकास्ट अनुभागों पर, अब यह समझना आसान है कि अमान्य कैसे विफल होते हैं और क्यों:
static_cast<D*>(b2s[0]) 0x7fffffffc910: कंपाइलर केवल 0x10 पर संकलित समय बाइट्स में कोशिश करने और एक B2से युक्त होने के लिए ऊपर चला गयाD
लेकिन क्योंकि b2s[0]यह नहीं था D, यह अब एक अपरिभाषित स्मृति क्षेत्र की ओर इशारा करता है।
Disassembly है:
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)
इसलिए हम देखते हैं कि जीसीसी करता है:
- जांचें कि क्या सूचक 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)
पहले एक NULL चैक होता है, और यह NULL लौटता है यदि वें einput NULL है।
अन्यथा, यह आरडीएक्स, आरएसआई और आरडीआई और कॉल में कुछ तर्क देता है __dynamic_cast।
मेरे पास अब इसे और अधिक विश्लेषण करने का धैर्य नहीं है, लेकिन जैसा कि अन्य ने कहा, इसके लिए काम करने का एकमात्र तरीका __dynamic_castकुछ अतिरिक्त आरटीटीआई-इन-मेमोरी डेटा संरचनाओं का उपयोग करना है जो वर्ग पदानुक्रम का प्रतिनिधित्व करते हैं।
इसलिए इसे B2उस तालिका के लिए प्रविष्टि से शुरू करना चाहिए , फिर इस वर्ग पदानुक्रम तक चलना चाहिए जब तक कि यह पता नहीं चलता कि Dटाइप टाइपकास्ट के लिए व्यवहार्य है b2s[0]।
यही कारण है कि पुनर्व्याख्या कास्ट संभावित रूप से महंगा है! यहाँ एक उदाहरण है जहाँ एक जटिल प्रक्रिया में एक में एक लाइनर पैच को परिवर्तित dynamic_castकरने से static_castरनटाइम में 33% की कमी आई है! ।
reinterpret_cast<D*>(b2s[1]) 0x7fffffffc940यह सिर्फ हमें आँख बंद करके विश्वास करता है: हमने कहा कि एक Dपते पर है b2s[1], और संकलक कोई ऑफसेट गणना नहीं करता है।
लेकिन यह गलत है, क्योंकि डी वास्तव में 0x7fffffc930 पर है, जो 0x7fffffffc940 पर है वह डी के अंदर बी 2 जैसी संरचना है! तो कचरा पहुंच जाता है।
हम इस भयावह -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 am6464, GCC 7.4.0 पर परीक्षण किया गया।