Xreferat.com » Рефераты по информатике и программированию » Объективное программирование

Объективное программирование

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

#include

#include


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 - передается по значению,

// поэтому может модифицироваться без изменения исходного объекта

//-------------------------------------------------------dat operator+(dat p,int n)

{

while (n-- !=0) p.next(p); // Вызов функции next для объекта p

return(p); // Возврат копии объекта x

}


//------ Операция "целое + дата" -----------------------------//1. Дружественная элемент-функция с полным списком аргументов

//2. Второй операнд класса dat - передается по значению,

//поэтому может модифицироваться без изменения исходного объекта

//-------------------------------------------------------dat operator+(int n, dat p)

{

while (n-- !=0) p.next(); // Вызов функции next для объекта p

return(p); // Возврат копии объекта p

}


//-------------------------------------------------------

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];

clrscr();

e = a++;

d=b+15;

for (i=0; i<10; i++)

p[i] = p[i] + i;

delete[10] p;

}


Многие из переопределяемых операций представляют собой аналог некоторого конвейера, по которому продвигается объект в процессе обработки. Такие операции в качестве одного из операндов и в качестве результата имеют объект одного класса. Вышеприведенные операции с датами как раз являются таковыми. Но преобразование объекта может производиться в таких операциях двумя разными способами. При этом возникают некоторые особенности в вызове конструкторов и деструкторов, на которых необходимо остановиться.


В рассмотренном выше примере одним из параметров элементафункции - объект класса dat передается по значению, аналогично передается и результат операции. Эти два объекта определены неявно и создаются путем копирования из других объектов. Поэтому конструкторы для них не вызываются. Однако при уничтожении этих объектов производится вызов деструкторов. Таким образом, при проектировании класса и передаче его объектов по значению необходимо учитывать эти "лишние" объекты и деструкторы. Перечислим возможные случаи возникновения и уничтожения объектов в функции:

- объект -формальный параметр - создается в стеке, его значение представляет собой копию соответствующего фактического параметра, соответственно, конструктор для него не вызывается;

- автоматический объект x в теле функции создается в стеке перед вызовом функции. Если он инициализируется копией другого объекта (например, текущего), то конструктор для него не вызывается:


dat x = *this;


В противном случае вызывается конструктор с соответствующим набором параметров:


dat x;

dat x("13-JUL-1990");


- в любом случае перед выходом из функции вызывается деструктор для автоматического объекта;

- если функция имеет формальный параметр - объект класса, то

для него вызывается деструктор после выхода из функции (если это

переопределяемый оператор, то после вычисления выражения);

- если функция возврашает объект по значению (а не по явной

или неявной ссылке), то функция получает дополнительный неявный

параметр - ссылку на результат (см. "Неявные ссылки"), а по оператору return производится копирование возвращаемого объекта в

объект-результат по заданной ссылке. Однако при вызове такой

функции транслятор может по-разному формировать эту ссылку:

- если производится прямое присваивание результата функции,

то передается ссылка на объект в левой части операции присваивания;

- в остальных случаях на каждый вызов функции (по синтаксису

программы) вызывающей функцией формируется дополнительный автоматический объект. Конструктор для него не вызывается, так как он

формируется копированием результата функции, а деструктор вызывается при выходе из вызывающей функции, как для обычного автоматического объекта.


Наиболее эффективным способом работы с объектом является передача его на вход (формальный параметр) и выдача на выход в качестве ссылки (преимущественно неявной). Однако в этом способе

все изменения, производимые при выполнении операции, происходят в

исходном объекте. Это не согласуется с интерпретацией большинства

бинарных операций, где результат является отдельным элементом

данных (объектов), а операнды не меняются. В качестве примера

рассмотрим вариант операции сложения "дата + целое", в котором

исходная дата увеличивается на заданное значение и одновременно является результатом операции.


class dat

Если Вам нужна помощь с академической работой (курсовая, контрольная, диплом, реферат и т.д.), обратитесь к нашим специалистам. Более 90000 специалистов готовы Вам помочь.
Бесплатные корректировки и доработки. Бесплатная оценка стоимости работы.

Поможем написать работу на аналогичную тему

Получить выполненную работу или консультацию специалиста по вашему учебному проекту
Нужна помощь в написании работы?
Мы - биржа профессиональных авторов (преподавателей и доцентов вузов). Пишем статьи РИНЦ, ВАК, Scopus. Помогаем в публикации. Правки вносим бесплатно.

Похожие рефераты: