static_castবনাম dynamic_castবনাম reinterpret_castঅভ্যন্তরীণ একটি ডাউনকাস্ট / আপকাস্টে দেখুন
এই উত্তরে আমি এই তিনটি প্রক্রিয়াটিকে একটি কংক্রিট আপকাস্ট / ডাউনকাস্ট উদাহরণের সাথে তুলনা করতে চাই এবং বিশ্লেষণ করতে চাই যে অন্তর্নিহিত পয়েন্টার / মেমরি / অ্যাসেমব্লিকে কীভাবে তারা তুলনা করে তার একটি দৃ understanding় ধারণা দেয়।
আমি বিশ্বাস করি যে এই ক্যাসেটগুলি কীভাবে আলাদা সে সম্পর্কে এটি একটি ভাল অনুভূতি দেবে:
static_cast: রানটাইম এ অফসেট করে একটি ঠিকানা করে (কম রানটাইম প্রভাব) এবং কোনও সুরক্ষা চেক করে না যে ডাউনস্ট্রাকটি সঠিক কিনা।
dyanamic_cast: রানটাইমের সময় একই ঠিকানাটি অফসেট করে static_castতবে এটি এবং একটি ব্যয়বহুল সুরক্ষা পরীক্ষা করে দেখুন যে আরটিটিআই ব্যবহার করে একটি ডাউনকাস্ট সঠিক কিনা correct
এই সুরক্ষা চেক আপনাকে কোনও বেইস ক্লাস পয়েন্টার রানটাইমে প্রদত্ত ধরণের কিনা তা জিজ্ঞাসা করার অনুমতি দেয় 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.wikedia.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পরিবর্তে এই একটির পরিবর্তে এর জন্য vtable রয়েছে B2এবং তাই সমস্ত ভার্চুয়াল কল স্বচ্ছতার সাথে কাজ করে।
এখন, আমরা শেষ পর্যন্ত টাইপ করা কাস্টিং এবং আমাদের দৃ concrete় উদাহরণের বিশ্লেষণে ফিরে যেতে পারি।
স্টাডআউট আউটপুট থেকে আমরা দেখতে পাই:
&d 0x7fffffffc930
b2s[1] 0x7fffffffc940
অতএব, static_castসেখানে সম্পন্ন Dইমপ্লিট 0x7fffffffc930 এ পূর্ণ ডেটা স্ট্রাকচার থেকে 0x7fffffffc940 এর B2মতো একটিতে অফসেটটি সঠিকভাবে গণনা করেছে did আমরা এটিও নির্ধারণ করি যে 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)
সুতরাং আমরা দেখতে পাই যে জিসিসি তা করে:
- পয়েন্টারটি নুল কিনা, এবং হ্যাঁ যদি নুল ফিরে আসে তা পরীক্ষা করে দেখুন
- অন্যথায়, এটি থেকে পৌঁছানোর জন্য এটি থেকে 0x10 বিয়োগ করুন
Dযা বিদ্যমান নেই
dynamic_cast<D*>(b2s[0]) 0: সি ++ আসলে পাওয়া গেছে যে কাস্টটি অবৈধ এবং ফিরে এসেছে 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)
প্রথমে একটি নুল চেক আছে, এবং এটি যদি এনইউএল হয় তবে এটি নুল ফেরত দেয়।
অন্যথায়, এটি আরডিএক্স, আরএসআই এবং আরডিআই এবং কলগুলিতে কিছু যুক্তি সেট আপ করে __dynamic_cast।
এটিকে আরও বিশ্লেষণ করার মতো ধৈর্য আমার এখন নেই, তবে অন্যরা যেমন বলেছে, এটির কাজ করার একমাত্র উপায় হ'ল __dynamic_castকিছু অতিরিক্ত আরটিটিআই-তে মেমরির ডেটা স্ট্রাকচারগুলি অ্যাক্সেস করা যা শ্রেণি শ্রেণিবিন্যাসের প্রতিনিধিত্ব করে।
সুতরাং এটি অবশ্যই সেই B2টেবিলটির প্রবেশ থেকে শুরু হওয়া উচিত , তারপরে এই শ্রেণীর শ্রেণিবিন্যাসটি হাঁটা পর্যন্ত এটি কোনও Dটাইপকাস্টের ভিটিবেল না পাওয়া পর্যন্ত b2s[0]।
এই কারণেই পুনরায় ব্যাখ্যা কাস্ট সম্ভাব্য ব্যয়বহুল! এখানে একটি উদাহরণ যেখানে এক মাছ ধরার নৌকা প্যাচ একটি রূপান্তর dynamic_castএকটি থেকে static_castএকটি জটিল প্রকল্পে 33% দ্বারা রানটাইম লঘু! ।
reinterpret_cast<D*>(b2s[1]) 0x7fffffffc940এটি কেবল আমাদের অন্ধভাবে বিশ্বাস করে: আমরা বলেছিলাম একটি Dঠিকানা আছে b2s[1], এবং সংকলকটি অফসেট গণনা করে না।
তবে এটি ভুল, কারণ ডি আসলে 0x7fffffffc930 এ, 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)
সম্পর্কিত প্রশ্নাবলী:
উবুন্টু 18.04 amd64, জিসিসি 7.4.0 এ পরীক্ষিত।