Иногда требуются исключения из этого правила, когда к "приватной" части объекта класса требуется доступ из некоторой отдельной функции, либо из всех элементов-функций другого класса, либо из переопределяемой в другом классе операции. Тогда в определении класса, к объектам которого разрешается такой доступ, должно быть объявление функции или другого класса "дружественным". Это согласуется с тем принципом, что сам класс определяет права доступа к своим объектам "со стороны".
Объявление дружественной функции предствляет собой прототип функции, объявление переопределяемой операции или имя класса, которым разрешается доступ, с ключевым словом friend впереди. Общая схема объявления такова:
class A
{
int x; // Приватная часть класса
...
friend class B; // Функции класса B дружественны классу A
// (имеют доступ к приватной части A)
friend void C::fun(A&);
// Элемент-функция fun класса C имеет
// доступ к приватной части A
friend void xxx(A&,int);
// Функция xxx дружественна классу A
friend void C::operator+(А&);
// Переопределяемая в классе C операция
// <объект C>+<объект A> дружественна
// классу A
class B
{
public: int fun1(A&);// Необходим доступ к приватной части A
void fun2(A&);// ----------------------------------- }
class C
{
public: void fun(A&);// ------------------------------------ void operator+(A&);//------------------------------- ....
}
К средствам контроля доступа относятся также объявления элементов-функций постоянными (const). В этом случае элементфункция
не имеет права изменять значение текущего объекта, с которым она
вызывается. Заголовок функции при этом имеет вид
void dat::put() const
{
}
3.4 Статические элементы класса
------------------------------
Иногда требуется определить данные, которые относятся ко
всем объектам класса. Это требуется, если объекты класса разделяют некоторый общий ресурс, связаны в общий список и т.д.. С этой
целью в определении класса могут быть введены статические элементы - переменные. Такой элемент сам в объекты класса не входит, зато при обращении к нему формируется обращение к внешней переменной с именем
<имя класса>::<имя элемента>
соответствующего типа. Доступность ее определяется стандартным образом в зависимости от размещения в приватной или общей части класса. Сама переменная должна быть явно определена в программе и инициализирована.
Пример: объекты класса связаны в односвязный список
--------------------------------------------------class list
{
static list *fst; // Ссылка на первый элемент
static list *lst; // Ссылка на последний элемент
list *next; // Ссылка на следующий элемент
.... .....
public:
void insfst(); // Вставить в начало списка
void inslst(); // Вставить в конец списка
void show(); // Просмотр всех объектов
void extract(); // Исключть из списка
list(); // Конструктор
~list(); // Деструктор
}
list list::fst=NULL; // Определение статических элементов
list list::lst=NULL;
//-------------------------------------------------------void insfst()
{
next = NULL;
if (fst==NULL)
fst=lst=this;
else
{ next=fst; fst=this; }
}
//-------------------------------------------------------void inslst()
{
next = NULL;
if (fst==NULL)
fst=lst=this;
else
{ lst->next=this; lst=this; }
}
//-------------------------------------------------------void list::extract()
{
list *p,*pred; // Поиск текущего и предыдущего
for (pred=NULL,p=fst; p !=NULL; // в списке
pred=p,p=p->next)
if (p=this) break; // Если найден - выход
if (p !=NULL)
{ // Найден - исключение из списка
if (pred==NULL)
fst = next;
else
pred->next=next;
}
}
//-------------------------------------------------------void list::show()
{
list *p;
for (p=fst; p !=NULL; p=p->next)
{ ...вывод информации об объекте... }
}
//------ При создании объекта он помещается в список -----------list::list()
{
insfst();
}
//------ При уничтожении объекта он исключается из списка ------list::~list()
{
extract();
}
Примером использования внутреннего списка объектов является
система всплывающих окон. При выполнении операций над одним из
окон часто требуется произвести некоторые действия с другими окнами, то есть в любой момент программе должен быть известен
список созданных объектов - окон. Последовательность объектов в
списке может отражать последовательность отображения окон на экране. Тогда при выполнении операции "всплытия" окна необходимо
изменить посложение соответствующего объекта в списке. Естественно, что конструктор и деструктор объекта включают его в список и
исключают.
Статическими могут быть объявлены также и элементы-функции.
Их "статичность" определяется тем, что вызов их не связан с конкреетным объектом и может быть выполнен по полному имени. Соответственно в них не используются неявная ссылка this. Они вводятся, как правило, для выполнения действий, относящихсмя ко всем объектам класса. Для предыдущего примера
class list
{ ...
static void show(); // Стaтическая функция просмотра
} // всего списка объектов
//-------------------------------------------------------static void list::show()
{
list *p;
for (p=fst; p !=NULL; p=p->next)
{ ...вывод информации об объекте... }
}
//-------------------------------------------------------void main()
{ ...
list::show(); // Вызов функции по полному имени
}
Лекция 4. Переопределение операторов.
------------------------------------
Напомним, что под классом понимается определяемый программистом тип данных, используемый наравне со стандартными базовыми типами. С точки зрения "равноправия" вновь вводимого типа данных желательно иметь возможность расширения (переопределения) операций языка, в которых один или несколько операндов могут быть объектами этого класса Это достигается введением элемента-функции специального вида, обращение к которой компилятор формирует при трансляции такой операции. Естественно, что такая функция должна иметь результат (значение или неявная ссылка), если предполагается использование этой операции внутри другого выражения.
Переопределение операций осуществляется в рамках стандартного синтаксиса языка Си, то есть обозначение операций и количество операндов остается прежним.
Необходимо отметить также и тот факт, что для каждой комбинации типов операндов переопределяемой операции необходимо ввести отдельную функцию, то есть транслятор не может производить перестановку операндов местами, даже если базовая операция допускает это. Например, при переопределении операции сложения объекта
класса dat с целым необходимо две функции dat+int и int+dat.
Для переопределения операции используется особая форма элемента-функции с заголовком такого вида:
operator<операция>( <список параметров-операндов> )
При этом имя функции состоит из ключевого слова operator и
символа данной операции в синтаксисе языка Си.
Список формальных параметров функции является списком операндов (количество, типы, способы передачи) операции.
Результат функции (тип, способ передачи) является результатом переопределяемой операции. Способ передачи и тип указывают на
возможности использования результата в других выражениях.
Имеется два способа описания функции, соответствующей переопределяемой операции:
- если функция задается как обычная элемент-функция класса,
то первым аргументом соответствующей операции является объект,
ссылка на который передается неявным параметром this;
- если первым аргументом переопределяемой операции не является объект некоторого класса, либо функция получает на вход не
ссылку на объект, а сам объект, тогда соответствующая элементфункция должна быть определена как дружественная с полным списком
аргументов. Естественно, что полное имя дружественной функцииоператора не содержит при этом имени класса.
В качестве примера рассмотрим доопределение стандартных операций над датами.
#include <stdio.h>
#include <conio.h>
#include <dos.h>
static int days[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
class dat
{
int day,month,year;
public:
void next(); // Элемент-функция вычисления
// следующего для
dat operator++(); // Операция ++
dat operator+(int); // Операция "дата + целое"
// с неявным операндом через this
friend dat operator+(dat,int) // Операции с явной передачей
friend dat operator+(int, dat) // всех параметров по значению
dat(); // Конструкторы
dat(int,int,int); // (см. предыдущие примеры)
dat(char *); //
~dat(); // Деструктор
}; // (см. предыдущие примеры)
//------ Функция вычисления следующего дня --------------------// Используется ссылка на текущий объект this,
// который изменяетсмя в процессе операции
//-------------------------------------------------------void dat::next()
{
day++;
if (day > days[month])
{
if ((month==2) && (day==29) && (year%4==0)) return;
day=1;
month++;
if (month==13)
{
month=1;
year++;
}
}
}
//------ Операция инкремента даты -----------------------------//1. Форма элемента-фукнции с неявным операндом по ссылке this
//2. Возвращает копию входного объекта (операнда) до увеличения
//3. Соответствует операции dat++ (увеличение после использования)
//4. Замечание: для унарных операций типа -- или ++ использование
// их до или после операнда не имеет значения (вызывается одна
// и та же функция).
//-------------------------------------------------------
dat dat::operator++()
{
// Создается временный объект
dat x = *this; // В него копируется значение текущего объекта
dat::next(); // Увеличивается значение текущего объекта
return(x); // Возвращается временный объект
}
//------ Операция "дата + целое" ------------------------------//1. Элемент-функция с неявным первым аргументом по ссылке this
//2. Входной объект не меняется, результат возвращается копией
// внутреннего автоматического объекта x
//-------------------------------------------------------dat dat::operator+(int n)
{
dat x;
x = *this; // Копирование текущего объекта в x
while (n-- !=0) x.next(); // Вызов функции next для объекта x
return(x); // Возврат копии объекта x
}
//------ Операция "дата + целое" ------------------------------//1. Дружественная элемент-функция с полным списком аргументов
//2. Альтернативный вариант предыдущей функции
//3. Первый операнд класса dat - передается по значению,