Бьерн Страуструп (947334), страница 29

Просмтор этого файла доступен только зарегистрированным пользователям. Но у нас супер быстрая регистрация: достаточно только электронной почты!

Текст из файла (страница 29)

время, затраченное на разработку нового типа, многократно окупается

в процессе отладки и развития программы.

Вот пример законченного определения типа intset, представляющего

понятие "множество целых":

class intset {

int cursize, maxsize;

int *x;

public:

intset(int m, int n); // не более m целых из 1..n

~intset();

int member(int t) const; // является ли t членом?

void insert(int t); // добавить к множеству t

void start(int& i) const { i = 0; }

void ok(int& i) const { return i<cursize; }

void next(int& i) const { return x[i++]; }

};

Для проверки этого класса вначале создадим, а затем распечатаем

множество случайных целых чисел. Это простое множество целых

можно использовать для проверки, есть ли повторения в их

последовательности. Но для большинства задач нужен, конечно,

более развитый тип множества. Как всегда возможны ошибки, поэтому

нужна функция:

#include <iostream.h>

void error(const char *s)

{

cerr << "set: " << s << '\n';

exit(1);

}

Класс intset используется в функции main(), для которой должно

быть задано два параметра: первый определяет число создаваемых

случайных чисел, а второй - диапазон их значений:

int main(int argc, char* argv[])

{

if (argc != 3) error("нужно задавать два параметра");

int count = 0;

int m = atoi(argv[1]); // число элементов множества

int n = atoi(argv[2]); // из диапазона 1..n

intset s(m,n);

while (count<m) {

int t = randint(n);

if (s.member(t)==0) {

s.insert(t);

count++;

}

}

print_in_order(&s);

}

Значение счетчика параметров программы argc равно 3, хотя

программа имеет только два параметра. Дело в том, что в argv[0]

всегда передается дополнительный параметр, содержащий имя программы.

Функция

extern "C" int atoi(const char*)

является стандартной библиотечной функцией, преобразующей целое из

строкового представления во внутреннюю двоичную форму. Как обычно,

если вы не хотите иметь такое описание в своей программе, то вам

надо включить в нее соответствующий заголовочный файл, содержащий

описания стандартных библиотечных функций. Случайные числа

генерируются с помощью стандартной функции rand:

extern "C" int rand(); // будьте осторожны:

// числа не совсем случайные

int randint(int u) // диапазон 1..u

{

int r = rand();

if (r < 0) r = -r;

return 1 + r%u;

}

Подробности реализации класса мало интересны для пользователя,

но в любом случае будут использоваться функции-члены.

Конструктор размещает массив целых с размером, равным заданному

максимальному размеру множества, а деструктор удаляет этот массив:

intset::intset(int m, int n) // не более m целых в 1..n

{

if (m<1 || n<m) error("недопустимый размер intset");

cursize = 0;

maxsize = m;

x = new int[maxsize];

}

intset::~intset()

{

delete x;

}

Целые добавляются таким образом, что они хранятся во множестве

в возрастающем порядке:

void intset::insert(int t)

{

if (++cursize > maxsize) error("слишком много элементов");

int i = cursize-1;

x[i] = t;

while (i>0 && x[i-1]>x[i]) {

int t = x[i]; // поменять местами x[i] и x[i-1]

x[i] = x[i-1];

x[i-1] = t;

i--;

}

}

Чтобы найти элемент, используется простой двоичный поиск:

int intset::member(int t) const // двоичный поиск

{

int l = 0;

int u = cursize-1;

while (l <= u) {

int m = (l+u)/2;

if (t < x[m])

u = m-1;

else if (t > x[m])

l = m+1;

else

return 1; // найден

}

return 0; // не найден

}

Наконец, нужно предоставить пользователю набор операций, с помощью

которых он мог бы организовать итерацию по множеству в некотором

порядке (ведь порядок, используемый в представлении intset,

от него скрыт). Множество по своей сути не является внутренне

упорядоченным, и нельзя позволить просто выбирать элементы массива

(а вдруг завтра intset будет реализовано в виде связанного списка?).

Пользователь получает три функции: start() - для инициализации

итерации, ok() - для проверки, есть ли следующий элемент, и next() -

для получения следующего элемента:

class intset {

// ...

void start(int& i) const { i = 0; }

int ok(int& i) const { return i<cursize; }

int next(int& i) const { return x[i++]; }

};

Чтобы обеспечить совместную работу этих трех операций, надо запоминать

тот элемент, на котором остановилась итерация. Для этого пользователь

должен задавать целый параметр. Поскольку наше представление множества

упорядоченное, реализация этих операций тривиальна. Теперь

можно определить функцию print_in_order:

void print_in_order(intset* set)

{

int var;

set->sart(var);

while (set->ok(var)) cout << set->next(var) << '\n';

}

Другой способ построения итератора по множеству приведен в $$7.8.

5.4 Еще о классах

В этом разделе описаны дополнительные свойства класса. Описан

способ обеспечить доступ к частным членам в функциях, не являющихся

членами ($$5.4.1). Описано, как разрешить коллизии имен членов

($$5.4.2) и как сделать описания классов вложенными ($$5.4.3), но

при этом избежать нежелательной вложенности ($$5.4.4). Вводится понятие

статических членов (static), которые используются для представления

операций и данных, относящихся к самому классу, а не к отдельным

