
- •1. Введение
- •2. Элементы языка
- •2.1. Первые программы
- •2.2. Алфавит языка
- •2.3. Комментарии
- •2.4. Типы данных
- •2.5. Целые типы данных
- •2.6. Плавающие типы данных
- •2.7. Константы-строки, или литералы
- •2.8. Директива препроцессора define
- •2.9. Описания
- •2.10. Модификатор const
- •3. Выражения
- •3.1. Операция и выражение присваивания
- •3.2. Арифметические операции
- •3.3. Операции отношения
- •3.4. Логические операции
- •3.5. Побитовые операции
- •3.6. Сдвиги
- •?????3.8. Тернарная или условная операция
- •3.9. Операция следования
- •3.10. Приоритеты операций и порядок вычисления
- •4.6. Оператор выбора switch
- •4.7. Оператор цикла while
- •4.8. Цикл с постусловием do-while
- •4.9. Оператор for
- •4.10. Оператор безусловного перехода
- •4.11. Оператор break
- •4.12. Оператор continue
- •4.13. Оператор return
- •5. Указатели
- •5.1. Определение указателей
- •5.2. Указатели и массивы
- •5.3. Адресная арифметика
- •5.4. Символьные массивы и строки
- •5.5. Многомерные массивы
- •5.6. Указатели и многомерные массивы
- •6. Операция sizeof
- •7. Операции для работы с динамической памятью
- •7.1. Операция выделения памяти new
- •7.2. Операция освобождения памяти delete
- •8. Функции
- •8.1. Определение и вызов функции
- •8.2. Функции. Передача аргументов
- •8.3. Передача многомерных массивов
- •8.4. Указатели на функции
- •8.5. Ссылки
- •8.6. Ссылки в качестве параметров функций
- •8.7. Аргументы по умолчанию
- •8.8. Переопределение функций
- •8.9. Шаблоны функций
- •9. Объявления и определения
- •10. Область существования имени
- •11. Область видимости
- •Здесь будет напечатано
- •12. Классы памяти
- •13. Объявления объектов и типов
- •14. Имена типов
- •15. Синоним имени типа
- •16. Правила преобразования стандартных типов
- •16.1. Явные преобразования
- •16.2. Неявные преобразования стандартных базовых типов
- •16.3. Преобразование производных стандартных типов
- •17. Перечисления
- •18. Классы
- •18.1. Объявление классов
- •18.2. Конструкторы
- •18.3. Деструкторы
- •18.4. Статические члены класса
- •18.5. Указатель this
- •18.6. Статические функции-члены
- •18.7. Указатели на члены класса
- •18.8. Инициализация данных–членов класса
- •18.9. Конструктор копирования и операция присваивания
- •18.10. Дружественные функции
- •18.11. Конструктор и операция new
- •18.12. Вызов деструктора
- •19. Производные классы
- •19.1. Построение производного класса
- •19.2. Защищенные члены класса
- •19.3. Управление уровнем доступа к членам класса
- •19.4. Последовательность вызова конструктора и деструктора при построении производного класса на основе одного базового
- •19.5. Преобразования типов
- •20. Полиморфизм
- •20.1. Раннее и позднее связывание
- •20.2. Виртуальные функции
- •20.3. Абстрактные классы
- •21. Переопределение стандартных операций
- •21.1. Основные определения и свойства
- •21.2. Операции new и delete при работе с абстрактными типами
- •21.3. Использование new при создании динамического объекта абстрактного типа
- •21.4. Операция delete
- •21.5. Преобразование типов
- •22. Некоторые особенности переопределенных операций
- •22.2. Операция [ ]
- •23. Классы и шаблоны
- •24. Списки
- •24.1. Операции над односвязными списками
- •24.2. Двунаправленные и кольцевые списки
- •24.3. Операции над кольцевыми списками
- •25. Стеки
- •25.1. Реализация стека через массив
- •25.2. Реализация стека через динамическую цепочку звеньев
- •26. Двоичные деревья
- •26.1. Определение и построение
- •26.2.Таблицы
- •27. Список литературы
18.3. Деструкторы
Важную роль наряду с инициализацией объектов абстрактных типов имеет и обратная к ней операция - удаление таких объектов. В частности, конструкторы многих классов выделяют память под объекты динамически, и после того, как необходимость в таких объектах отпадает, их рекомендуется удалить.
Это удобно выполнить в деструкторе - функции, которая вызывается для объекта абстрактного типа, когда он выходит из области существования. В рассмотренном выше примере место для хранения строк в памяти выделяется динамически, поэтому полезно определить деструктор. Имя деструктора, как и конструктора, не может быть произвольным, оно образуется символом ~ и именем класса (дополнение к конструктору):
class string { . . .
public:
~ string ( ) { delete str; }
. . .
};
Здесь деструктор очень прост. Он может быть сложнее, и оформлен в виде аутлайн-функци. Деструктор никогда не может иметь аргументов. Отметим, что нельзя получить адрес ни конструктора, ни деструктора. Вызов конструктора происходит автоматически во время определения объекта абстрактного типа. Вызов деструктора происходит автоматически при выходе объекта из области своего существования. Деструктор может быть вызван и явно с обязательным указанием его полного имени. Отметим также, что для класса, в котором явно не определен ни один конструктор, компилятор самостоятельно генерирует так называемый конструктор по умолчанию, не имеющий аргументов, с уровнем доступа public. То же относится и к деструктору.
Замечание: данные класса не обязательно должны быть определены или описаны до их первого использования в принадлежащих классу функциях. То же самое справедливо и для принадлежащих классу функций, т.е. обратиться из одной функции класса к другой можно до ее определения внутри тела класса. Все компоненты класса видны во всем классе.
18.4. Статические члены класса
Данное - член класса можно объявить со служебным словом static. Память под такие данные резервируется при запуске программы, .т.е. еще до того, как программист явно создаст первый объект данного абстрактного типа. При этом все объекты, сколько бы их ни было, используют эту заранее созданную одну - единственную копию своего статического члена. Статический член класса должен быть инициализирован после определения класса и до первого описания объекта этого класса с помощью так называемого полного или квалифицированного имени статического члена, которое имеет вид имя_класса::имя_статического_члена.
Если статический член имеет доступ public, то его также можно использовать в программе с помощью квалифицированного имени, как и обычным образом, с помощью уточненного имени.
Пример:
Напишем класс object, в статическом члене которого хранится число существующих в каждый момент времени объектов типа object.
class object {
char *str;
public:
static int num_obj;
object ( char *s){ // Конструктор.
str = new char [strlen (s) + 1];
strcpy ( str, s );
cout <<“Создается ” << str <<‘\n’; num_obj ++ ;
}
~ object ( ){
cout <<“Уничтожается ” <<str << ‘\n‘;
delete str;
num_obj – –;
}
};
int object::num_obj = 0; // Инициализация. Об этом говорит
// ключевое слово int!
object s1 (“первый глобальный объект.”,
s2 (“второй глобальный объект.”);
void f ( char *str ) {
object s ( str );
cout <<“Всего объектов - ” << object::num_object<<“.\n“;
cout <<“Проработала функция f()” <<“.\n“;}
void main ( ) {
cout <<“Пока объектов - “ <<object::num_obj << “.\n“;
object m (“объект в main ( ).”);
cout <<“А сейчас объектов - ” << m.num_obj <<“.\n“;
f (“локальный объект.”);
f (“другой локальный объект.”);
cout <<“Перед окончанием main () объектов - ” <<s1.num_obj<<“.\n“;
}
Результаты работы программы:
Создается первый глобальный объект.
Создается второй глобальный объект.
Пока объектов – 2.
Создается объект в main ( ).
А сейчас объектов – 3.
Создается локальный объект.
Всего объектов – 4.
Проработала функция f().
Уничтожается локальный объект.
Создается другой локальный объект.
Всего объектов – 4.
Проработала функция f().
Уничтожается другой локальный объект.
Перед окончанием main ( ) объектов – 3.
Уничтожается объект в main ( ).
Уничтожается второй глобальный объект.
Уничтожается первый глобальный объект.
Обратим внимание, что конструкторы для глобальных объектов вызываются до функции main (), а деструкторы после main( ).
Отметим, что классы, определенные внутри функции не могут иметь статических членов.