Ввод-вывод в символьные массивы.
Строка являются массивом символов. Значением строки является указатель на первый ее символ:
char *string = "строка\n";
Здесь указатель на символы string будет содержать адрес первого символа 'c' строки "строка\n", которая размещается в некоторой области памяти, начиная с этого адреса:
Здесь string[3] = = 'о'.
Рассмотрим фрагмент программы:
char buffer[ ] =" "; // Инициализация // строки из 10 пробелов. char *string = buffer; // string указывает на начало буфера. string="проба\n"; // Присваивание!
При инициализации создается строка buffer и в нее помещаются символы (здесь 10 пробелов). Инициализация char *string=buffer устанавливает указатель string на начало этой строки.
Операция же присваивания в последней строке не копирует приведенную строку "проба\n" в массив buffer, а изменяет значение указателя stringтак, что он начинает указывать на строку "проба\n":
Чтобы скопировать строку "проба\n" в buffer, можно поступить так:
char buffer[ ] = " "; char *p ="проба\n"; int i =0; while ( ( buffer[i] = p[i] ) != '\0' ) i++;
Или так: char buffer[ ] = " " char * p = "проба\n"; char * buf = buffer; while (*buf ++ = *p ++ );
Здесь сначала *p копируется в *buf, т.е. символ 'п' копируется по адресу buf, который совпадает с адресом buffer, т.е. buffer[0] становится равен 'п'. Затем происходит увеличение указателей p и buf, что приводит к продвижению по строкам "проба\n" и buffer соответственно. Последний скопированный символ будет '\0', его значение - 0 и оператор while прекратит цикл.
Еще проще воспользоваться библиотечной функцией, прототип которой находится в файле string.h:
strcpy( buffer, "проба\n");
При копировании необходимо обеспечить, чтобы размер памяти, выделенной под buffer, был достаточен для хранения копируемой строки.
Виртуальные базовые классы.
Иногда применение множественного наследования предполагает достаточно тесную связь между
классами, которые рассматриваются как "братские" базовые классы. Такие классы-братья обычно
должны проектироваться совместно. В большинстве случаев для этого не требуется особый стиль
программирования, существенно отличающийся от того, который мы только что рассматривали. Просто
на производный класс возлагается некоторая дополнительная работа. Обычно она сводится к
переопределению одной или нескольких виртуальных функций (см. $$13.2 и $$8.7). В некоторых
случаях классы-братья должны иметь общую информацию. Поскольку С++ - язык со строгим контролем
типов, общность информации возможна только при явном указании того, что является общим в этих
классах. Способом такого указания может служить виртуальный базовый класс.
Виртуальный базовый класс можно использовать для представления "головного" класса, который может
конкретизироваться разными способами:
class window {
// головная информация
virtual void draw();
};
Для простоты рассмотрим только один вид общей информации из класса window - функцию draw().
Можно определять разные более развитые классы, представляющие окна (window). В каждом
определяется своя (более развитая) функция рисования (draw):
class window_w_border : public virtual window {
// класс "окно с рамкой"
// определения, связанные с рамкой
void draw();
};
class window_w_menu : public virtual window {
// класс "окно с меню"
// определения, связанные с меню
void draw();
};
Теперь хотелось бы определить окно с рамкой и меню:
class window_w_border_and_menu
: public virtual window,
public window_w_border,
public window_w_menu {
// класс "окно с рамкой и меню"
void draw();
};
Каждый производный класс добавляет новые свойства окна. Чтобы воспользоваться комбинацией всех
этих свойств, мы должны гарантировать, что один и тот же объект класса window используется для
представления вхождений базового класса window в эти производные классы. Именно это обеспечивает
описание window во всех производных классах как виртуального базового класса.
Можно следующим образом изобразить состав объекта класса window_w_border_and_menu:
Чтобы увидеть разницу между обычным и виртуальным наследованием, сравните этот рисунок с
рисунком из $$6.5, показывающим состав объекта класса satellite. В графе наследования каждый
базовый класс с данным именем, который был указан как виртуальный, будет представлен
единственным объектом этого класса. Напротив, каждый базовый класс, который при описании
наследования не был указан как виртуальный, будет представлен своим собственным объектом.
Виртуальные деструкторы.
Виртуальный деструктор
Практически всегда деструктор делается виртуальным. Делается это для того, чтобы корректно (без утечек памяти) уничтожались объекты не только заданного класса, а и любого производного от него. Например: в игре уровни, звуки и спрайты могут создаваться загрузчиком, а уничтожаться — менеджером памяти, для которого нет разницы между уровнем и спрайтом.
Пусть (на C++) есть тип Father и порождённый от него тип Son:
class Father
{
public:
Father() {}
~Father() {}
};
class Son : public Father
{
public:
int* buffer;
Son() : Father() { buffer = new int[1024]; }
~Son() { delete[] buffer; }
};
Нижеприведённый код является некорректным и приводит к утечке памяти.
Father* object = new Son(); // вызывается Son()
delete object; // вызывается ~Father()!!
Однако, если сделать деструктор Father виртуальным:
class Father
{
public:
Father() {}
virtual ~Father() {}
};
class Son : public Father
{
private:
int* buffer;
public:
Son() : Father() { buffer = new int[1024]; }
~Son() { delete[] buffer; }
};
вызов delete object; приведет в последовательному вызову деструкторов ~Son и ~Father.