C++
स्पष्ट प्रकार के रूपांतरण

परिचय

वाक्य - विन्यास

• सरल-प्रकार-निर्दिष्ट ( )
• सरल-प्रकार-निर्दिष्ट ( अभिव्यक्ति-सूची )
• सरल-प्रकार-निर्दिष्ट ब्रेडेड-इनिट-सूची
• टाइपनेम-स्पेसियर ( )
• टाइपनेम-स्पेसियर ( अभिव्यक्ति-सूची )
• टाइपनेम-स्पेसियर ब्रेडेड-इनिट- सूची
• dynamic_cast < टाइप-आईडी > ( अभिव्यक्ति )
• static_cast < टाइप-आईडी > ( अभिव्यक्ति )
• reinterpret_cast < टाइप-आईडी > ( अभिव्यक्ति )
• const_cast < टाइप-आईडी > ( अभिव्यक्ति )
• ( type-id ) कास्ट-एक्सप्रेशन

टिप्पणियों

व्युत्पन्न रूपांतरण का आधार

static_cast का उपयोग करके बेस क्लास के लिए एक पॉइंटर को पॉइंटर से व्युत्पन्न वर्ग में परिवर्तित किया जा सकता है। static_cast कोई रन-टाइम जाँच नहीं करता है और अपरिभाषित व्यवहार को जन्म दे सकता है जब सूचक वास्तव में वांछित प्रकार को इंगित नहीं करता है।

struct Base {};
struct Derived : Base {};
Derived d;
Base* p1 = &d;
Derived* p2 = p1;                        // error; cast required
Derived* p3 = static_cast<Derived*>(p1); // OK; p2 now points to Derived object
Base b;
Base* p4 = &b;
Derived* p5 = static_cast<Derived*>(p4); // undefined behaviour since p4 does not
                                         // point to a Derived object

इसी तरह, आधार वर्ग के संदर्भ को static_cast का उपयोग करके व्युत्पन्न वर्ग के संदर्भ में परिवर्तित किया जा सकता है।

struct Base {};
struct Derived : Base {};
Derived d;
Base& r1 = d;
Derived& r2 = r1;                        // error; cast required
Derived& r3 = static_cast<Derived&>(r1); // OK; r3 now refers to Derived object

यदि स्रोत प्रकार बहुरूपी है, तो dynamic_cast का उपयोग व्युत्पन्न रूपांतरण के लिए आधार बनाने के लिए किया जा सकता है। यह एक रन-टाइम जाँच करता है और अपरिभाषित व्यवहार उत्पन्न करने के बजाय विफलता ठीक होती है। सूचक मामले में, एक अशक्त सूचक विफलता पर वापस आ जाता है। संदर्भ मामले में, एक अपवाद प्रकार std::bad_cast की विफलता पर फेंका जाता है std::bad_cast (या std::bad_cast से प्राप्त एक वर्ग std::bad_cast )।

struct Base { virtual ~Base(); }; // Base is polymorphic
struct Derived : Base {};
Base* b1 = new Derived;
Derived* d1 = dynamic_cast<Derived*>(b1); // OK; d1 points to Derived object
Base* b2 = new Base;
Derived* d2 = dynamic_cast<Derived*>(b2); // d2 is a null pointer

कब्ज दूर करना

Const ऑब्जेक्ट के लिए एक पॉइंटर को const_cast कीवर्ड का उपयोग करके पॉइंटर को नॉन- const_cast ऑब्जेक्ट में परिवर्तित किया जा सकता है। यहां हम एक फ़ंक्शन को कॉल करने के लिए const_cast का उपयोग करते हैं जो कि const_cast सही नहीं है। यह केवल एक नॉन-कॉस्ट char* तर्क को स्वीकार करता है, भले ही यह सूचक के माध्यम से कभी नहीं लिखता है:

void bad_strlen(char*);
const char* s = "hello, world!";
bad_strlen(s);                    // compile error
bad_strlen(const_cast<char*>(s)); // OK, but it's better to make bad_strlen accept const char*

