- •Определение объектно-ориентированного языка программирования (оояп). Основные свойства оояп - абстракция, инкапсуляция, наследование, полиморфизм.
- •Пример использования ооп (объектно-ориентированного проектирования)
- •Разработка класса в ооп: определение и реализация класса. Члены класса. Уровни видимости. Inline-функции. Основные этапы разработки класса
- •Определение класса
- •Рекомендации по поводу использования уровней видимости при определении класса
- •Методы класса: классификация методов, доступ к членам класса, неявный параметр this. Определение и реализация методов. Использование методов для экземпляров класса. [3, стр.6 – 7, 9-16]
- •Использование класса
- •Реализация класса
- •Пример: реализация класса Rational
- •Реализация методов класса
- •Использование класса
- •Пример использования класса
- •Перегрузка операторов
- •Выбор перегруженной функции
- •Примеры
- •Пример с ошибками
- •Друзья или члены
- •Преобразования типа: назначение, использование. Правила преобразования типа. Возможные проблемы.
- •Возникающие проблемы
- •Решение проблемы
- •Когда используются присваивание и копирующий конструктор
- •Типы отношений между классами. Контейнерные классы: определение, видимость членов класса. Реализация и вызов конструкторов и деструкторов вложенных классов. Реализация и использование методов.
- •Контейнерные классы: определение
- •Контейнерные классы: реализация методов
- •Контейнерные классы: реализация конструкторов
- •Простое наследование: правила определения производного класса
- •Пример производного класса
- •Указатели на классы: базовый и производный
- •Понятие статического и динамического связывания
- •Виртуальные функции
- •Пример: классы Точка и Окружность.
- •Пример использования динамического связывания: список
- •Понятие и назначение итераторов. Проектирование, реализация и использование итератора.
- •Шаблоны типа для функций
Методы класса: классификация методов, доступ к членам класса, неявный параметр this. Определение и реализация методов. Использование методов для экземпляров класса. [3, стр.6 – 7, 9-16]
Методы класса можно классифицировать по двум независимым критериям – по функциональному назначению и по их отношению к классу.
По функциональному назначению методы класса делятся на следующие категории:
конструкторы – предназначены для инициализации состояния экземпляров класса при их создании;
деструкторы – предназначены для выполнения каких-то дополнительных действий в момент уничтожения экземпляров класса;
селекторы – предназначены для обработки состояния класса без его изменения;
модификаторы – предназначены для изменения состояния класса;
итераторы – предназначены для организации последовательного доступа к элементам данных, определяющих состояние некоторого (одного) экземпляра класса.
По отношению к классу методы делятся на следующие две категории:
функция-член класса – функция, принадлежащая самому классу и не существующая вне класса; прототипы функций-членов класса включены в определение класса;
функция-друг класса – внешняя по отношению к классу функция, которая может существовать вне класса, но имеет доступ к закрытой (и защищенной) части класса. Прототип функции-друга класса также включается в определение класса, но начинается специальным ключевым словом friend.
Конструкторы и деструкторы класса могут быть реализованы только функциями-членами класса и имеют специальный синтаксис. Другие методы класса имеют обычный синтаксис функций языка С++ и могут быть реализованы и функциями-членами, и функциями-друзьями класса. Мы пока ограничимся рассмотрением только функций-членов класса.
Как уже было сказано, прототипы функций-членов класса включаются в определение класса. Рассмотрим следующий пример. Пусть определен простой класс X, состояние которого – целое в формате слова. Пусть для этого класса определены две функции-члена класса: функция-селектор int get() – вернуть значение состояния, и функция-модификатор void set(int) – установить значение. Прототипы функций включаются в открытую (public) часть класса:
class X{
private:
int a;
public:
int get();
void set(int);
};
Приведенное выше определение класса, к сожалению, не позволяет определить, какая из двух функций является селектором. С точки зрения компилятора, обе функции могут изменять состояние класса, т.е. обе функции являются модификаторами. Чтобы определить функцию-селектор, необходимо явно указать, что состояние класса меняться не будет. Для этого в конце прототипа функции, перед точкой с запятой, добавляется ключевое слово const:
class X{
private:
int a;
public:
int get() const; // функция-селектор
void set(int); // функция-модификатор
};
Использование класса
В соответствии с определением языка С++, новый класс представляет собой новый тип данных, определенный пользователем. Использование этого типа, с одной стороны, определяется обычными правилами языка (действующими и для стандартных типов языка). С другой стороны, использование классов предполагает использование и новых возможностей.
Так, в соответствии с обычными правилами языка, любой объект, используемый в программе, должен быть предварительно определен с помощью предложений описания типа. Для созданного класса (нового типа) это определение выглядит следующим образом:
имя_класса имя_объекта; |
// элементный объект |
Rational a; |
имя_класса имя_объекта [количество]; |
// массив объектов |
Rational b[4];
|
имя_класса *имя_объекта; |
// указатель на объект |
Rational *ptr; |
При определении объектов они могут быть инициализированы. При этом если конструкторы в определении класса отсутствуют, правила инициализации объектов определяются стандартными правилами инициализации структуры. Если же в определении класса включены конструкторы, тогда инициализация экземпляров класса осуществляется соответствующим конструктором в соответствии со следующими правилами:
а) элементные объекты
имя_класса имя_объекта, // пустой конструктор имя_объекта(значение), // одноаргументный инициализирующий конструктор
имя_объекта(знач1, знач2), // 2-х аргументный инициализирующий конструктор
имя_объекта1(имя_объекта2); // копирующий конструктор
Например, для класса Rational это будет выглядеть так:
Rational a1, // пустой конструктор
a2(2), // одноаргументный инициализирующий конструктор
a3(2, 5); // 2-х аргументный инициализирующий конструктор
Rational b(a1); // копирующий конструктор; эквивалентная запись –
// Rational b = a1;
При определении массива объектов для каждого элемента массива будет вызван пустой конструктор. Помимо этого, можно инициализировать значения элементов массива – в соответствии с обычными правилами языка:
имя_класса имя_объекта[количество] = {знач1, знач2, . . .};
знач1, знач2, . . . – константные значения соответствующего класса. Так как в языке не определены константы для создаваемого нового класса, в качестве таких значений используется явный вызов какого-либо конструктора. Это приведет к созданию временного объекта нового типа (класса), который после использования будет уничтожен.
Например, для класса Rational это выглядит так:
Rational mas[4] = {Rational(), // пустой конструктор
Rational(2), // одноаргументный конструктор
Rational(3, 8), // 2-х аргументный конструктор
Rational(a1) // копирующий конструктор
};
Если определен указатель на новый класс, объект может быть построен динамически с помощью оператора new. Использование оператора традиционное:
имя_класса *имя_объекта;
имя_объекта = new имя_класса; – выделяется память под один экземпляр класса; будет вызван пустой конструктор
имя_объекта = new имя_класса(арг, . . .); – также выделяется память под один экземпляр; для его инициализации будет вызван указанный конструктор
имя_объекта = new имя_класса [количество]; – выделяется память под массив экземпляров; для каждого экземпляра массива будет вызван пустой конструктор
Примеры для класса Rational:
Rational *p1, *p2, *p3;
p1 = new Rational; // инициализация пустым конструктором
p2 = new Rational(2, 3); // инициализация 2-х аргументным конструктором
p3 = new Rational[5]; // массив из 5 элементов; для каждого элемента вызывается
// пустой конструктор
