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

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

ВВЕДЕНИЕ В ОБЪЕКТНОЕ ПРОГРАММИРОВАНИЕ

Лекция 1. Объектное программирование как технология программирования

-------------------------------------------------------------

Традиционная технология программирования 70-х годов - структурное

программирование:

- модульное программирование;

- нисходящее программирование;

- структурное проектирование процедур и данных (программирование без

goto).

Язык Паскаль - соответствует указанным принципам и был разработан под

влиянием идей структурного программирования.

Альтернативный подход - восходящее программирование - предполагает в

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

полный набор действий над объектами, которые представлены в данной задаче.

Пример традиционного подхода библиотека стандартных функций.

Следующий шаг - введение в программу объектов. Под объектом

понимается структура данных, которая содержит полную информацию о состоянии

соответствующего физического объекта, который отображается программой. В

Си этому может соответствовать структура struct), в Паскале - запись

(record). Множество объектов одного типа составляют понятие класса.

Объектно-ориентированный подход к разработке программ предполагает, что в

программе устанавливается взаимно-однозначное соответствие между

физическими объектами,

отображаемыми программой, и програмнными объектами, являющимися, по

существу, структурированными переменными (в дальнейшем под термином

"объект" будем понимать программный объект).

Традиционный подход: ---------- переменная тип данных

Объектно-ориентиро- физический программный класс

ванный подход: объект объект объектов

При создании объектов программист определяет множество функций, при

помощи которых (а точнее, исключительно через которые)над объектом

выполняется некоторое допустимое множество операций.

Такие функции должны иметь обязательный параметр - ссылку на текущий

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

частью понятия класса объектов, так как они определяют возможные

действия над объектами одного и того же типа (то есть класса).

Объектно-ориентированные программы можно разрабатывать и с помощью

традиционных языков программирования. Рассмотрим пример определения

объектов типа "дата" на классическом Си.

//------ структура dat - аналог класса объектов "дата" --------typedef

struct dat

{

unsigned day;

unsigned month;

unsigned year;

}

DAT;

//----- набор функций для класса объектов "дата" --------------static int

mm[] = {31,28,31,30,31,30,31,31,30,31,30,31};

//----- Проверка на корректность -----------------------------int

TestData(p)

DAT *p;

//------ Следующая дата ----------------------------------------void

NextData(p)

DAT *p;

{

p->day++;

if (p->day month]) return;

if (p->month ==2 && p->day==29 && p->year %4 ==0) return;

p->day=1;

p->month++;

if (p->month !=13) return;

p->month=1;

p->year++;

}

//------- Следующая дата через n дней --------------------------void

PlusData(p,n)

DAT *p;

int n;

{

while (n-- !=0) NextData(p);

}

//------- Основная программа ---------------------------------

void main()

{

DAT a;

do

{

scanf("%d%d%d", &a.day, &a.month, &a.year);

}

while(TestData(&a) ==0);

PlusData(&a, 17);

}

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

Фактически определение класса объектов как типа данных и известного

набора функций для выполнения операций над переменными этого типа

эквивалентно понятию базового типа данных (БТД) языка программирования.

Единственное отличие класса от БТД заключается в том, что первый

определяется программистом, а второй встроен в определение языка

программирования.

Язык программирования Си++ представляет собой расширение языка Си

для программирования объектов и их классов. При этом использование

классов эквивалентно вплоть до синтаксиса использованию базовых типов

данных:

Понятия классического Си Понятия Си++

------------------------- ----------- БТД:

Класс:

элемент данных языка, для определяемая пользователем

которого известно множество структура, элементы которой

значений, форма представления, являются ранее определен набор операций.

ными типами данных и классами,

и множества функций,оперирующих с ним.

--------------------------------------------------------- Переменная:

Объект:

область памяти, содержащая переменная, содержащая

структуру данных определенного структуру данных, определенную

типа. как класс.

--------------------------------------------------------- Операция:

Переопределение операторов:

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

претируется по отношению к тому тов указанного класса может быть

БТД, к которому относится пере- вызвана в виде одной из стандарт менная

(так операция '+' ных операций языка Си, которая

по-разному интерпретируется для переопределяется, если операндом

переменных типа int и double). ее является объект класса, а не

переменная БТД.

Лекция 2. Дополнительные возможности языка Си++