его объектам ($$5.4.5). Раздел завершается примером, показывающим,

как можно построить дискриминирующее (надежное) объединение ($$5.4.6).

5.4.1 Друзья

Пусть определены два класса: vector (вектор) и matrix (матрица).

Каждый из них скрывает свое представление, но дает полный набор операций

для работы с объектами его типа. Допустим, надо определить функцию,

умножающую матрицу на вектор. Для простоты предположим, что

вектор имеет четыре элемента с индексами от 0 до 3, а в матрице

четыре вектора тоже с индексами от 0 до 3. Доступ к элементам

вектора обеспечивается функцией elem(), и аналогичная функция есть

для матрицы. Можно определить глобальную функцию multiply

(умножить) следующим образом:

vector multiply(const matrix& m, const vector& v);

{

vector r;

for (int i = 0; i<3; i++) { // r[i] = m[i] * v;

r.elem(i) = 0;

for (int j = 0; j<3; j++)

r.elem(i) +=m.elem(i,j) * v.elem(j);

}

return r;

}

Это вполне естественное решение, но оно может оказаться очень

неэффективным. При каждом вызове multiply() функция elem() будет

вызываться 4*(1+4*3) раз. Если в elem() проводится настоящий

контроль границ массива, то на такой контроль будет потрачено

значительно больше времени, чем на выполнение самой функции, и в

результате она окажется непригодной для пользователей. С другой

стороны, если elem() есть некий специальный вариант доступа без

контроля, то тем самым мы засоряем интерфейс с вектором и матрицей

особой функцией доступа, которая нужна только для обхода контроля.

Если можно было бы сделать multiply членом обоих классов

vector и matrix, мы могли бы обойтись без контроля индекса при

обращении к элементу матрицы, но в то же время не вводить специальной

функции elem(). Однако, функция не может быть членом двух классов.

Надо иметь в языке возможность предоставлять функции, не являющейся

членом, право доступа к частным членам класса. Функция - не член

класса, - имеющая доступ к его закрытой части, называется другом

этого класса. Функция может стать другом класса, если в его

описании она описана как friend (друг). Например:

class matrix;

class vector {

float v[4];

// ...

friend vector multiply(const matrix&, const vector&);

};

class matrix {

vector v[4];

// ...

friend vector multiply(const matrix&, const vector&);

};

Функция-друг не имеет никаких особенностей, за исключением права

доступа к закрытой части класса. В частности, в такой функции

нельзя использовать указатель this, если только она действительно

не является членом класса. Описание friend является настоящим

описанием. Оно вводит имя функции в область видимости класса,

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

на наличие других описаний такого же имени в этой области

видимости. Описание friend может находится как в общей, так и в

частной частях класса, это не имеет значения.

Теперь можно написать функцию multiply, используя элементы

вектора и матрицы непосредственно:

vector multiply(const matrix& m, const vector& v)

{

vector r;

for (int i = 0; i<3; i++) { // r[i] = m[i] * v;

r.v[i] = 0;

for ( int j = 0; j<3; j++)

r.v[i] +=m.v[i][j] * v.v[j];

}

return r;

}

Отметим, что подобно функции-члену дружественная функция

явно описывается в описании класса, с которым дружит. Поэтому она

является неотъемлемой частью интерфейса класса наравне с

функцией-членом.

Функция-член одного класса может быть другом другого класса:

class x {

// ...

void f();

};

class y {

// ...

friend void x::f();

};

Вполне возможно, что все функции одного класса являются друзьями

другого класса. Для этого есть краткая форма записи:

class x {

friend class y;

// ...

};

В результате такого описания все функции-члены y становятся друзьями

класса x.

5.4.2 Уточнение имени члена

Иногда полезно делать явное различие между именами членов классов

и прочими именами. Для этого используется операция :: (разрешения

области видимости):

class X {

int m;

public:

int readm() const { return m; }

void setm(int m) { X::m = m; }

};

В функции X::setm() параметр m скрывает член m, поэтому к члену

можно обращаться, только используя уточненное имя X::m. Правый

операнд операции :: должен быть именем класса.

Начинающееся с :: имя должно быть глобальным именем. Это особенно

полезно при использовании таких распространенных имен как read, put,

open, которыми можно обозначать функции-члены, не теряя возможности

обозначать ими же функции, не являющиеся членами.

Например:

class my_file {

// ...

public:

int open(const char*, const char*);

};

int my_file::jpen(const char* name, const char* spec)

{

// ...

if (::open(name,flag)) { // используется open() из UNIX(2)

// ...

}

// ...

}

5.4.3 Вложенные классы

Описание класса может быть вложенным. Например:

class set {

struct setmem {

int mem;

setmem* next;

setmem(int m, setmem* n) { mem=m; next=n; }

};

setmem* first;

public:

set() { first=0; }

insert(int m) { first = new setmem(m,first); }

// ...

};

Доступность вложенного класса ограничивается областью видимости

лексически объемлющего класса:

setmem m1(1,0); // ошибка: setmem не находится

// в глобальной области видимости

Если только описание вложенного класса не является совсем простым,

то лучше описывать этот класс отдельно, поскольку вложенные описания

могут стать очень запутанными:

class setmem {

friend class set; // доступно только для членов set

int mem;

setmem* next;

setmem(int m, setmem* n) { mem=m; next=n; }

// много других полезных членов

Характеристики

Список файлов книги