Программирование. Принципы и практика использования C++ Исправленное издание

Страуструп Бьерн

• Он ссылается на объекты в памяти (он не владеет объектами, не размещает их, не удаляет и т.д.).

• Он знает свой размер (а значит, способен проверять выход за пределы допустимого диапазона).

• Он знает точный тип своих элементов (а значит, не может порождать ошибки, связанные с типами).

• Его несложно передать (скопировать) как пару (указатель, счетчик).

• Его нельзя неявно преобразовать в указатель.

• Он позволяет легко выделить поддиапазон в целом диапазоне.

• Его легко использовать как встроенный

массив.

Свойство “легко использовать как встроенный массив” можно обеспечить лишь приблизительно. Если бы мы сделали это совершенно точно, то вынуждены были бы смириться с ошибками, которых стремимся избежать.

Рассмотрим пример такого класса.

template<class T>

class Array_ref {

public:

Array_ref(T* pp, int s) :p(pp), sz(s) { }

T& operator[ ](int n) { return p[n]; }

const T& operator[ ](int n) const { return p[n]; }

bool assign(Array_ref a)

{

if (a.sz!=sz) return false;

for (int i=0; i<sz; ++i) { p[i]=a.p[i]; }

return true;

}

void reset(Array_ref a) { reset(a.p,a.sz); }

void reset(T* pp, int s) { p=pp; sz=s; }

int size const { return sz; }

// операции копирования по умолчанию:

// класс Array_ref не владеет никакими ресурсами

// класс Array_ref имеет семантику ссылки

private:

T* p;

int sz;

};

Класс

Array_ref

близок к минимальному.

• В нем нет функций

push_back

(для нее нужна динамическая память) и

at

(для нее нужны исключения).

• Класс Array_ref имеет форму ссылки, поэтому операция копирования просто копирует пары (

p, sz

).

• Инициализируя разные массивы, можем получить объекты класса

Array_ref

, которые имеют один и тот же тип, но разные размеры.

• Обновляя пару (

p, size

) с помощью функции

reset

, можем изменить размер существующего класса

Array_ref

(многие алгоритмы требуют указания поддиапазонов).

• В классе

Array_ref

нет интерфейса итераторов (но при необходимости этот недостаток легко устранить). Фактически концепция класса

Array_ref

очень напоминает диапазон, заданный двумя итераторами.

Класс

Array_ref

не владеет своими элементами и не управляет памятью, он просто представляет собой механизм для доступа к последовательности элементов и их передачи функциям. Иначе говоря, он отличается от класса

array

из стандартной библиотеки (см. раздел 20.9).

Для

того чтобы облегчить создание объектов класса

Array_ref

, напишем несколько вспомогательных функций.

template<class T> Array_ref<T> make_ref(T* pp, int s)

{

return (pp) ? Array_ref<T>(pp,s):Array_ref<T>(0,0);

}

Если мы инициализируем объект класса

Array_ref

указателем, то должны явно указать его размер. Это очевидный недостаток, поскольку, задавая размер, легко ошибиться. Кроме того, он открывает возможности для использования указателя, представляющего собой результат неявного преобразования массива производного класса в указатель базового класса, например указателя

Polygon[10]

в указатель

Shape*

(ужасная проблема, описанная в разделе 25.4.2), но иногда мы должны просто доверять программисту.

Мы решили проявить осторожность в отношении нулевых указателей (поскольку это обычный источник проблем) и пустых векторов.

template<class T> Array_ref<T> make_ref(vector<T>& v)

{

return (v.size) ? Array_ref<T>(&v[0],v.size):

Array_ref<T>(0,0);

}

Идея заключается в том, чтобы передавать вектор элементов. Мы выбрали класс

vector

, хотя он часто не подходит для систем, в которых класс

Array_ref

может оказаться полезным. Причина заключается в том, что он обладает ключевыми свойствами, присущими контейнерам, которые здесь можно использовать (например, контейнерам, основанным на пулах; см. раздел 25.3.3).

В заключение предусмотрим обработку встроенных массивов в ситуациях, в которых компилятор знает их размер.

template <class T, int s> Array_ref<T> make_ref(T (&pp)[s])

{

return Array_ref<T>(pp,s);

}

Забавное выражение

T(&pp)[s]

объявляет аргумент

pp

ссылкой на массив из

s

элементов типа

T

. Это позволяет нам инициализировать объект класса

Array_ref

массивом, запоминая его размер. Мы не можем объявить пустой массив, поэтому не обязаны проверять, есть ли в нем элементы.

Polygon ar[0]; // ошибка: элементов нет

Используя данный вариант класса

Array_ref

, мы можем переписать наш пример.

void better(Array_ref<Shape> a)

{

for (int i = 0; i<a.size; ++i) a[i].draw;

}

void f(Shape* q, vector<Circle>& s0)

{

Polygon s1[10];