विषय पर बढ़ें

अंतिम अद्यतन：2026-10-12

C++ mutable कीवर्ड

C++ के mutable कीवर्ड पर गहरी चर्चा

C++ में, mutable कीवर्ड को अक्सर const सीमा को "穿透" (penetrate) करने वाला टूल माना जाता है। कुछ स्थितियों में, भले हम किसी ऑब्जेक्ट पर const सुरक्षा लागू करना चाहते हैं, फिर भी उस ऑब्जेक्ट के कुछ डेटा मेंबर्स को बदलने की ज़रूरत होती है। यह लेख mutable के उपयोग के केस और उसके पीछे की डिज़ाइन फ़िलॉसफ़ी पर विस्तार से चर्चा करेगा और बताएगा कि यह C++ में विशेष प्रोग्रामिंग ज़रूरतों को कैसे हल करता है।

1. mutable कीवर्ड का बुनियादी उपयोग

हम जानते हैं कि जब कोई मेंबर फ़ंक्शन const qualifier के साथ लिखा जाता है, तो वह मेंबर फ़ंक्शन ऑब्जेक्ट की स्थिति न बदलने की गारंटी देता है। हालाँकि, व्यावहारिक प्रोग्रामिंग में कभी-कभी हम एक डेटा मेंबर को बदलना चाहते हैं, लेकिन साथ ही मेंबर फ़ंक्शन को const ही रखना चाहते हैं। यही mutable कीवर्ड का काम है:

class Foo  
{  
private:  
    mutable bool done_;  
public:  
    void doSomething() const {
        // 在 const 成员函数中修改 mutable 成员
        done_ = true;
    }  
};

उपरोक्त उदाहरण में, doSomething() को const घोषित किया गया है, जो दर्शाता है कि यह ऑब्जेक्ट की स्थिति नहीं बदलेगा। लेकिन done_ को mutable चिह्नित किया गया है, जिसका मतलब है कि const मेथड में भी हम done_ को बदल सकते हैं। यह डिज़ाइन हमें फ़ंक्शन इंटरफ़ेस की semantics वैसी ही रखते हुए कुछ बदलने योग्य डेटा को मैनेज करने देता है।

2. लॉजिकल const-ness vs. बिटवाइज़ const-ness

C++ में const-ness दो श्रेणियों में बाँटी जा सकती है: लॉजिकल const-ness और बिटवाइज़ const-ness। लॉजिकल const-ness का मतलब है कि बाहर से देखने पर ऑब्जेक्ट की स्थिति नहीं बदली, जबकि बिटवाइज़ const-ness का मतलब है कि मेमोरी में ऑब्जेक्ट का बिट डेटा वैसा ही रहा। mutable कीवर्ड हमें लॉजिकल const-ness परिभाषित करने देता है, यानी भले ही ऑब्जेक्ट का कुछ आंतरिक डेटा बदल गया हो, लॉजिकल रूप से ऑब्जेक्ट की स्थिति में कोई दिखने योग्य बदलाव नहीं हुआ।

जैसे एक thread-safe क्लास में हम डेटा एक्सेस की सुरक्षा के लिए boost::mutex का उपयोग कर सकते हैं। const मेथड में लॉक लेने के लिए हम mutex को mutable घोषित कर सकते हैं:

class ThreadSafeClass {
private:
    mutable std::mutex mtx_;
    int data_;
public:
    int getData() const {
        std::lock_guard<std::mutex> lock(mtx_);
        return data_;
    }
};

उपरोक्त उदाहरण में, भले ही getData मेथड const घोषित है, डेटा एक्सेस की thread सुरक्षा के लिए हमें लॉक की ज़रूरत है। इसलिए हमने mtx_ को mutable घोषित किया, ताकि const मेथड में इसे बदला जा सके। ऐसी स्थिति में हम कहते हैं कि क्लास की लॉजिकल स्थिति नहीं बदली, बदलाव सिर्फ़ thread सुरक्षा सुनिश्चित करने के लिए किया गया है।

3. Lambda एक्सप्रेशन में mutable

C++11 से mutable का उपयोग lambda एक्सप्रेशन में भी हो सकता है, ताकि by-value कैप्चर किए गए वेरिएबल्स को बदला जा सके। डिफ़ॉल्ट रूप से lambda में by-value कैप्चर किए वेरिएबल्स immutable होते हैं। अगर lambda में कैप्चर किए वेरिएबल को बदलने की ज़रूरत हो, तो mutable का उपयोग करें:

int x = 0;
auto f1 = [=]() mutable { x = 42; };  // OK: 可以修改捕获的 x
auto f2 = [=]() { x = 42; };  // Error: 按值捕获的变量不能被修改

ऐसी स्थिति में, mutable हमें फ़ंक्शन बॉडी में कैप्चर किए वेरिएबल को बदलने देता है, बाहरी वेरिएबल की वैल्यू पर बिना असर के।

4. const_cast से बचना

mutable कीवर्ड के बिना, हमें इन विशेष स्थितियों से निपटने के लिए const_cast का उपयोग करना पड़ सकता है। const_cast ऑब्जेक्ट की const-ness हटा सकता है, लेकिन इसकी कमियाँ भी हैं: const_cast const सुरक्षा को पूरी तरह हटा सकता है, जिससे हम ऑब्जेक्ट में मनमर्ज़ी से बदलाव और मेथड कॉल कर सकते हैं, जिससे कोड की पठनीयता और सुरक्षा घटती है।

इसके मुकाबले mutable कीवर्ड ज़्यादा fine-grained नियंत्रण देता है। mutable के ज़रिए हम खास डेटा मेंबर्स पर "अपवाद" लगा सकते हैं, जिससे उन्हें const मेथड में बदला जा सकता है, पूरे ऑब्जेक्ट की const-ness हटाए बिना। इसलिए mutable इन विशेष मामलों को ज़्यादा सुरक्षित तरीके से संभालता है।

5. mutable का उपयोग करने की डिज़ाइन फ़िलॉसफ़ी

mutable कीवर्ड की डिज़ाइन फ़िलॉसफ़ी इंटरफ़ेस की लॉजिकल const-ness बनाए रखने में है। ज़्यादातर मामलों में हम const-correct कोड लिखना चाहते हैं, जिसका मतलब है कि स्पष्ट रूप से बदले बिना ऑब्जेक्ट की स्थिति नहीं बदलती। mutable हमें कुछ आंतरिक इम्प्लीमेंटेशन में लचीलापन देता है, जैसे caching, रेफ़रेंस काउंटिंग, डिबग जानकारी आदि, बिना इंटरफ़ेस डिज़ाइन की निरंतरता तोड़े।

इंटरफ़ेस डिज़ाइन करते समय हमें स्पष्ट होना चाहिए कि कब और क्यों किसी ऑब्जेक्ट की स्थिति बदलने की ज़रूरत है। mutable कीवर्ड कोड को लॉजिकल स्तर पर अपरिवर्तित रखता है और साथ ही खास डेटा मेंबर्स को बदलने की क्षमता देता है। इसके लिए डिज़ाइनर की गहरी सोच चाहिए, यह सुनिश्चित करते हुए कि mutable का उपयोग ऑब्जेक्ट की const-ness कॉन्सेप्ट को न तोड़े, और इसका उपयोग केवल सचमुच ज़रूरी स्थितियों में हो।

6.रेफ़रेंस

https://stackoverflow.com/questions/105014/does-the-mutable-keyword-have-any-purpose-other-than-allowing-a-data-member-to

संबंधित विषय

टिप्पणियाँ