
- •1.2 Философские замечания
- •1.3 Процедурное программирование
- •1.4 Модульное программирование
- •1.5 Абстракция данных
- •1.6 Пределы абстракции данных
- •1.7 Объектно-ориентированное программирование
- •1.8 Концепции объектно-ориентированного программирования
- •1.8.1 Инкапсуляция
- •1.8.2 Полиморфизм
- •1.8.3 Наследование
- •1.10 Несколько полезных советов
- •2.2 Перегрузка функций
- •2.3 Перегрузка операторов
- •2.4 Наследование
- •2.5 Конструкторы и деструкторы
- •2.7 Два новых типа данных
- •Глава 3. Классы и объекты
- •3.1 Параметризованные конструкторы
- •3.2 Дружественные функции
- •3.3 Значения аргументов функции по умолчанию
- •3.3.1 Корректное использование аргументов по умолчанию
- •3.4 Взаимосвязь классов и структур
- •3.5 Связь объединений и классов
- •3.6 Анонимные объединения
- •3.7 Inline-функции
- •3.7.1 Создание inline-функций внутри класса
- •3.8 Передача объектов в функции
- •3.9 Возвращение объектов функциями
- •3.10 Присваивание объектов
- •3.11 Конструктор копирования
- •3.12 Массивы объектов
- •3.12.1 Инициализация массивов объектов
- •3.12.2 Создание инициализированных и неинициализированных массивов
- •3.13 Указатели на объекты
- •3.14 Статические члены класса
- •Глава 4. Перегрузка функций и операторов
- •4.1 Перегрузка конструкторов
- •4.2 Локализация переменных
- •4.3 Локализация создания объектов
- •4.4 Перегрузка функций и неопределенность
- •4.5 Определение адреса перегруженной функции
- •4.6 Указатель this
- •4.7 Перегрузка операторов
- •4.8 Дружественная функция-оператор
- •4.9 Ссылки
- •4.9.1 Параметры-ссылки
- •4.9.2 Передача ссылок на объекты
- •4.9.3 Возврат ссылок
- •4.9.4 Независимые ссылки
- •4.9.5 Использование ссылок для перегрузки унарных операторов
- •4.10 Перегрузка оператора []
- •4.11 Создание функций преобразования типов
- •Глава 5. Наследование, виртуальные функции и полиморфизм
- •5.1 Наследование и спецификаторы доступа
- •5.1.1 Спецификаторы доступа
- •5.1.2 Спецификатор доступа при наследовании базового класса
- •5.1.3 Дополнительная спецификация доступа при наследовании
- •5.2 Конструкторы и деструкторы производных классов
- •5.3 Множественное наследование
- •5.4 Передача параметров в базовый класс
- •5.5 Указатели и ссылки на производные типы
- •5.6 Ссылки на производные классы
- •5.7 Виртуальные функции
- •5.8 Для чего нужны виртуальные функции?
- •5.9 Чисто виртуальные функции и абстрактные типы
- •5.10 Виртуальный базовый класс
- •5.11 Раннее и позднее связывание
- •Глава 6. Подсистема динамического выделения памяти
- •6.1 Введение в обработку исключений
- •6.1.1 Перехват всех исключений
- •6.2 Работа с памятью с помощью new и delete
- •6.3 Размещение объектов
- •6.4 Перегрузка new u delete
- •7.1.1 Потоки
- •7.3 Создание собственных операторов вставки и извлечения
- •7.3.1 Создание операторов вставки
- •7.3.2 Перегрузка операторов извлечения
- •7.4 Форматирование ввода/вывода
- •7.4.1 Форматирование с помощью функций-членов класса ios
- •7.4.2 Использование манипуляторов
- •7.5 Создание собственных функций-манипуляторов
- •7.5.1 Создание манипуляторов без параметров
- •7.5.2 Создание манипуляторов с параметрами
- •7.6 Файловый ввод/вывод
- •7.6.1 Открытие и закрытие файлов
- •7.6.2 Чтение и запись в текстовые файлы
- •7.6.3 Двоичный ввод/вывод
- •7.6.4 Определение конца файла
- •7.6.5 Произвольный доступ
- •Глава 8. Ввод/вывод в массивы
- •8.1 Классы ввода/вывода в массивы
- •8.2 Создание потока вывода
- •8.3 Ввод из массива
- •8.4 Использование функций-членов класса ios
- •8.5 Потоки ввода/вывода в массивы
- •8.6 Произвольный доступ в массив
- •8.7 Использование динамических массивов
- •8.8 Манипуляторы и ввод/вывод в массив
- •8.9 Собственные операторы извлечения и вставки
- •8.10 Форматирование на основе массивов
- •Глава 9. Шаблоны и библиотека stl
- •9.1 Функции-шаблоны
- •9.2 Функции с двумя типами-шаблонами
- •9.3 Ограничения на функции-шаблоны
- •9.4 Классы-шаблоны
- •9.5 Пример с двумя типами-шаблонами
- •9.6 Обзор библиотеки stl
- •9.7 Класс vector
- •9.7 Класс string
- •9.8 Класс list
3.12.2 Создание инициализированных и неинициализированных массивов
Если создаются как инициализированные, так и неинициализированные массивы объектов, то возникает особая ситуация. Рассмотрим следующий класс:
class C
{
int i;
public:
C(int j) { i=j; }
int get_i() { return i; }
};
Здесь конструктор требует один аргумент. В результате объявления любого массива элементов данного класса требуется, чтобы эти элементы были инициализированы. Следующее объявление массива является ошибочным:
C а[9]; // ошибка, конструктор требует инициализатор
Причина, по которой это объявление неверно, связана с тем, что подобное объявление, поскольку оно не содержит инициализации, требует наличия конструктора без параметров. Так как класс C не имеет конструктора без параметров, то компилятор выдает сообщение об ошибке. Для того чтобы решить эту проблему, необходимо перегрузить конструктор, добавив еще один — без параметров. В таком случае оба типа массивов — с инициализированными и неинициализированными элементами — становятся допустимыми. (Перегрузка конструкторов подробно обсуждается в следующей главе). В качестве примера ниже приведена усовершенствованная версия объявления класса C:
class C
{
int i;
public:
C() { i=0; } // вызывается для неинициализированных массивов
C(int j) { i=j; } // вызывается для инициализированных массивов
int get_i() { return i; }
};
Для объявленного таким образом класса оба следующих объявления являются допустимыми:
C a1[3] = {3, 5, 6}; // инициализированный
C а2[9]; // неинициализированный
3.13 Указатели на объекты
В языке С можно получить доступ к структуре непосредственно или с использованием указателей на эту структуру. Аналогичным образом в C++ можно ссылаться на объект непосредственно, как это имело место во всех предыдущих примерах, или используя указатель на этот объект. Указатели на объекты являются одним из важнейших понятий C++.
Для доступа к членам объекта через сам объект используется оператор «точка» (.). Если же используется указатель на объект, тогда необходимо использовать оператор «стрелка» (->). Использование операторов «точка» и «стрелка» аналогично их использованию для структур и объединений.
Указатель на объект объявляется с использованием того же синтаксиса, что и указатели на данные других типов:
#include <iostream.h>
class P_example
{
int num;
public:
void set_num(int val) { num = val; }
void show_num();
};
void P_example::show_num()
{
cout << num << "\n";
}
int main()
{
P_example obj, *p; // объявление объекта и указателя на него
obj.set_num(1); // прямой доступ
р = &obj; // присваивание р адреса obj
p->show_num(); // доступ с помощью указателя
return 0;
}
Обратим внимание, что адрес объекта obj получен с использованием оператора взятия адреса & точно так же, как берется адрес переменной любого типа.
Инкремент или декремент указателя изменяет его таким образом, что он всегда указывает на следующий элемент базового типа. То же самое справедливо и для объектов.
#include <iostream.h>
class P_example
{
int num;
public:
void set_num(int val) { num = val; }
void show_num();
};
void P_example::show_num()
{
cout << num << "\n";
}
int main()
{
P_example obj[2], *p;
obj[0].set_num(10); // прямой доступ к объекту
obj[1].set_num(20);
p = &obj[0]; // получение указателя на первый элемент
p->show_num(); // вывод значения obj[0] с помощью указателя
р++; // переход к следующему объекту
p->show_num(); // вывод значения obj[1] с помощью указателя
р--; // переход к предыдущему объекту
p->show_num(); // вывод значения obj[0]
return 0;
}
Программа выводит на экран числа 10, 20, 10.