C++
const कीवर्ड

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

• const टाइप myVariable = initial; // एक कास्ट चर घोषित करता है; बदला नहीं जा सकता
• const प्रकार और myReference = myVariable; // एक कांस्टेबल चर के संदर्भ में घोषणा करता है
• const प्रकार * myPointer = & myVariable; // एक पॉइंटर-टू-कॉन्स्टल की घोषणा करता है। सूचक बदल सकता है, लेकिन अंतर्निहित डेटा सदस्य को सूचक के माध्यम से नहीं बदला जा सकता है
• टाइप करें * const myPointer = & myVariable; // एक कास्ट पॉइंटर घोषित करता है। सूचक को कुछ और इंगित करने के लिए पुन: असाइन नहीं किया जा सकता है, लेकिन अंतर्निहित डेटा सदस्य को बदला जा सकता है
• const प्रकार * const myPointer = & myVariable; // एक कांस्ट्रेक्टर-टू-कास्ट की घोषणा करता है।

टिप्पणियों

कांस्टेबल स्थानीय चर

घोषणा और उपयोग।

// a is const int, so it can't be changed
const int a = 15;  
a = 12;           // Error: can't assign new value to const variable
a += 1;           // Error: can't assign new value to const variable

संदर्भ और संकेत की बाध्यता

int &b = a;       // Error: can't bind non-const reference to const variable
const int &c = a; // OK; c is a const reference

int *d = &a;      // Error: can't bind pointer-to-non-const to const variable
const int *e = &a // OK; e is a pointer-to-const

int f = 0;
e = &f;           // OK; e is a non-const pointer-to-const,
                  // which means that it can be rebound to new int* or const int*

*e = 1            // Error: e is a pointer-to-const which means that
                  // the value it points to can't be changed through dereferencing e

int *g = &f;
*g = 1;           // OK; this value still can be changed through dereferencing
                  // a pointer-not-to-const

कास्ट पॉइंटर्स

int a = 0, b = 2;

const int* pA = &a; // pointer-to-const. `a` can't be changed through this
int* const pB = &a; // const pointer. `a` can be changed, but this pointer can't.
const int* const pC = &a; // const pointer-to-const.

//Error: Cannot assign to a const reference
*pA = b;

pA = &b;

*pB = b;

//Error: Cannot assign to const pointer
pB = &b;

//Error: Cannot assign to a const reference
*pC = b;

//Error: Cannot assign to const pointer
pC = &b;

कांस्टेबल सदस्य कार्य

किसी वर्ग के सदस्य कार्यों को const घोषित किया जा सकता है, जो संकलक और भविष्य के पाठकों को बताता है कि यह फ़ंक्शन ऑब्जेक्ट को संशोधित नहीं करेगा:

class MyClass
{
private:
    int myInt_;
public:
    int myInt() const { return myInt_; }
    void setMyInt(int myInt) { myInt_ = myInt; }
};

एक const मेंबर फंक्शन में, this पॉइंटर प्रभावी रूप से const MyClass * बजाय const MyClass * का एक MyClass * । इसका मतलब है कि आप फ़ंक्शन के भीतर किसी भी सदस्य चर को नहीं बदल सकते हैं; संकलक एक चेतावनी का उत्सर्जन करेगा। तो setMyInt घोषित नहीं किया जा सका const ।

आप लगभग हमेशा के रूप में सदस्य कार्यों को चिह्नित करना चाहिए const जब संभव। केवल const मेम्बर फंक्शन्स को एक const MyClass पर बुलाया जा सकता है।

static विधियों को const घोषित नहीं किया जा सकता है। ऐसा इसलिए है क्योंकि एक स्थिर विधि एक वर्ग से संबंधित है और इसे ऑब्जेक्ट पर नहीं कहा जाता है; इसलिए यह ऑब्जेक्ट के आंतरिक चर को कभी भी संशोधित नहीं कर सकता है। अतः static विधियों को const घोषित करना निरर्थक होगा।

कॉन्स्टल और नॉन-कॉस्ट गेट्टर विधियों में कोड के दोहराव से बचना।

C ++ विधियों में जो केवल const योग्यता से भिन्न होती है, उसे ओवरलोड किया जा सकता है। कभी-कभी गटर के दो संस्करणों की आवश्यकता हो सकती है जो कुछ सदस्य के संदर्भ में लौटते हैं।

Foo को एक वर्ग बनाते हैं, जिसमें दो तरीके होते हैं जो समान संचालन करते हैं और प्रकार Bar ऑब्जेक्ट का संदर्भ देते हैं:

class Foo
{
public:
    Bar& GetBar(/* some arguments */)
    {
        /* some calculations */
        return bar;
    }
    
    const Bar& GetBar(/* some arguments */) const
    {
        /* some calculations */
        return bar;
    }

    // ...
};

उनके बीच एकमात्र अंतर यह है कि एक तरीका गैर-कॉन्स्टेबल है और एक नॉन-कॉस्ट रेफरेंस (जिसका उपयोग ऑब्जेक्ट को संशोधित करने के लिए किया जा सकता है) और दूसरा कॉन्स्टेबल है और कॉन्स्ट रेफरेंस रिटर्न करता है।

कोड दोहराव से बचने के लिए, एक विधि को दूसरे से कॉल करने का प्रलोभन है। हालाँकि, हम कॉन्स्टेबल से नॉन-कास्ट विधि नहीं कह सकते हैं। लेकिन हम नॉन-कास्ट से कॉन्स्ट विधि को कॉल कर सकते हैं। इसके लिए कांस्टेबल को हटाने के लिए 'const_cast' का उपयोग करना होगा।

समाधान है:

struct Foo
{
    Bar& GetBar(/*arguments*/)
    {
        return const_cast<Bar&>(const_cast<const Foo*>(this)->GetBar(/*arguments*/));
    }
    
    const Bar& GetBar(/*arguments*/) const
    {
        /* some calculations */
        return foo;
    }
};

उपरोक्त कोड में, हम का स्थिरांक संस्करण फोन GetBar गैर स्थिरांक से GetBar स्थिरांक प्रकार को यह कास्टिंग द्वारा: const_cast<const Foo*>(this) । चूँकि हम नॉन-कॉस्ट से कॉन्स्ट विधि को कहते हैं, ऑब्जेक्ट स्वयं नॉन-कॉस्ट है, और कॉस्ट को हटाने की अनुमति है।

निम्नलिखित अधिक पूर्ण उदाहरण की जाँच करें:

#include <iostream>

class Student
{
public:
    char& GetScore(bool midterm)
    {
        return const_cast<char&>(const_cast<const Student*>(this)->GetScore(midterm));
    }
    
    const char& GetScore(bool midterm) const
    {
        if (midterm)
        {
            return midtermScore;
        }
        else
        {
            return finalScore;
        }
    }
    
private:
    char midtermScore;
    char finalScore;
};

int main()
{
    // non-const object
    Student a; 
    // We can assign to the reference. Non-const version of GetScore is called
    a.GetScore(true) = 'B';
    a.GetScore(false) = 'A';
    
    // const object
    const Student b(a); 
    // We still can call GetScore method of const object,
    // because we have overloaded const version of GetScore
    std::cout << b.GetScore(true) << b.GetScore(false) << '\n'; 
}