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

скачать (156 kb.)

1   2   3

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; // . *<ссылка на элемент>

// <*dat>-> *<ссылка на элемент>

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

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; // Уничтожение динамического объекта

} <---------------------// Уничтожение автоматических объектов


3.2. Создание и уничтожение объектов.

Конструкторы и деструкторы

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

Процесс создания и уничтожения объектов класса ассоциируется

при объектном программировании с созданием и уничтожением соответствующих им физических объектов. Поэтому с этими действиями

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

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

элементы-функции класса и имена их совпадают с именем класса.

Конструкторов для данного класса может быть сколь угодно много,

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

один и имеет имя ~<имя класса>.

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

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

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

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

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

входом в 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<10; i++) // n раз

xxx(b[i]); // При вызове неявно передается ссылка на b[i]

for (i=0; i< n; i++) //

xxx(p[i]) // При вызове неявно передается ссылка на p[i]

delete[n] p; // Уничтожение массива динамических объектов // деструктор явно вызывается n раз

} // Деструктры для a и b[10] вызываются после

// выхода из main()
}
3.3 Ограничение доступа к объектам класса. Дружественность.

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

Выше было дано формальное определение класса. Содержательная его сторона состоит в том, что класс выступает в Си++ как определенный программистом тип данных. Такой тип данных включает в себя:

- описание структуры объектов класса. Объект класса представляет собой совокупность элементов (структуру), каждый из которых является переменной некоторого типа или объектом ранее определенного класса;

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

- описание процедур создания и уничтожения объекта класса (конструктор и деструктор).
При этом внутренняя структура объектов (описанная в "приватной" части класса) доступна только элементам-функциям. Наоборот, "публичная" часть определения класса - это описание той части объекта, к которой возможен доступ из любого места программы, если доступен сам объект. Данное ограничение позволяет исключить некорректное использование объектов класса, как случайное, так и умышленное. Возможные ошибки, связанные с неправильным "поведением" объектов класса, локализуются таким образом в определении самого класса, а не в использовании его объектов.
Иногда требуются исключения из этого правила, когда к "приватной" части объекта класса требуется доступ из некоторой отдельной функции, либо из всех элементов-функций другого класса, либо из переопределяемой в другом классе операции. Тогда в определении класса, к объектам которого разрешается такой доступ, должно быть объявление функции или другого класса "дружественным". Это согласуется с тем принципом, что сам класс определяет права доступа к своим объектам "со стороны".
Объявление дружественной функции предствляет собой прототип функции, объявление переопределяемой операции или имя класса, которым разрешается доступ, с ключевым словом 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()
1   2   3



Рефераты Практические задания Лекции
Учебный контент

© ref.rushkolnik.ru
При копировании укажите ссылку.
обратиться к администрации