const_cast to reference type का उपयोग const_cast योग्य लैवल्यू को नॉन-कास्ट-योग्य वैल्यू में बदलने के लिए किया जा सकता है।

const_cast खतरनाक है क्योंकि यह C ++ प्रकार प्रणाली के लिए आपको एक कास्ट ऑब्जेक्ट को संशोधित करने से रोकने के लिए असंभव बनाता है। ऐसा करने से अपरिभाषित व्यवहार होता है।

const int x = 123;
int& mutable_x = const_cast<int&>(x);
mutable_x = 456; // may compile, but produces *undefined behavior*

धूर्त रूपांतरण टाइप करें

किसी ऑब्जेक्ट प्रकार के लिए एक पॉइंटर (सम्मान। संदर्भ) को reinterpret_cast का उपयोग करके किसी अन्य ऑब्जेक्ट प्रकार के लिए पॉइंटर (सम्मान। संदर्भ) में परिवर्तित किया जा सकता है। यह किसी भी निर्माता या रूपांतरण कार्यों को नहीं कहता है।

int x = 42;
char* p = static_cast<char*>(&x);      // error: static_cast cannot perform this conversion
char* p = reinterpret_cast<char*>(&x); // OK
*p = 'z';                              // maybe this modifies x (see below)

int x = 42;
char& r = reinterpret_cast<char&>(x);
const void* px = &x;
const void* pr = &r;
assert(px == pr); // should never fire

int x = 123;
unsigned int& r1 = reinterpret_cast<unsigned int&>(x);
int& r2 = reinterpret_cast<int&>(r1);
r2 = 456; // sets x to 456

reinterpret_cast उपयोग एक पॉइंटर-टू-डेटा-सदस्य प्रकार से दूसरे में बदलने के लिए, या एक पॉइंटर-टू-मेंबर-फ़ंक्शन प्रकार को दूसरे में बदलने के लिए भी किया जा सकता है।

reinterpret_cast उपयोग करना खतरनाक माना जाता है क्योंकि reinterpret_cast या संदर्भ के माध्यम से पढ़ने या लिखने के लिए reinterpret_cast उपयोग करके प्राप्त स्रोत और गंतव्य प्रकार असंबंधित होने पर अपरिभाषित व्यवहार को ट्रिगर कर सकते हैं।

सूचक और पूर्णांक के बीच रूपांतरण

ऑब्जेक्ट पॉइंटर ( void* सहित) या फ़ंक्शन पॉइंटर को reinterpret_cast उपयोग करके पूर्णांक प्रकार में परिवर्तित किया जा सकता है। यह केवल तभी संकलित करेगा जब गंतव्य का प्रकार काफी लंबा हो। परिणाम कार्यान्वयन-परिभाषित है और आम तौर पर सूचक को इंगित करने वाले मेमोरी में बाइट का संख्यात्मक पता देता है।

आमतौर पर, long या unsigned long किसी भी पॉइंटर मान को रखने के लिए पर्याप्त होती है, लेकिन यह मानक द्वारा गारंटी नहीं है।

इसी प्रकार, पूर्णांक प्रकार को सूचक प्रकार में परिवर्तित करने के लिए reinterpret_cast का उपयोग किया जा सकता है। फिर से परिणाम कार्यान्वयन-परिभाषित है, लेकिन पूर्णांक प्रकार के माध्यम से एक राउंड ट्रिप द्वारा अपरिवर्तित होने की गारंटी दी जाती है। मानक यह गारंटी नहीं देता है कि मान शून्य शून्य सूचक में परिवर्तित हो गया है।

void register_callback(void (*fp)(void*), void* arg); // probably a C API
void my_callback(void* x) {
    std::cout << "the value is: " << reinterpret_cast<long>(x); // will probably compile
}
long x;
std::cin >> x;
register_callback(my_callback,
                  reinterpret_cast<void*>(x)); // hopefully this doesn't lose information...

स्पष्ट कंस्ट्रक्टर या स्पष्ट रूपांतरण फ़ंक्शन द्वारा रूपांतरण

