const string &operator[](int idx) const;

class ResizeableIntArray
{
     public:

          int &operator[](int index);

          const int &operator[](int index) const;

     // other details eliminated

     private:

         void Resize(index);    // resize array so index identifies a valid element
                                      //   any added elements assigned value of zero

         bool ValidIndex(int index) const;  // check if index identifies a valid element

         void ComplainBitterly() const;   // report an error condition (eg throw exception)
         
};

//   the version without const adornment

int ResizableIntArray::operator[](int index)
{
      //   the following is pseudo-code to illustrate idea
      if (InvalidIndex(index))
          ResizeArray(index);      //   this won't work if method is const (i.e. trailing const)

      if (InvalidIndex(index)) ComplainBitterly();

      return element[index];      
}

//   the version with const adornment

const int ResizableIntArray::operator[](int index) const
{
      if (InvalidIndex(index)) ComplainBitterly();
      return element[index];      
}

int main()
{
       ResizeableIntArray modifiable;

       modifiable[3] = 5;     // calls non-const version

       int &x = modifiable[5];    //   this actually resizes array.
                                        //      x will reference 5'th element

       x = 10;   // will set 5th element to 10

       const ResizeableIntArray unmodifiable;

       unmodifiable[3] = 42;   //  compiler will compain as const operator []
                                      // used here, so can't be used as LHS

       int &y = unmodifiable[5];   // compiler will complain.  const operator[]
                                           // called, but a const returned reference
                                           // can't be bound to a non-const one.

       const int &z = unmodifiable[5];   // this is OK (const operator [], result
                                                   // assigned to const reference.
                                                   //  bitter complaint at run time unless
                                                   //  unmodifiable has a 5th element

       int q = z;         // OK;  assign q to value referenced by z
       int &r = z;       //  compiler complaint;  binding const ref to non-const one

       const int &s = z;  //  OK.  s and z are alias for unmodifiable[5]
                               //  (if it exists and we get here despite complaint 
                               //  above)
}