Перегрузка оператора индексации индекса C++ [] таким образом, чтобы можно было реагировать на обновления

По оператору [] можно узнать только доступ.
Даже если внешний объект использует бесплатную версию, это не означает, что запись будет иметь место, а может быть.

Таким образом, вам нужно вернуть объект, который может обнаруживать изменения.
Лучший способ сделать это — обернуть объект классом, который переопределяет operator=. Затем эта оболочка может сообщить хранилищу, когда объект был обновлен. Вы также хотели бы переопределить operator Type (приведение), чтобы константную версию объекта можно было получить для доступа на чтение.

Тогда мы могли бы сделать что-то вроде этого:

class WriteCheck;
class Store
{
  public:
  Type const& operator[](int index) const
  {
    return state[index];
  } 
  WriteCheck operator[](int index);
  void stateUpdate(int index)
  {
        // Called when a particular index has been updated.
  }
  // Stuff
};

class WriteCheck
{ 
    Store&  store;
    Type&   object;
    int     index;

    public: WriteCheck(Store& s, Type& o, int i): store(s), object(o), index(i) {}

    // When assignment is done assign
    // Then inform the store.
    WriteCheck& operator=(Type const& rhs)
    {
        object = rhs;
        store.stateUpdate(index);
    }

    // Still allow the base object to be read
    // From within this wrapper.
    operator Type const&()
    {
        return object;
    }   
};      

WriteCheck Store::operator[](int index)
{   
    return WriteCheck(*this, state[index], index);
}

Более простая альтернатива:
Вместо того, чтобы предоставлять оператор[], вы предоставляете конкретный метод set для объекта хранилища и предоставляете доступ для чтения только через оператор[]

Вы можете заставить (неконстантный) operator[] возвращать прокси-объект, который хранит ссылку или указатель на контейнер, и в котором operator= сигнализирует о контейнере обновления.

(Идея использования константного и неконстантного оператора [] является отвлекающим маневром... вы можете знать, что вы только что предоставили неконстантный доступ к объекту, но вы не знаете, действует ли этот доступ до сих пор. использоваться для чтения или записи, когда эта запись завершается, или иметь какой-либо механизм для последующего обновления контейнера.)

Еще одно элегантное (ИМХО) решение... На самом деле оно основано на том, что перегрузка const вызывается только при использовании на объекте const. Давайте сначала создадим две перегрузки [] — как нужно, но с разными локациями:

Type& operator[](int index)
{
    assert(index >=0 && index < size);
    return stateWrite[index];
}
const Type& operator[](int index) const
{
    assert(index >=0 && index < size);
    return stateRead[index];
}

Теперь вы должны создать теневую ссылку вашего объекта, когда вам нужно «прочитать» его следующим образом:

const Indexable& myIndexableRead = myIndexable; // create the shadow
Type a = myIndexableRead[2]; //Access
myIndexable[3] = a;  //Modification

Создание этого теневого объявления фактически ничего не создает в памяти. Он просто создает другое имя для вашего объекта с доступом "const". Все это решается на этапе компиляции (включая использование перегрузки const) и ни на что не влияет в рантайме — ни на память, ни на производительность.

И в сухом остатке - это гораздо элегантнее (ИМХО), чем создание всяких прокси присваивания и т.п. Должен констатировать, что утверждение "От оператора[] можно только реально сказать доступ< /сильный>" неверно. В соответствии со стандартом C++ возврат динамически размещенного объекта или глобальной переменной по ссылке является окончательным способом разрешить его прямую модификацию, включая случай перегрузки [].

#include <iostream>

using namespace std;

class SafeIntArray {
    int* numbers;
    int size;
    static const int externalValue = 50;

public:
    SafeIntArray( unsigned int size = 20 ) {
        this->size = size;
        numbers = new int[size];
    }
    ~SafeIntArray() {
        delete[] numbers;
    }

    const int& operator[]( const unsigned int i ) const {
        if ( i < size )
            return numbers[i];
        else
            return externalValue;
    }

    int& operator[]( const unsigned int i ) {
        if ( i < size )
            return numbers[i];
        else
            return *numbers;
    }

    unsigned int getSize() { return size; }
};

int main() {

    SafeIntArray arr;
    const SafeIntArray& arr_0 = arr;
    int size = arr.getSize();

    for ( int i = 0; i <= size ; i++ )
        arr[i] = i;

    for ( int i = 0; i <= size ; i++ ) {
        cout << arr_0[i] << ' ';
    }
    cout << endl;

    return 0;
}