एक रूपांतरण जिसमें एक स्पष्ट कंस्ट्रक्टर या रूपांतरण फ़ंक्शन शामिल होता है, वह अंतर्निहित रूप से नहीं किया जा सकता है। हम अनुरोध कर सकते हैं कि रूपांतरण static_cast का उपयोग करके स्पष्ट रूप से किया जाए। इसका अर्थ प्रत्यक्ष आरंभीकरण के समान है, सिवाय इसके कि परिणाम एक अस्थायी है।

class C {
    std::unique_ptr<int> p;
  public:
    explicit C(int* p) : p(p) {}
};
void f(C c);
void g(int* p) {
    f(p);                 // error: C::C(int*) is explicit
    f(static_cast<C>(p)); // ok
    f(C(p));              // equivalent to previous line
    C c(p); f(c);         // error: C is not copyable
}

निष्प्राण रूपांतरण

static_cast किसी भी अंतर्निहित रूपांतरण का प्रदर्शन कर सकता है। static_cast का यह उपयोग कभी-कभी उपयोगी हो सकता है, जैसे कि निम्न उदाहरणों में:

• एक दीर्घवृत्त के लिए तर्क पारित करते समय, "अपेक्षित" तर्क प्रकार सांख्यिकीय रूप से ज्ञात नहीं होता है, इसलिए कोई अंतर्निहित रूपांतरण नहीं होगा।

  const double x = 3.14;
  printf("%d\n", static_cast<int>(x)); // prints 3
  // printf("%d\n", x); // undefined behaviour; printf is expecting an int here
  // alternative:
  // const int y = x; printf("%d\n", y);
  

  स्पष्ट प्रकार के रूपांतरण के बिना, एक double वस्तु को दीर्घवृत्त के पास भेजा जाएगा, और अपरिभाषित व्यवहार होगा।

• एक व्युत्पन्न वर्ग असाइनमेंट ऑपरेटर बेस क्लास असाइनमेंट ऑपरेटर को कॉल कर सकता है जैसे:

  struct Base { /* ... */ };
  struct Derived : Base {
      Derived& operator=(const Derived& other) {
          static_cast<Base&>(*this) = other;
          // alternative:
          // Base& this_base_ref = *this; this_base_ref = other;
      }
  };
  

एनम रूपांतरण

static_cast एक पूर्णांक या फ्लोटिंग पॉइंट प्रकार से एन्यूमरेशन प्रकार (चाहे स्कोप या अनकैप्ड) में परिवर्तित हो सकता है, और इसके विपरीत। यह गणन प्रकारों के बीच भी परिवर्तित हो सकता है।

• एक अंकगणित प्रकार से एक अंकगणितीय प्रकार में रूपांतरण एक अंतर्निहित रूपांतरण है; static_cast का उपयोग करना संभव है, लेकिन आवश्यक नहीं है।

• जब एक पूर्णांक या गणना प्रकार एक गणना प्रकार में परिवर्तित किया जाता है:

  • यदि मूल मान गंतव्य एनम की सीमा के भीतर है, तो इसका परिणाम यह है कि मूल्य। ध्यान दें कि यह मान सभी प्रगणकों के लिए असमान हो सकता है।
  • अन्यथा, परिणाम अनिर्दिष्ट है (<= C ++ 14) या अपरिभाषित (> = C ++ 17)।

  उदाहरण:

  enum Scale {
      SINGLE = 1,
      DOUBLE = 2,
      QUAD = 4
  };
  Scale s1 = 1;                     // error
  Scale s2 = static_cast<Scale>(2); // s2 is DOUBLE
  Scale s3 = static_cast<Scale>(3); // s3 has value 3, and is not equal to any enumerator
  Scale s9 = static_cast<Scale>(9); // unspecified value in C++14; UB in C++17
  

सदस्यों के लिए संकेत के आधार रूपांतरण के लिए व्युत्पन्न

व्युत्पन्न वर्ग के सदस्य के लिए एक सूचक को static_cast का उपयोग करके आधार वर्ग के सदस्य के लिए एक सूचक में परिवर्तित किया जा सकता है। मिलान करने के लिए इंगित किए गए प्रकार

यदि ऑपरेंड सदस्य मान के लिए अशक्त सूचक है, तो परिणाम भी सदस्य मान के लिए एक अशक्त सूचक है।

