C++
परिवर्तनशील खोजशब्द

गैर-स्थिर वर्ग सदस्य संशोधक

इस संदर्भ में mutable संशोधक का उपयोग यह इंगित करने के लिए किया जाता है कि वस्तु के बाह्य-दृश्य स्थिति को प्रभावित किए बिना किसी कांस्टेबल ऑब्जेक्ट के डेटा फ़ील्ड को संशोधित किया जा सकता है।

यदि आप महंगी गणना के परिणामस्वरूप कैशिंग के बारे में सोच रहे हैं, तो आपको शायद इस कीवर्ड का उपयोग करना चाहिए।

यदि आपके पास एक लॉक (उदाहरण के लिए, std::unique_lock ) डेटा फ़ील्ड है जो एक std::unique_lock विधि के अंदर लॉक और अनलॉक है, तो यह कीवर्ड वह भी है जिसका आप उपयोग कर सकते हैं।

आपको इस कीवर्ड का उपयोग किसी ऑब्जेक्ट के तार्किक कॉन्स्टेंस-नेस को तोड़ने के लिए नहीं करना चाहिए।

कैशिंग के साथ उदाहरण:

class pi_calculator {
 public:
     double get_pi() const {
         if (pi_calculated) {
             return pi;
         } else {
             double new_pi = 0;
             for (int i = 0; i < 1000000000; ++i) {
                 // some calculation to refine new_pi
             }
             // note: if pi and pi_calculated were not mutable, we would get an error from a compiler
             // because in a const method we can not change a non-mutable field
             pi = new_pi;
             pi_calculated = true;
             return pi;
         }
     }
 private:
     mutable bool pi_calculated = false;
     mutable double pi = 0;
};

उत्परिवर्तित लंबोदर

डिफ़ॉल्ट रूप से, अंतर्निहित operator() एक लैम्ब्डा की है const । यह लंबोदर पर नॉन- const ऑपरेशन करना पसंद नहीं करता है। संशोधित करने वाले सदस्यों को अनुमति देने के लिए, एक लैम्ब्डा को mutable रूप में चिह्नित किया जा सकता है, जो निहित operator() गैर- const बनाता है:

int a = 0;

auto bad_counter = [a] {
    return a++;   // error: operator() is const
                  // cannot modify members
};

auto good_counter = [a]() mutable {
    return a++;  // OK
}

good_counter(); // 0
good_counter(); // 1
good_counter(); // 2