C++: библиотека программиста

 
115 
Foo* foo = array[Index(17, 29)]; 
// Работает 
С чтением массива проблем нет. Если индекс существует, возвращается содержимое массива по 
данному индексу. Если индекс в массиве отсутствует, значение 
NULL
полностью соответствует идее 
предварительной инициализации массива значениями 
NULL
. Минутку, но как добавить в массив новую 
ячейку или изменить уже существующую? Значение, возвращаемое операторной функцией 
operator[]
, не является ни левосторонним выражением (lvalue), ни классом с перегруженным 
оператором 
=
и по нему нельзя выполнить присваивание. 
array[Index(31, 37)] = foo; // Не работает 
Ваш компилятор не спит ночами и ждет, когда же у него появится такая замечательная возможность 
забить поток 
сеrr
сообщениями об ошибках. Можно было бы создать интерфейс на базе функций, но 
тогда у клиента нарушится иллюзия того, что он имеет дело с нормальным, честным массивом. 
Существует ли способ использовать оператор 
[]
в левой части операции присваивания для индексов, 
которых еще нет? Оказывается, существует, но для этой цели нам потребуется новая идиома — курсор. 
Курсоры и разреженные массивы 
Итак, вторая попытка. Наша основная цель — чтобы операторная функция 
operator[]
возвращала 
нечто, обладающее следующими свойствами: 
1. Оно должно преобразовываться к типу содержимого массива. 
2. Оно может использоваться в левой части операции присваивания для изменения содержимого 
соответствующей ячейки. 
Это «нечто» представляет собой особый класс, который называется курсором (cursor). Ниже показан 
уже знакомый разреженный массив с курсором в операторной функции 
operator[]
: 
class ArrayCursor; 
class SparseArray { 
friend class ArrayCursor; 
private: 
struct Node { 
Index 
index; 
Foo* 
content; 
Node* 
next; 
Node(Index i, Foo* c, Node* n) : index(i), content(c), next(n) {}; 
}; 
Node* 
cells; 
public: 
SparseArray() : cells(NULL) {} 
ArrayCursor operator[](Index i); 
}; 
class ArrayCursor { 
friend class SparseArray; 
private: 
SparseArray& 
array;
// 
Обратный указатель на массив-владелец 
Index 
index; 
// 
Элемент, представленный курсором 
SparseArray::Node* 
node; 
// 
Если существует индекс, отличный от NULL 
// 
Конструкторы объявлены закрытыми, поэтому пользоваться ими 
// 
может только SparseArray. Первый конструктор используется, когда 
// 
индекс еще не существует, а второй – когда индекс уже присутствует 
// 
в массиве. 

---

 116 
ArrayCursor(SparseArray& arr, Index i) 
: array(arr), index(i), node(NULL) {} 
ArrayCursor(SparseArray& arr, SparseArray::Node* n) 
: array(arr), node(n), index(n->index) {} 
public: 
// 
Следующий оператор = позволяет преобразовать присваивание курсору в 
// 
присваивание соответствующему элементу массива. 
ArrayCursor& operator=(Foo* foo); 
}; 
ArrayCursor& ArrayCursor::operator=(Foo* foo) { 
if (node == NULL) { 
// Индекс не существует 
node = new SparseArray::Node(index, foo, array.cells); 
array.cells = node; 
} 
else 
// 
Индекс уже существует, изменить значение элемента 
node->content 
= 
foo; 
return 
*this; 
} 
ArrayCursor SparseArray::operator[](Index i) 
{ 
SparseArray::Node* n = cells; 
while (n != NULL) 
if (n->index = i) 
return 
ArrayCursor(*this, 
n); // 
Существует 
else 
n 
= 
n->next; 
return 
ArrayCursor(*this, 
i); 
// 
Еще не существует 
} 
Ого! Что же происходит в этом хитроумном коде? Все волшебство заключено в двух операторных 
функциях, 
SparseArray::operator[]()
и 
ArrayCursor::operator=()
. 
SparseArray:: 
operator[]()
возвращает 
ArrayCursor
независимо от того, существует индекс или нет (об этом 
ArrayCursor
узнает по тому, какой конструктор был выбран). 
ArrayCursor::operator=(Foo*)
делает одно из двух: если индекс уже существует, элемент изменяется, а если не существует — он 
динамически добавляется в массив. В этом проявляется вся суть курсорности (курсоризма?): 
перегруженный оператор 
=
выполняет присваивание не для самого курсора, а для структуры данных, 
от которой происходит курсор. Теперь присваивание работает независимо от того, существует индекс 
или нет. 
array[Index(17, 29)] = new Foo; 
// Добавляет индекс 
array[Index(17, 29)] = new Foo; 
// Изменяет значение с заданным индексом 
Неплохо для часовой работенки, не правда ли? Наш массив работает совсем как настоящий. Почти. 
Операторы преобразования и оператор -> 
Осталось добавить еще пару штрихов. Во-первых, оператор 
[]
в правой части операции присваивания 
работает уже не так, как было написано, поскольку он возвращает 
ArrayCursor
, а не 
Foo*
или 
Foo*&
. 
Но причин для беспокойства нет, потому что 
Foo*()
в случае необходимости автоматически 
преобразует 
ArrayCursor
к 
Foo*
. Вторая проблема заключается в том, что оператор 
[]
не может 
использоваться слева от оператора 
->
; на помощь приходит 
operator->()
! 

---