कैसे ऑपरेटर द्वारा आवंटित मूल्य नियंत्रित करने के लिए []

Question

मैं जानता हूँ कि operator[] ओवरलोड कैसे इस प्रकार है:

T& operator [](int idx) { 
    return TheArray[idx]; 
} 

T operator [](int idx) const { 
    return TheArray[idx]; 
} 

लेकिन क्या मैं चाहता हूँ arr[i] = value द्वारा आवंटित मूल्यों को नियंत्रित करने के लिए है। मैं 0 और 9 के बीच मान को नियंत्रित करना चाहता हूं। क्या ऐसा करने के लिए कोई वाक्यविन्यास है?

Answer 1

रेने एक अच्छा जवाब प्रदान की गई है। इसके अलावा, यहां एक पूर्ण उदाहरण है। ध्यान दें कि मैंने proxy_T कक्षा में "उपयोगकर्ता परिभाषित रूपांतरण", यानी operator T जोड़ा है।

#include <iostream> 
#include <array> 
#include <stdexcept> 

template <class T> 
class myClass 
{ 
    std::array<T, 5> TheArray; // Some array... 

    class proxy_T 
    { 
     T& value; // Reference to the element to be modified 

    public: 
     proxy_T(T& v) : value(v) {} 

     proxy_T& operator=(T const& i) 
     { 
      if (i >= 0 and i <= 9) 
      { 
       value = i; 
      } 
      else 
      { 
       throw std::range_error(std::to_string(i)); 
      } 
      return *this; 
     } 

     operator T() // This is required for getting a T value from a proxy_T, which make the cout-lines work 
     { 
      return value; 
     } 
    }; 

public: 
    proxy_T operator [](int const idx) 
    { 
     return TheArray.at(idx); 
    } 

    T operator [](int const idx) const 
    { 
     return TheArray[idx]; 
    } 
}; 

int main() { 
    myClass<int> A; 

    std::cout << A[0] << std::endl; 
    A[0] = 2; 
    std::cout << A[0] << std::endl; 
    A[1] = 20; 
} 

Answer 2

आपको एक टेम्पलेट क्लास लिखना होगा जिसमें सरणी (प्रकार टी के) में तत्व का संदर्भ होगा, इस टेम्पलेट में आप असाइनमेंट ऑपरेटर को लागू करते हैं, और वहां आप अपना चेक लागू कर सकते हैं। फिर आप अपने [] ऑपरेटर से इस टेम्पलेट क्लास का ऑब्जेक्ट वापस कर देते हैं।

कुछ इस तरह:

template< typename T> class RangeCheck 
{ 
public: 
    RangeCheck(T& dest): mDestVar(dest) { } 
    RangeCheck& operator =(const T& new_value) { 
     if ((0 <= new_value) && (new_value < 9)) { // <= ?? 
     mDestVar = new_value; 
     } else { 
     ... // error handling 
     } 
     return *this; 
    } 
private: 
    T& mDestVar; 
};