Я могу использовать [] оператор в C++ для создания виртуальных массивов

Все, что вы хотите, возможно, но, поскольку вам также нужен доступ для записи, результат иногда будет немного сложнее. Что вам нужно, так это функция установки, возвращающая не прямой «доступ для записи точки», а временную копию, которая будет выполнять запись, как только копия выйдет за пределы области видимости.

Следующий фрагмент кода пытается обрисовать решение:

class PointVector
{
  MyClass container_;

  public:
  class PointExSet: public Point
  {
    MyClass &container_;
    int index_;

    public:
    PointExSet(MyClass &container, int index)
      :Point(container.GetVector(index)),container_(container),index_(index)
    {
    }

    ~PointExSet()
    {
      container_.PutVector(index_) = *this;
    }
  };

  PointExSet operator [] (int i)
  {
    return PointExSet(container_,i);
  }
};

Это не так хорошо, как вы, вероятно, надеетесь, но я боюсь, что вы не сможете найти намного лучшее решение на C ++.

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

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

Если посмотреть на ваш пример кода, то в нем есть тест для стратегии хранения. Не делайте этого. Либо используйте ОО и пусть ваш объект хранения реализует общий виртуальный интерфейс, либо (что, вероятно, лучше) используйте программирование шаблонов для изменения механизма хранения.

Если вы посмотрите на гарантии, предоставляемые std::vector (в более современных стандартах C++), то можно иметь что-то, что имеет динамическое хранение и позволяет использовать арифметику указателей, хотя это требует непрерывного хранения. Учитывая, что некоторые из ваших значений создаются на лету, вероятно, не стоит накладывать это ограничение на ваши реализации, но само ограничение не препятствует использованию operator[].

Чтобы иметь полный контроль над операциями с массивом, operator [] должен возвращать специальный объект (давно изобретенный и названный «курсором»), который будет обрабатывать операции за вас. Например:

class Container
{
  PointCursor operator [] (int i)
  {
    return PointCursor(this,i);
  }
};
class PointCursor
{
public:
    PointCursor(_container, _i)
       : container(_container), i(_i),
         //initialize subcursor
         x(container, i) {}     

    //subcursor
    XCursor x;
private:
   Container* container;
   int i;
};
class XCursor
{
public:
    XCursor(_container, _i)
      : container(_container), i(_i) {}

     XCursor& operator = (const XCursor& xc)
     {
          container[i].x = xc.container[xc.i].x;
          //or do whatever you want over x
     }

     Container* container;
     int i; 
}
//usage
my_container[i].x = their_container[j].x; //calls XCursor::operator = ()