अन्यथा, रूपांतरण केवल तभी मान्य होता है, जब ऑपरेटर द्वारा इंगित सदस्य वास्तव में गंतव्य वर्ग में मौजूद होता है, या यदि गंतव्य वर्ग एक आधार या व्युत्पन्न वर्ग होता है, जिसमें संचालक द्वारा इंगित किए गए सदस्य होते हैं। static_cast वैधता के लिए जाँच नहीं करता है। यदि रूपांतरण मान्य नहीं है, तो व्यवहार अपरिभाषित है।

struct A {};
struct B { int x; };
struct C : A, B { int y; double z; };
int B::*p1 = &B::x;
int C::*p2 = p1;                              // ok; implicit conversion
int B::*p3 = p2;                              // error
int B::*p4 = static_cast<int B::*>(p2);       // ok; p4 is equal to p1
int A::*p5 = static_cast<int A::*>(p2);       // undefined; p2 points to x, which is a member
                                              // of the unrelated class B
double C::*p6 = &C::z;
double A::*p7 = static_cast<double A::*>(p6); // ok, even though A doesn't contain z
int A::*p8 = static_cast<int A::*>(p6);       // error: types don't match

शून्य * से T *

C ++ में, void* को स्पष्ट रूप से T* परिवर्तित नहीं किया जा सकता है, जहाँ T एक ऑब्जेक्ट प्रकार है। इसके बजाय, static_cast का उपयोग रूपांतरण को स्पष्ट रूप से करने के लिए किया जाना चाहिए। यदि ऑपरेंड वास्तव में एक T ऑब्जेक्ट को इंगित करता है, तो परिणाम उस ऑब्जेक्ट को इंगित करता है। अन्यथा, परिणाम अनिर्दिष्ट है।

// allocating an array of 100 ints, the hard way
int* a = malloc(100*sizeof(*a));                    // error; malloc returns void*
int* a = static_cast<int*>(malloc(100*sizeof(*a))); // ok
// int* a = new int[100];                           // no cast needed
// std::vector<int> a(100);                         // better

const char c = '!';
const void* p1 = &c;
const char* p2 = p1;                           // error
const char* p3 = static_cast<const char*>(p1); // ok; p3 points to c
const int* p4 = static_cast<const int*>(p1);   // unspecified in C++03;
                                               // possibly unspecified in C++11 if
                                               // alignof(int) > alignof(char)
char* p5 = static_cast<char*>(p1);             // error: casting away constness

सी-स्टाइल कास्टिंग

सी-स्टाइल कास्टिंग को 'सर्वश्रेष्ठ प्रयास' कास्टिंग माना जा सकता है और इसे नाम दिया गया है क्योंकि यह एकमात्र कास्ट है जिसे सी में इस्तेमाल किया जा सकता है। इस कलाकारों के लिए वाक्यविन्यास (NewType)variable ।

जब भी इस कास्ट का उपयोग किया जाता है, यह निम्न में से एक c ++ का उपयोग करता है (क्रम में):

• const_cast<NewType>(variable)
• static_cast<NewType>(variable)
• const_cast<NewType>(static_cast<const NewType>(variable))
• reinterpret_cast<const NewType>(variable)
• const_cast<NewType>(reinterpret_cast<const NewType>(variable))

कार्यात्मक कास्टिंग बहुत समान है, हालांकि इसके सिंटैक्स के परिणाम के रूप में कुछ प्रतिबंध: NewType(expression) । नतीजतन, बिना रिक्त स्थान के केवल प्रकार डाले जा सकते हैं।

नए c ++ कास्ट का उपयोग करना बेहतर है, क्योंकि अधिक पठनीय है और C ++ स्रोत कोड के अंदर कहीं भी आसानी से देखा जा सकता है और संकलन-समय में त्रुटियों का पता लगाया जाएगा, बजाय रन-टाइम में।

चूंकि यह कलाकार अनपेक्षित reinterpret_cast परिणामस्वरूप हो सकता है, इसलिए इसे अक्सर खतरनाक माना जाता है।