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

указанного типа. В Си++ введены два оператора, аналогичные функциям 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)

if (p=this) break; // Если найден - выход

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