Методы программирования
(2 семестр)
Раздел 2. Лекция 06 Пример разработки класса “вектор”. Перегрузка операций
Нижегородский государственный университет
им. Н.И. Лобачевского
Факультет вычислительной математики и кибернетики
Краткое содержание предыдущей серии
Конструктор – специальный метод, который вызывается при создании объекта. Различают 4 вида конструкторов (по умолчанию, инициализатор, преобразования типа, копирования).
Деструктор – специальный метод, который вызывается при уничтожении объекта. Деструктор бывает только 1.
Общая рекомендация: в случае, если Ваш класс содержит поля-указатели, необходимо реализовывать конструкторы и деструкторы самостоятельно, не полагаясь на компилятор.
Дальнейшее изучение
Сегодня мы посмотрим на пример создания класса и изучим средства перегрузки операций.
Итак, за дело!
Класс «вектор». Постановка задачи
Задача: создать класс, представляющий вектор и реализующий основные операции над векторами.
A
A[1]
A[i]
A[n]
+
1
2
3
Класс «вектор». Проектирование данных
Проектирование данных:
Основные данные вектора – массив координат вещественного типа.
Количество координат заранее неизвестно – массив должен быть динамическим. Значит, необходимо помнить еще и размер вектора (количество координат).
private:
double *pVector; // массив координат
unsigned int iSize; // количество координат
Класс «вектор». Проектирование операций
Проектирование операций:
Получение размера (количества координат).
Получение / установка i-ой координаты.
Сложение векторов (аналог операции +).
Вычитание векторов (аналог операции -).
Сложение векторов (аналог операции +=).
Вычитание векторов (аналог операции -=).
Операции ++, -- (чисто иллюстративные, инкремент и декремент всех координат).
Скалярное произведение векторов.
Класс «вектор». Объявление
class TVector {
private:
double *pVector; // Массив координат
int iSize; // Размер вектора
public:
TVector(int s=10); // конструктор
TVector(const TVector &v); // конструктор копирования
~TVector(); // деструктор
int GetSize() const { return iSize; } // размер вектора
double GetValue(int pos) const; // взять элемент
void SetValue(int pos, double value); //положить элемент
// векторные операции
TVector Add(const TVector &v) const; // сложение (+)
TVector AddEq(const TVector &v); // сложение (+=)
double Mult(const TVector &v) const; // скалярное произв.
// ввод-вывод
void Print() const; // вывод на экран
void Input(); // ввод с клавиатуры
};
Класс «вектор». Конструктор
// Здесь не нужно 2-ой раз указывать
// значение по умолчанию
TVector::TVector(int s) {
iSize = s;
pVector = new double[s];
for (int i = 0; i < s; i++)
pVector[i] = 0;
}
Класс «вектор». Конструктор копирования
TVector::TVector(const TVector& v) {
iSize = v.GetSize();
pVector = new double[iSize];
for (int i = 0; i < iSize; i++)
pVector[i] = v.GetValue(i);
}
Класс «вектор». Деструктор
TVector::~TVector() {
delete [] pVector;
}
Класс «вектор». Set и Get
double TVector::GetValue(int pos) const {
return pVector[pos];
}
void TVector::SetValue(int pos, double value) {
pVector[pos] = value;
}
Внимание: за рамками примера остается очень
важный момент, связанный с обработкой
ошибок, например, выхода за границы диапазона
координат вектора!
Класс «вектор». Сложение векторов +
// сложение (+)
TVector TVector::Add(const TVector &v) const {
double dTemp;
TVector temp(iSize);
for (int i = 0; i < iSize; i++) {
dTemp = pVector[i] + v.GetValue(i);
temp.SetValue(i, dTemp);
}
return temp;
}
Внимание: за рамками примера остается очень
важный момент, связанный с обработкой
ошибок, например, несовпадение размеров векторов!
Класс «вектор». Сложение векторов +=
// сложение (+=)
TVector TVector::AddEq(const TVector &v) {
for (int i = 0; i < iSize; i++)
pVector[i] = pVector[i] + v.GetValue(i);
return *this;
}
Внимание: за рамками примера остается очень
важный момент, связанный с обработкой
ошибок, например, несовпадение размеров векторов!
Класс «вектор». Скалярное произведение
// скалярное произведение
double TVector::Mult(const TVector &v) const {
double p = 0;
for (int i = 0; i < iSize; i++)
p = p + pVector[i] * v.GetValue(i);
return p;
}
Класс «вектор». Вывод на экран
// вывод на экран
void TVector::Print() const {
for (int i = 0; i < iSize; i++)
printf(“%f \n”, pVector[i]);
}
// ввод с клавиатуры
void TVector::Input() {
for (int i = 0; i < iSize; i++)
scanf(“%f \n”, &pVector[i]);
}
Класс «вектор». Что куда писать?
Объявление класса: файл vector.h
Реализация методов: файл vector.cpp
Примечание:
в файл vector.cpp добавляем #include “vector.h”
vector.h
vector.cpp
Класс «вектор». Пример использования
#include “vector.h”
void main () {
TVector v3(20), v2;
for (int i=0; i
}
TVector v1 = v3; // все хорошо
v2 = v3; // все плохо! v2 и v3 - // близнецы
v1.AddEq(v3); // все хорошо
v1.Print();
}
Класс «вектор». Анализ результатов
Создан класс TVector без контроля ошибок.
Реализован конструктор копирования, но в случае присваивания в уже созданные ранее объекты происходит создание объектов-близнецов с общими данными-координатами (v2 = v3).
Реализован доступ к элементу, но он неестественный хотелось бы v2[i], а нужно v2.GetValue(i).
Реализованы операции сложения, но их запись неестественна;
хотелось бы v1 = v2 + v3, а надо v1 = v2.Add(v3).
Вывод: нужны средства, упрощающие форму записи и устраняющие ошибки (см. пункт 2).
Перегрузка операций
Перегрузка операций – специальный синтаксический механизм C++, который позволяет использовать стандартные операции языка не только для переменных базовых типов, но и для объектов.
При этом имеется возможность указать, каким именно образом операции должны отрабатывать.
Перегрузка операций – написание специальных функций, отвечающих за выполнение той или иной операции.
Что значит “перегрузить операцию”?
Перегрузка операций – указание того, как данная операция должна применяться к объектам этого класса.
Некоторые ограничения:
нельзя перегружать операции “.”, “::”, “sizeof”.
Ограничения совершенно разумны, очевидно, что перегрузка этих операций вряд ли может пригодиться.
Правила перегрузки операций
Перегрузка операций осуществляется с помощью методов специального вида (функций-операций) и подчиняется следующим правилам:
при перегрузке операций сохраняются количество аргументов, приоритеты операций и правила ассоциации (справа налево или слева направо), используемые в стандартных типах данных;
для стандартных типов данных переопределять операции нельзя;
функции-операции не могут иметь аргументов по умолчанию;
функции-операции наследуются (за исключением =);
функции-операции не могут определяться как static.
Способы перегрузки операций
Операция может быть перегружена при помощи написания специальной функции 3-мя способами:
метод класса;
дружественная функция;
обычная функция.
Наиболее естественным с точки зрения объектно-ориентированного подхода представляется первый способ, именно он будет рассмотрен в лекциях.
Общая рекомендация при перегрузке операций
При перегрузке операций необходимо большое внимание уделять семантике (смыслу) операции.
Так, если в языке программирования операция + для стандартных типов данных что-то складывает, то и в Вашем классе перегруженная операция + должна что-то складывать. В противном случае, программа становится непонятной при просмотре, а классом тяжело правильно воспользоваться.
Общий вид метода для перегрузки операции
<тип_рез> operator<знак_оп>(<список_парам>);
специальное ключевое слово
тип результата
операции
знак
операции
список параметров
имя метода
Перегрузка унарных операций
Унарная операция – 1 аргумент.
1 аргумент приходит через указатель this.
Вывод: список параметров пуст!
Перегрузим для класса вектор унарный минус:
TVector& TVector::operator-() {
for (int i = 0; i < iSize; i++)
pVector[i] = (-1)*pVector[i];
return *this;
}
Теперь мы можем написать:
TVector v1(20);
(-v1).Print(); (-(-v1)).Print();
Перегрузка унарных операций
Перегрузка была некорректной!
Необходимо возвращать создавать временный объект и его возвращать, иначе минус портит данные.
Перегрузка унарных операций. Особый случай – операции ++ и --
Особый случай – операции ++ и --, которые имеют 2 формы (префиксную и постфиксную).
Вопрос: как компилятор различает, какую из форм Вы перегрузили?
Ответ: для постфиксного инкремента и декремента необходимо включить в список параметров
1 фиктивный параметр типа int.
// ++v
TVector& TVector::operator++() {…}
// v++
const TVector TVector::operator++(int) {…}
Постинкремент должен быть реализован посредством преинкремента
Перегрузка бинарных операций
Бинарная операция – 2 аргумента.
1 аргумент приходит через указатель this (левая часть – первый аргумент).
2 аргумент должен приходить через параметр метода (правая часть – второй аргумент).
Вывод: список параметров состоит из 1 параметра.
Перегрузка бинарных операций. Операция +=
// Перегрузим для класса вектор операцию +=
TVector& TVector::operator+=(const TVector& v)
{
for (int i = 0; i < iSize; i++)
pVector[i] += v.GetValue(i);
return *this;
}
// Теперь мы можем написать:
TVector v4(5), v5(5);
for (i=0; i < 5; i++) {
v4.SetValue(i, i);
v5.SetValue(i, 2*i);
}
v4+=v5; v4.Print(); v4+=v5+=v5; v4.Print();
Перегрузка бинарных операций. Операция +
// Перегрузим для класса вектор операцию +
TVector TVector::operator+(const TVector& v) {
TVector temp(iSize);
for (int i = 0; i < iSize; i++)
temp.SetValue(i, pVector[i]+v.GetValue(i));
return temp;
}
// Теперь мы можем написать:
TVector v4(5), v5(5);
for (i=0; i < 5; i++) {
v4.SetValue(i, i);
v5.SetValue(i, 2*i);
}
TVector v6 = v4 + v5 + v5; v6.Print();
Перегрузка бинарных операций. Осторожно, реализацию писал крупный специалист!
При перегрузке бинарных операций нужно обращать внимание на существенное отличие операций вида + и +=.
Первая из операций должна вернуть в качестве результата новый объект, а вторая – свой первый операнд.
При возврате нового объекта необходимо обращать внимание на использование ссылок и выделения памяти для временного объекта (см. соображения о возможных ошибках в лекции 3).
Перегрузка бинарных операций. Операция * (скалярное произведение)
// Перегрузим для класса вектор операцию * (скалярное произведение)
double TVector::operator*(const TVector& v) {
double res = 0;
for (int i = 0; i < iSize; i++)
res += pVector[i] * v.GetValue(i);
return res;
}
// Теперь мы можем написать:
TVector v4(5), v5(5);
for (i=0; i < 5; i++) {
v4.SetValue(i, i);
v5.SetValue(i, 2*i);
}
double a = v4 * v5;
printf("\n a = %f ", a);
Перегрузка бинарных операций. Операция * (умножение вектора на скаляр)
// Перегрузим для класса вектор операцию * (вектор* скаляр)
TVector TVector::operator*(double d) {
TVector temp(iSize);
for (int i = 0; i < iSize; i++)
temp.pVector[i] = pVector[i] * d;
return temp;
}
// Теперь мы можем написать:
TVector v4(5);
for (i=0; i < 5; i++) {
v4.SetValue(i, i);
}
TVector v6 = v4 * 3;
v6.Print();
Перегрузка бинарных операций
Иногда приходится реализовывать перегруженные функции как отдельные функции.
Пример:
a = b * 2 и a = 2 * b.
Перегрузка операции индексирования
Проблема: писать v.GetValue(i) и v.SetValue(i, i*i) очень неудобно. Хотелось бы писать просто v[i] и в первом, и во втором случае.
Решение: перегрузка операции индексирования.
Рекомендация: перегружайте операцию индексирования для тех (и только для тех) классов, для которых она имеет содержательный смысл!
Как перегружать? Операция индексирования имеет 1 параметр (индекс элемента). Она должна возвращать ССЫЛКУ на запрашиваемый элемент.
Перегрузка операции индексирования
Смысл использования ссылки:
если мы возвращаем ссылку на элемент, то у нас будут работать как конструкции вида a = v[i], так и конструкции вида
v[i] = a.
В противном случае конструкции a = v[i] работать будут, а v[i] = a – не будут.
Перегрузка операции индексирования для класса TVector
double& TVector::operator[](int i) {
return pVector[i];
}
// Теперь мы можем написать:
TVector v4(5), v5(5);
for (i=0; i < 5; i++) {
v4[i] = i;
v5[i] = v4[i] + 2*i;
}
v4.Print();
v5.Print();
Перегрузка операции присваивания
Перегрузка операции присваивания – важный элемент в разработке класса.
Проблема: в случае применения в тексте программы присваивания для двух переменных объектного типа компилятор производит простое копирование полей!
Если класс имеет поля-указатели, применяемый компилятором метод присваивания приводит к потере памяти, проблеме возникновения “близнецов” и, в конечном счете, серьезным сбоям в работе программы.
Перегрузка операции присваивания. Пример неправильного функционирования. Шаг 1
TVector a(5), b(6);
iSize = 5
pVector
a
iSize = 6
pVector
b
Перегрузка операции присваивания. Пример неправильного функционирования. Шаг 2
TVector a(5), b(6);
…
a = b;
iSize = 6
pVector
a
iSize = 6
pVector
b
Операция присваивания и конструктор копирования
Все это сильно напоминает проблемы, которые возникали при отсутствии конструктора копирования.
Вопрос: когда вызывается конструктор копирования, а когда операция присваивания?
Ответ: конструктор копирования вызывается, если происходит создание нового объекта. Если выполняется присваивание в уже существующий (ранее созданный) объект, то вызывается операция присваивания.
Операция присваивания и конструктор копирования. Примеры
TVector v1(10);
TVector v2 = v1; // Конструктор копирования
v1 = v2; // Операция присваивания
Более сложные примеры связаны с передачей (возвратом) объектов в функцию (из функции). При выполнении этих операций при необходимости создания нового объекта вызывается конструктор копирования.
Операция присваивания.
Когда и как перегружать?
Ответ очевиден: если в классе есть поля-указатели, необходимо перегружать операцию присваивания.
Заголовок метода:
const <Имя класса>& operator=(const <Имя класса>&);
Реализация: в отличие от конструктора копирования, при выполнении операции присваивания в объекте, в который осуществляется присваивание, уже есть данные. Поэтому, в отличие от конструктора копирования, в первую очередь необходимо освободить занятую память.
Перегрузка операции присваивания для класса TVector
const TVector& TVector::operator=(const TVector& v) {
delete []pVector;
iSize = v.GetSize();
pVector = new double[iSize];
for (int i = 0; i < iSize; i++)
pVector[i] = v.GetValue(i);
return *this;
}
// Теперь мы можем написать:
TVector v1(10);
TVector v2 = v1; // Конструктор копирования
v1 = v2; // Операция присваивания
Внимание,
ошибка!
Перегрузка операции присваивания для класса TVector. Исправление
const TVector& TVector::operator=(const TVector& v) {
if (this != &v) {
delete []pVector;
iSize = v.GetSize();
pVector = new double[iSize];
for (int i = 0; i < iSize; i++)
pVector[i] = v.GetValue(i);
}
return *this;
}
// Теперь мы можем написать:
TVector v1(10);
v1 = v1; // Операция присваивания
А если
v = v?
Перегрузка операции присваивания
Вариант с проверкой не является единственным.
Варианты:
проверка на совпадение;
копирование указателя, выделение памяти, копирование информации, освобождение указателя;
double* tmpVector = pVector;
iSize = v.GetSize(); pVector = new double[iSize];
for (int i = 0; i < iSize; i++) pVector[i]=v.GetValue(i);
delete []tmpVector;
идиома «Copy-And-Swap»:
void TVector::Swap(TVector& v) { … } // *this <-> v
TVector& TVector::operator=(TVector v) {
Swap(v); return *this;
}
Перегрузка потоковых операций ввода-вывода
Существуют классы потоков в/в ostream, istream.
cout – объект класса ostream, cin – istream.
Потоковые операции << и >> применяются не к объекту пользовательского типа, а к объекту-потоку! cout << v;
Перегрузка << и >> д.б. выполнена в виде friend-функции.
friend ostream& operator<<
(ostream& os, const TVector& v)
friend istream& operator>>
(istream& is, TVector& v)
Перегрузка операции приведения типа
2 варианта приведения типа:
при помощи конструктора с единственным параметром:
TComplex(int _re): re(_re), im(0) {}
Может быть использовано при передаче параметра в функцию.
Можно запретить неявные преобразования при помощи explicit TComplex(int _re): re(_re), im(0) {}
(явные по-прежнему работают)
при помощи operator ТИП_ДАННЫХ()
operator TComplex::int() { return re;}
Замечание: «нет» возвращаемого значения.
1-ый случай: преобразование выполняет класс, к которому приводится аргумент (TComplex –> int нельзя).
2-ой случай: преобразование выполняет исходный класс.
За рамками курса пока остались
Перегрузка операций new и delete
(operator new, пример: “сборка мусора”).
Перегрузка операции вызова функции
(operator ()).
Данные примеры перегрузки используются реже и, будучи хорошо описанными в литературе, могут быть изучены самостоятельно.
Следующая тема
Далее мы рассмотрим, как реализуется в C++ принцип наследования.
Павловская Т.А. C/C++ Программирование на языке высокого уровня.
Ален И. Голуб. Правила программирования на C/C++.
Из книг заимствованы различные идеи, элементы текста.
http://lye.upnet.ru
http://xaxa.h1.ru/jokes.html
Если не удалось найти и скачать доклад-презентацию, Вы можете заказать его на нашем сайте. Мы постараемся найти нужный Вам материал и отправим по электронной почте. Не стесняйтесь обращаться к нам, если у вас возникли вопросы или пожелания:
Email: Нажмите что бы посмотреть
Это сайт презентации, докладов, проектов в PowerPoint. Здесь удобно хранить и делиться своими презентациями с другими пользователями.