-----------------------------------------------

Ниже рассмотрим средства, расширяющие классический Си. Хотя

они и не относятся непосредственно к классам, с их помощью можно

реализовать рассмотренные выше принципы объектно-ориентированного

программирования.

2.1. Присваивание структур

------------------------- Операция присваивания может быть

применена к структурам одного типа. В этом случае предполагается их

побайтное копирование

одной в другую. Она (а не ссылка на нее) может быть также фактическим

параметром и результатом функции. Если имеется ссылка на

структуру с именем p, то результатом операции *p является структура в

целом. Таким образом, структура приближается к базовым типам данных в том

смысле, что над ней возможны вышеуказанные операции. Для обозначения

структуры можно также использовать имя

структуры без ключевого слова struct.

struct dat

{ int day,month,year; }

dat NextDat(dat x) // Формальный параметр - структура

{ ... return(x); } // Возвратить структуру как результат

dat Nextdat1(dat *p)

{ ... return(*p); } // Возврат структуры косвенно по ссылке

dat a,b,c,*q; // Ключевое слово struct не используется

void main()

{

q = &b;

a = b; // Прямое присваивание структур

a = *q; // Косвенное присваивание по ссылке

c = NextDat(b); // Присваивание структуры как результата

c = NextDat1(&b); // функции, фактический параметр в

} // NextDat - копия структуры

2.2. Обращения по адресу (неявная ссылка)

----------------------------------------

При работе со структурами большого размера - при передаче их

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

неэффективной операцией. Гораздо эффективнее передавать ссылку на эту

структуру. Для того, чтобы постоянно не указывать операции взятия адреса

и косвенного обращения по ссылке в Си++ введен тип - неявная ссылка:

при определении переменной неявно вводится ссылка, указывающая на эту

переменную. Использование этой переменной в большинстве операций

предполагает косвенное обращение по соответствующей ссылке. При

инициализации такой переменной значением другой переменной создается ссылка

на эту другую переменную. При использовании в любом выражении переменной -

неявной ссылки реально производится косвенное обращение по созданной

ссылке.

Си++ Эквивалент в "классическом" Си

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

-- Инициализация константой -----------------int &a = 5;

int a, *pa =a;

*pa = 5;

//--------------- Инициализация переменной -----------------int x;

int x,*pa;

int &a = x; pa = &x;

a = 5; *pa = 5;

//-------------- Неявная ссылка на структуру ----------------struct dat

struct dat

{ int day,month,year }; { int day,month, year };

dat x; dat x;

dat& b = x; dat* pb = &x;

dat& c = {12,12,1990}; dat cc = {12,12,1990};

dat *pc = &cc;

b.year = 1990; pb->year= 1990;

c.day=b.day+3; pc->day = pb->day+3;

c = b; // Копирование pc->day = pb->day;

// структуры pc->month = pb->month;

pc->year = pb->year;

Наиболее часто неявные ссылки используются при передаче параметров и

результатов функций. В этом случае транслятор сам выбирает, что необходимо

использовать в качестве фактического параметра - переменную или ссылку на

нее, и что используется в качестве результата - ссылка или переменная,

косвенно адресуемая по ссылке. Цель подобных ухищрений будет видна позднее

- при переопределении операторов, а пока можно заметить, что вызов функций,

с

параметрами - обычными значениями и неявными ссылками - синтаксически

идентичен. То же самое касается результатов.

В качестве иллюстрации рассмотрим три примера функций, имеющих в

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

соответственно:

- значением;

- явной ссылкой;

- неявной ссылкой.

Пример 1. Параметры - значения

---------------------------------------------------------dat Inc(dat x)

========> - копирование

{ --------> - ссылка

x.day++;

return(x); ----¬ стек +---+x.day++

} ¦ b =========> x =========¬

L---- +---+ ¦ return(x)

void main() ¦

