Объективное программирование
int day,month,year;
public:
void next(); // Элемент-функция вычисления
// следующего для
dat& operator+(int); // Операция "дата + целое"
// с неявным операндом через this
//------ Операция "дата + целое" ------------------------------//1. Дружественная элемент-функция с полным списком аргументов
//2. Альтернативный вариант предыдущей функции
//3. Первый операнд класса dat - неявная ссылка на фактический
// параметр, значение меняется при выполнении операции
//4. Тело функции непосредственно в определении класса.
//-------------------------------------------------------friend dat& operator+(dat& p,int n)
{
while (n-- !=0) p.next();// Вызов функции next для объекта p
// по неявной ссылке на него.
return(p); // Возврат неявной ссылки неа p
}
// Операция "целое + дата" ------------------------------------//1. Дружественная элемент-функция с полным списком аргументов
//2. Второй операнд класса dat - неявная ссылка на фактический
// параметр, значение меняется при выполнении операции.
//3. Тело функции непосредственно в определении класса.
//-------------------------------------------------------
friend dat& operator+(int n, dat& p)
{
while (n-- !=0) p.next(); // Вызов функции next для объекта p
// по неявной ссылке на него.
return(p); // Возврат неявной ссылки на p
}
//-------------------------------------------------------
dat(); // Конструкторы
dat(int,int,int); // (см. предыдущие примеры)
dat(char *); //
~dat(); // Деструктор
}; // (см. предыдущие примеры)
//------ Операция "дата + целое" -------------------------------//1. Элемент-функция с неявным первым аргументом по ссылке this
//2. Меняется значение текущего объекта
//3. Результат - неявная ссылка на текущий объект
//--------------------------------------------------------dat& dat::operator+(int n)
{
while (n-- !=0)
next(); // Вызов функции next с текущим объектом this
return(*this); // Возврат неявной ссылки на объект (this)
}
//---------------------------------------------------------
void main()
{
int i;
dat a;
dat b(17,12,1990);
dat c(12,7);
dat d(3);
dat e;
dat *p = new dat[10];
e = a++;
d=b+15;
for (i=0; i<10; i++)
p[i] + i;
delete[10] p;
}
Лекция 5. Особенности переопределения различных операций
-------------------------------------------------------
Одной из важных возможностей использования переменных базовых типов в операциях является их преобразование к другим типам,
которое может производиться неявно (в бинарных арифметических
операциях и при присваивании), либо с использованием операции явного преобразования типа. Если преследовать целью достижение при
добавлении новых классов всей полноты свойств базовых типов данных, то аналогичные преобразования необходимо ввести и для этих
классов. Далее рассмотрим два возможных способа такого преобразования - стандартный, преобразование объекта класса к переменной
базового типа данных, и нестандартный - преобразование переменной
базового типа данных или объекта класса к объекту другого класса.
5.1 Преобразование к базовому типу данных
----------------------------------------
В качестве примера рассмотрим неявное преобразование объекта класса dat к базовым типам данных int и long. Сущность его заключается в вычислении полного количества дней в дате, заданной входным объектом (long) и количества дней в текущем году в этой же дате (int). Для задания этих операции необходимо переопределить в классе dat одноименные операции int и long. Переопределяемые операции задаются соответствующими элементами-функциями без параметров, ссылка на текущий объект входного класса передается через неявный параметр this. Тип результата совпадает с базовым типом, к которому осуществляется приведение и поэтому не указывается.
static int days[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
class dat
{
int day,month,year;
public:
operator int(); // Преобразование dat в int
operator long(); // Преобразование dat в long
long operator -(dat &p); // Операция dat-dat вычисляет
// разность дат в днях
dat(); // Конструкторы
dat(int,int,int); //
dat(char *); //
~dat(); // Деструктор
};
//------ Преобразование dat в int -----------------------------// Используется ссылка на текущий объект this
//------------------------------------------------------- dat::operator int()
{
int r; // Текущий результат
int i; // Счетчик месяцев
for
(r=0, i=1; i r
+= days[month]; // месяцах if
((month>2) && (year%4==0)) r++; // Високосный
год r
+= day; // Дней в
текущем месяце return(r); } //------
Преобразование
dat в long ---------------------------// Используется
ссылка на текущий
объект this //------------------------------------------------------
dat::opertor long() { long
r; // Текущий
результат r
= 365 * (year-1) // Дней в
предыдущих
полных годах r
+= year / 4; // Високосные
года r
+= (int)(*this); // Дней в
текущем году
- предыдущая
// операция
(явное преобразование return(r);
// dat в int } //--------
Операция вычисления
разницы двух
дат ---------------// Первый
операнд по
ссылке на текущий
объект this //
Второй операнд
по неявной
ссылке p //-------------------------------------------------------long
dat::operator-(dat& p) { return((long)(*this)
- (long)p); // Преобразовать
оба объекта
// к типу
long и вычисл. разность } void
main() { dat
a("12-05-1990"); // Дата,
заданная текстовой
строкой dat
b; // Текущая
дата int
c; long
d; //
Явное преобразование
к long printf("С
12-05-1990 прошло %4ld
днейn",(long)b-(long)a); //
Явное преобразование
к int printf("В
этом году прошло
%3d днейn",(int)b); //
Неявное преобразование
при присваивании c
= b; d
= b - a; // Операция
dat-dat printf("С
12-05-1990 прошло %4ld
днейn",d); printf("В
этом году прошло
%3d днейn",c); } 5.2
Преобразование
переменной
к объекту класса
--------------------------------------------- Данный
способ не является
стандартным
и требует проверки
работоспособности
в используемом
компиляторе.
Он основан на
том факте,
что при компиляции
явного или
неявного
преобразования
объекта класса
к базовому типу
данных "xxx" вызывается
переопределяемая
операция "operator
xxx()". Соответственно,
при явном или
неявном преобразовании
к классу "zzz"
должна
вызываться
переопределяемая
операция "operator
zzz". Логично, что
такая операция
должна быть
определена
в классе "zzz".
Но тогда имя
соответствующей
элемента-функции
будет "zzz::zzz", что
соответствует
конструктору.
Таким образом,
если необходимо
определить
явное или неявное
преобразование
от базового
типа или класса
"xxx" к классу
"zzz", то
в классе "zzz"
необходимо
определить
конструктор class
zzz
{
int par_zzz;
----------------- входной
тип (класс)
zzz(xxx p); или
zzz(xxx& p);
L-------------------- выходной
тип (класс)
}; void
zzz::zzz(xxx &p)
{
par_zzz = ... p.par_xxx ...; элемент
объекта-----
L-------элемент объекта выходного
класса
входного класса
} class
xxx
{
friend class zzz;
int par_xxx;
}; со
следующими
свойствами: -
объект класса
"zzz", который
является выходным
при преобразовании
типов доступен
как в любом
конструкторе
через ссылку
на текущий
объект this; -
элементам
выходного
объекта (например,
par_zzz) должны
быть
присвоены
значения с
явным или неявным
использованием
ссылки
this
this->par_zzz = ...
(*this).par_zzz = ...
par_zzz = ... -
объект или
переменная
того класса
или базового
типа, которые
являются входными
в преобразовании
типов, доступны
через
соответствующий
формальный
параметр, который
может быть как
значением
(копией объекта
или переменной),
так и неявной
ссылкой. Значение
переменной
или элементов
входного объекта
могут использоваться
как аргументы
при преобразовании
типов; -
для доступа
из функции
класса "zzz" к
приватной части
объекта класса
"xxx" класс "zzz"
должен быть
объявлен
дружественным в
определении
класса "xxx". В
качестве примера
рассмотрим
обратное
преобразование
базового типа
long к типу dat - количество
дней от начала
летоисчисления
преобразуется
к дате. Здесь
же рассмотрим
другой класс -
man, в котором одним
из элементов
приватной части
является дата. static
int days[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 }; class
dat { int
day,month,year; public:
dat(long); //
Преобразование
long в dat
dat(man&); //
Преобразование
man в dat dat();
// Конструкторы
dat(int,int,int); //
dat(char *); // ~dat();
// Деструктор }; class
man { friend
class dat; // Класс dat
дружественен ...
// классу man