{ ----¬ стек +---+ --¦-¬ временная

dat a,b,*p; ¦ a day++

{ x->day++

x->day++; ----¬ стек +---+

return(x); г===== b ¦

a = *Inc(Inc(&b)); ¦ ¦ L---- +-¦-+

p = Inc(&b); ¦ ¦ ----¬ ¦return(x)

a = *p; ¦ L-- a ¦

L---

Пример 3. Параметры - неявные ссылки

---------------------------------------------------------dat& Inc(dat&

x) x.day++ неявная ссылка dat* px

{ x.day++

x.day++; ----¬ стек +---+

return(x); г===== b ¦

a = Inc(Inc(b)); ¦ ¦ L---- +-¦-+

p = &Inc(b); ¦ ¦ ----¬ ¦return(px)

a = *p; ¦ L-- a ¦

L---

Сравнение этих примеров показывает следующее:

- при работе с формальным параметром - неявной ссылкой

используется имя формального параметра в качестве идентификатора

переменной, которая заменяется транслятором на косвенное обращение по

неявной ссылке;

- при возвращении результата используется имя переменной,которая

заменяется транслятором неявной ссылкой на нее;

- примеры 2 и 3 идентичны по реализации, но отличаются по

синтаксису вызова функции;

- примеры 1 и 3 отличаются по реализации, но идентичны по

синтаксису вызова функции;

- из предыдущего следует, что при вызове функции список фактический

параметров недостаточен для определения транслятором способа их передачи

(значением или ссылкой), поэтому в Си++ для каждой внешней функции

необходимо задать прототип.

Так как размер структуры, передаваемой в качестве результата функции,

может быть сколь угодно большим, то для его хранения необходимо создать

временную переменную. Транслятор "Borland C" в этом случае поступает

следующим образом:

- при входе в функцию в стеке предполагается существование неявного

параметра - "длинной" ссылки на структуру, в которой размещается

результат функции;

- при выполнении операции return(x), где x - локальная переменная или

формальный параметр, выполняется побайтовое копирование переменной x по

адресу, заданному неявным параметром;

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

переменной-структуре, то при вызове такой функции в стек помещается

неявный параметр - ссылка на переменную в левой части операции

присваивания;

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

неявной автоматической переменной на каждый вызов функции, возвращающей

структуру в качестве результата, а при вызове передается соответствующая

ссылка на эту переменную-структуру. Такие переменные имеют все свойства

автоматических, они существуют все время работы вызывающей функции,

возможно даже получить ссылку на такую переменную.

Программа на Си++ Реализация

----------------- ---------- -- неявный параметр

dat Inc(dat x) void Inc(dat *r,dat x)

{ {

x.day++; x.day++;

return(x); *r = x; // Копирование

} } // результата

void main() void main()

{ {

dat a,b*p; dat a,b,*p;

dat t,u; // Временнye переменнye

a = Inc(b); Inc(&a,b); // Ссылка на левую часть

p = &Inc(b); Inc(&t,b); // Присаивание временной

p = &t; // переменной и получение

a = *p; a = *p; // ссылки на нее

a = Inc(Inc(b)); Inc(&u,b); // Промежуточный результат

Inc(&a,u); // во временной переменной

} }

2.3. Функции - элементы структуры

-------------------------------- Повторим рассмотренный выше

пример в другой форме:

//------------ структура dat - аналог класса объектов "дата" --struct dat

{

unsigned day;

unsigned month;

unsigned year;

int TestData();

void NextData();

void PlusData(int n)

{

while(n-- !=0) dat::NextData(this);

}

};

//----------- набор функций для класса объектов "дата" --------static int

mm[] = {31,28,31,30,31,30,31,31,30,31,30,31};

//----------- Проверка на корректность -----------------------int

dat::TestData()

//----------- Следующая дата ----------------------------------void

dat::NextData()

{

day++;

if (day ::

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

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

(В нашем примере это будет struct dat *this ). Поля этой структуры доступны

через явное использование этой ссылки

this->month = 5;

this->day++;

или неявно

month = 5;

day++;

- для переменной, имеющей тип некоторой структуры, вызов

функцииэлемента этой структуры имеет вид

. ( )

2.4. Переопределение функций

--------------------------- В Си++ возможно определение

нескольких функций с одинаковым

именем, но с разными типами формальных параметров. При этом компилятор

выбирает соответствующую функцию по типу фактических параметров.

Переопределяемую функцию необходимо объявить с ключевым

словом overload:

overload SetDat;

void SetDat(int dd,int mm,int yy,dat *p)

{ // Дата вводится в виде трех целых

p->day=dd;

p->month=mm;

p->year=yy;

}

void SetDat(char *s,dat *p) // Дата вводится в виде строки

{

sscanf(s,"%d%d%d", &p->day, &p->month, &p->year);

}

void main()

{

dat a,b;

SetDat(12, 12, 1990, &a); // Вызов первой функции

SetDat("12,12,1990", &b); // Вызов второй функции

}

Функции-элементы также могут быть переопределены, при этом явного

объявления не требуется.

struct dat

{

int day,month,year;

void SetDat(int,int,int);

void Setdat(char *);

}

void dat::SetDat(int dd,int mm,int yy)

{

day=dd; month=mm; year=yy;

}

void dat::SetDat(char *s)

{

sscanf(s,"%d%d%d",&day,&month,&year);

}

void main()

{

dat a,b;

a.SetDat(12,12,1990);

b.SetDat("12,12,1990");

}

2.5. Операторы управления динамической памятью

---------------------------------------------

В библиотеке Си имеются две функции управления динамической памятью -

malloc() и free(), которые выделяют и освобождают область памяти

заданного размера (в байтах). В этой области программа может разместить

переменную (или массив), которая называется динамической. При выделении

памяти под динамическую переменную необходимо при помощи операции sizeof

определять количество байтов, необходимое для размещения переменной

указанного типа. В Си++ введены два оператора, аналогичные функциям malloc

и free new и delete. Они отличаются от соответствующих функций тем, что

допускают использования в качестве аргументов непосредственно

спецификацию типа создаваемой динамической переменной и ссылки на

динамическую переменную:

Си++ "Классический" Си

------------------------- ---------------------------------char

*s,x[80]; char *s,x[80];

dat *p,*q; struct dat *p,*q;

void main() void main()

{ {

p = new dat; p = malloc(sizeof (struct dat));

q = new dat[15]; q = malloc(15*sizeof (struct dat));

gets(x); gets(x);

s = new char[strlen(x)+1]; s = malloc(strlen(x)+1);

... ...

delete p; free(p);

delete q; free(q);

delete s; free(s);

}

Операторы имеют вид:

new описатель типа>

delete

2.6. Параметры функций по умолчанию

----------------------------------

При определении формальных параметров функции может быть

указано его значение, принимаемое при вызове по умолчанию при

отсутствии этого параметра в списке фактических:

//----- Функция устанавливает по умолчанию текущее значение года,

//----- месяца и дня

#include

void dat::SetDat(int d=0, int m=0, int y=0)

{

struct date x;

getdate(&x); // Стандартная функция получения

// текущей даты

// Проверка на значение по умолчанию

year = (y == 0) ? x.da_year : y;

month= (m == 0) ? x.da_month: m;

day = (d == 0) ? x.da_day : d;

}

2.7 Контроль преобразования типов ссылок

---------------------------------------

В "классическом" Си при выполнении присваивания, передаче

фактических параметров происходит автоматическое преобразование ссылок к

базовым типам данных (int,unsigned) и наоборот, а также преобразование

одного типа ссылки к другому. В Си++ такие "вольности" исключены,

программист должен сам выполнить явное преобразование. Например, при

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

"alloc.h"

extern void* malloc(int n);

dat *p;

p = (dat *) malloc (10*sizeof(dat));

¦

L--- преобразование void* в dat*

Естественно, что это преобразование типов фиктивное в том смысле,

что не меняет значения ссылки и не приводит к генерации кода. Оно только

меняет "точку зрения" транслятора на данную ссылку.

2.8 Вставляемые (inline) функции

-------------------------------

Если функция (обычная или элемент-функция структуры или класса)

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

выполняет подстановку по тексту программы тела функции с соответствующей

заменой формальных параметров на фактические. Элемент-функция также

считается inline по умолчанию, если ее тело определено непосредственно в

определении структуры (или класса),например:

struct dat

{

int d,m,y;

void Setdat(char *p) // Функция inline по умолчанию

{

... // Тело функции

}

2.9 Ссылки на элементы структуры

-------------------------------

Если структура имеет несколько элементов одного типа,то для нее

может быть создана "внутренняя" ссылка, которая принимает значение

внутреннего адреса (смещения) элемента относительно выбранной структуры.

Формирование и использование такой ссылки ясно

из примера:

struct dat

{

int day,month,year;

void Getdat();

void Putdat();

void Nextdat();

}

int dat::*p; // Ссылка на элемент типа int

// в структуре dat

p = & dat::month; // Значение p - смещение (адрес)

// элемента month в структуре типа

// dat

dat x,*px = &x; //

x.*p = 5; // Обращение по внутренней ссылке

px->*p = 5; // . *

// -> *

Эквивалентно

x.month = 5;

px->month =5;

Аналогичная внутренняя ссылка может быть создана для элементов-

функций, принадлежащих одной структуре, при этом функции

должны быть идентичными по результатам и параметрам:

void (dat::*fun)(); // Ссылка на элемент-функцию

// структуры dat

fun = & dat::Putdat(); // Значение fun - ссылка на

// элемент-функцию Putdat в dat

(x.*fun)(); // Вызов элемента-функции по

(px->*fun)(); // ссылке fun для структуры x

// и для структуры по ссылке px

Эквивалентно

x.Putdat();

px->Putdat();

2.10 Неизменяемые переменные (константы)

---------------------------------------

В Си++ введен дополнительный контроль за изменением значений

переменных. Ключевое слово const, используемой при определении и

инициализации переменной, запрещает ее изменение, что контролируется

транслятором при ее дальнейшем использовании. Такая же возможность

существует и для формальных параметров функции, например:

const int n=5;

n++; // Запрещено

int xxx(const int m)

{

m++; // Запрещено

}

Применительно к ссылке const может использоваться в двух вариантах,

применительно к самой ссылке (адресу) и применительно к указуемому

значению:

- при использовании conts применительно к указуемому значению

разрешается модифицировать саму ссылку при помощи присваивания и операций

адресной арифметики, а изменения операнда косвенно по ссылке запрещены.

Такая ссылка называется ссылкой на постоянный объект:

const char * p;

p = "1234567890"; // Разрешено присваивание ссылке

p + =3; // Разрешена модификация ссылки

*(p+3) = '3'; // Запрещено присваивание по ссылке

(*p)++; // Запрещен инкремент по ссылке

- при использовании const применительно к ссылке запрещается менять

значение ссылки после инициализации, в том числе средствами адресной

арифметики. Такая ссылка называется постоянной ссылкой на объект:

char const* p = "1234567890";

char c;

(*p) = '3'; // Разрешено присваивание по ссылке

p++; // Запрещено изменение значения

c = *(p+3); // самой ссылки

Полная фиксация ссылки и адресуемого ею объекта возможна в виде

const char const* p = "1234567890";

2.11 Общие замечания о дополнениях в Си++

----------------------------------------

Основные отличия Си++ от "классического" Си:

- структура (struct) приближена по свойствам к базовым типам

данных (char,int);

- введено понятие элемента-функции. Элементы-функции играют

роль своеобразного "интерфейса" для использования определенной

программистом структуры;

- расширены возможности транслятора по контролю и преобразованию

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

по умолчанию). Именно поэтому вызову любой внешней функции должно

предшествовать объявление ее прототипа (заголовка функции со списком типов

параметров).

Все эти новые свойства необходимы при определении понятий

класса и объекта.

Лекция 3. Классы. Объекты. Конструкторы и деструкторы

----------------------------------------------------

3.1.Понятие класса и объекта в Си++

----------------------------------

В самом простом виде класс определяется в Си++ как структура, работа

с элементами которой возможна только через элементы-функции. В отличие

от структуры класс имеет "приватную" (личную) часть, элементы которой не

могут быть доступны иначе как через другие элементыфункции, и "публичную"

(общую) часть, элементы

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

определяемая в программе переменная, тип которой определен

как класс (структура):

Определение структуры Определение класса

------------------------- -----------------------------------struct dat

class dat

{ { // Приватная часть

int day,month,year; int day,month,year;

public: // Публичная часть

void SetDat(int,int,int); void SetDat(int,int,int);

void SetDat(char *); void SetDat(char *);

} аа}

void main() void main()

{ {

// Опред-ние переменных a,b // Опред-ние объектов a,b класса dat

dat a,b; dat a,b;

a.day = 5; // Непосредственное использование

a.month = 12; // приватной части объекта запрещено

bAA.SetDat("12,12,1990"); b.Setdat("12,12,1990");

} }

"Приватная" часть класса не обязательно должна следовать в начале

определения класса. Для ее обозначения в произвольном месте

определения класса можно использовать служебное слово private.

Tаким образом в первом приближении класс отличается от структуры

четко определенным интерфейсом доступа к его элементам.

Объекты класса обладают всеми свойствами переменных, в том числе такими,

как область действия и класс памяти (время жизни).

Последнее свойство наиболее интересно, так как процессы создания и

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

(конструктор и деструктор). Напомним, что по классам памяти (и времени

жизни) в Си различаются переменные:

- статические (внешние), создаваемые в статической памяти программы

и существующие в течение всего времени работы программы;

- автоматические, создаваемые в стеке в момент вызова функции и

уничтожаемые при ее завершении;

- динамические, создаваемые и уничтожаемые в свободной памяти задачи в

моменты вызова функций malloc() и free() или выполнения операторов new и

delete.

Соответственно в программе возможно определение статических,

автоматических и динамических объектов одного класса:

class dat

{ ....... }

dat a,b; // Статические объекты

dat *p; // Ссылка на объект

void main()

{

dat c,d; // Автоматические объекты

p = new dat; // Динамический объект

...

delete p; // Уничтожение динамического объекта

} .

С процессом создания объектов связано понятие их инициализации.

Инициализировать объекты обычным способом нельзя. Их инициализация

осуществляется либо явным присваиванием (копированием)

другого объекта, либо неявным вызовом конструктора. Если

конструктор имеет формальные параметры, то в определении переменной после

ее имени должны присутствовать в скобках значения фактических параметров.

Момент вызова конструктора и деструктора определяется временем

создания и уничтожения объектов:

- для статических объектов - конструктор вызывается перед

входом в main(), деструктор - после выхода из main(). Конструкторы

вызываются в порядке опредлеления объектов, деструкторы - в

обратном порядке;

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

входе в функцию (блок), деструктор - при выходе из него;

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

оператора new, деструктор - при выполнении оператора delete.

В Си++ возможно определение массива объектов класса. При этом

конструктор и деструктор вызываются для каждого элемента массива и не

должны иметь параметров. При выполнении оператора delete для ссылки на

массив объектов необходимо также указывать его размерность. Конструктор для

массива объектов должен быть без параметров.

//--------------------------------------------------------#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:

dat(int,int,int); // Конструктор с параметрами

// (возможно умолчание)

dat(char *); // Конструктор с одним параметром

dat(); // Конструктор без параметров

~dat(); // Деструктор

};

//------- Конструктор с параметром - текстовая строка ---------

dat::dat(char *s)

{

int i;

char ss[80];

strcpy(ss,s);

for (i=0; ss[i] !=0; i++)

if (ss[i]=='-') ss[i]=','; // Замена '-' на ','

sscanf(ss,"%d%d%d",&day,&month,&year);

}

// Конструктор с тремя параметрами (по умолчанию 0 - текущая дата)

dat::dat(int d=0, int m=0, int y=0)

{

struct date x;

getdate(&x); // Стандартная функция получения

// текущей даты

// Проверка на значение по умолчанию

year = (y == 0) ? x.da_year : y;

month= (m == 0) ? x.da_month: m;

day = (d == 0) ? x.da_day : d;

}

//------ Конструктор без параметров --------------------------dat::dat()

{

struct date x;

getdate(&x); // Стандартная функция получения

// текущей даты

year = x.da_year ;

month= x.da_month;

day = x.da_day ;

}

//------ Деструктор ------------------------------------------dat::~dat()

{

printf("Дата ==> %2d-%2d-%4d\n",day,month,year);

}

//------------------------------------------------------dat a("12-12-

1990"); // Внешняя переменная - конструктор

// вызывается перед main()

dat b[10]; // Массив объектов - конструктор без

// параметров вызывается перед main()

void xxx(dat &p)

{

dat c(12,12); // Вызывается Конструктор dat(int,int,int)

// для автоматического объекта

dat d = p; // Конструктор для автоматического объекта не

... // вызывается, т.к. объект инициализируется

... // копированием

} // При выходе из функции вызываются деструкторы

// для объектов c и d

void main()

{

int i,n;

scanf("%d",&n);

dat *p = new dat[n]; // Создание массива динамических объектов

// конструктор без параметров явно вызывается

for (i=0; i+ дружественна

// классу 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)

Страницы: 1, 2