Язык программирования С++: элементы структуры, дружественные функции

Содержание

1. Структуры. Описание. Создание структурных переменных. Доступ к элементам структуры

2. Дружественные классы. Дружественные функции

3. Задача

Имеется список автомашин, в котором записаны

- марка автомашине;

- фамилия владельца;

- год выпуска;

- регистрационный номер;

- дата прохождения техосмотра(дд/мм/гггг).

Определите автомашины и их владельцев, не прошедших техосмотр (учесть, что автомашины старше 10 лет должны проходить техосмотр каждый год, остальные - 1раз в 2 года). Подсчитайте количество автомашин, прошедших техосмотр в текущем году в указанном месяце (вводится с клавиатуры) и определите фамилии их владельцев.

4. Задача.

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

1. Структуры. Описание. Создание структурных переменных. Доступ к элементам структуры

Структуры языка C++ представляют поименованную совокупность компонентов, называемых полями, или элементами структуры. Элементом структуры может быть:

-переменная любого допустимого типа;

-битовое поле;

-функция.

Объявление структуры имеет следующее формальное описание:

struct [имя_структуры] {

тип_элемента_структуры имя_ элемента1;

тип_элемента_структуры имя_ элемента2;

...

тип_элемента_структуры имя_ элементаN;

} [список_объявляемых_переменных];

Объявление структуры с битовыми полями имеет следующее формальное описание:

struct [имя_структуры] {

тип_элемента_структуры

[имя_ элемента1] : число_бит;

тип_элемента_структуры

[имя_ элемента2] : число_бит;

...

тип_элемента_структуры

[имя_ элементаN] : число_бит;

} [список_объявляемых_переменных];

Возможно неполное объявление структуры, имеющее следующее формальное описание:

struct имя_структуры;

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

Список объявляемых переменных типа данной структуры может содержать:

-имена переменных;

-имена массивов;

-указатели.

Например: struct sA {char a[2], int i;} struA, struB[10], *struC;

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

Размер структуры с битовыми полями всегда кратен байту. Битовые поля можно определять для целочисленных переменных типа int, unsigned int, char и unsigned char. Одна структура одновременно может содержать и переменные, и битовые поля. Если для битового поля не задано имя элемента, то доступ к такому полю не разрешен, но количество указанных бит в структуре размещается.

Типом элемента структуры может быть:

-другой структурный тип (допускаются вложенные структуры);

-указатель на данный структурный тип;

-неполно объявленный структурный тип;

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

Например:

struct sA {char a[2], sA* this_struct;};

// Корректное объявление структуры

struct sB;

// Неполное объявление структуры

struct sA {char a[2], sB* this_struct;};

// Корректное объявление структуры

struct sA {char a[2], sA this_struct;};

// Ошибочное объявление

Структура не может содержать в качестве вложенной структуры саму себя, но она может содержать элемент, являющийся указателем на объявляемую структуру.

Например:

struct structA {

struct structA *pA; int iA; } sA;

// pA указатель на структуру

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

Например:

struct POINT // Объявление структурного

// типа POINT

{

int x; // Объявление элементов x и y

int y;

} p_screen = { 50, 100 };

// Эквивалентно записи p_screen.x = 50;

// и p_screen.y = 100;

Выделение памяти

При создании переменной типа структуры:

-память под все элементы структуры выделяется последовательно для каждого элемента;

-для битовых полей память выделяется, начиная с младших разрядов;

-память, выделяемая под битовые поля, кратна байту;

-общая выделяемая память может быть больше, чем сумма размеров полей структуры.

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

struct structA {

char cA;

char sA[2];

float fA;};

При создании переменной структурного типа:

structA s1;

будет выделено 7 байтов. Элементы структуры будут размещены в памяти в следующем порядке:

char cA char sA[2] float fA

1 2 3 4 5 6 7

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

struct structB {

int i1:2;

int i2:3;

int :6;

unsigned int i3:4;};

При создании переменной структурного типа:

structB s2;

будет выделено 2 байта. Элементы структуры будут размещены в памяти в следующем порядке:

Для целочисленных значений, предусматривающих наличие знакового разряда (например, int), старший левый бит из общего числа битов, выделяемых под данное битовое поле, интерпретируется как знак. Например, битовое значение 11 для поля i1 будет восприниматься как -1, а значение 11 для поля i3 - как 3.

Элементы структуры могут иметь модификаторы доступа: public, private и protected. По умолчанию все элементы структуры объявляются как общедоступные (public). Забегая вперед, следует сказать, что все члены класса по умолчанию объявляются как защищенные (private).

Для обращения к отдельным элементам структуры используются операторы: . и ->.

Доступ к элементам структуры может иметь следующее формальное описание:

переменная_структурного_типа.элемент_структуры=значение;

имя_структурного_типа *указатель_структуры=

& переменная_структурного_типа;

указатель_структуры->элемент_структуры=значение;

Например:

struct structA {

char c1;

char s1[4];

float f1;} aS1,

// aS1 - переменная структурного типа

*prtaS1=&aS1;

// prtaS1 - указатель на структуру aS1

struct structB {

struct structA aS2;

// Вложенная структура

} bS1,*prtbS1=&bS1;

aS1.c1= 'Е';

// Доступ к элементу c1 структуры aS1

prtaS1->c1= 'Е';

// Доступ к элементу c1 через

// указатель prtaS1

(*prtaS1).c1= 'Е';

// Доступ к элементу c1

(prtbS1->aS2).c1='Е';

// Доступ к элементу вложенной структуры

Доступ к элементу массива структурного типа имеет следующий формальный синтаксис:

имя_массива[индекс_элемента_массива].элемент_структуры

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

Например:

struct structA {

int i; char c;} sA[4], *psA;

psA=&sA[0];

…

cout<<psA->i;

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

// структур

// Переход ко второму элементу массива

psA++;

// Эквивалентно записи: psA=&sA[1];

cout<<psA->i;

Переменные структурного типа и элементы структуры можно передавать в функции в качестве параметров.

Передача параметров может выполняться:

-по ссылке или указателю;

-по значению.

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

Например:

struct structA {

int i; char c;} sA, *psA=&sA;

void F1(struct structA sA);

// Передача параметров по значению

void F2(struct structA *psA);

// Передача параметров по указателю

void F3(struct structA &sA);

// Передача параметров по ссылке

…

void F2(struct structA *psA) {

psA->i =10; }

// Доступ к элементу структуры

При большой вложенности вызовов и использовании большого числа структур или их значительных размерах вызов по значению может привести к переполнению стека.

Функция может возвращать значение структурного типа или типа указателя на структуру.

Например:

struct structA { int i; char с;};

struct structA Function3(void);

// Функция возвращает значение

// структурного типа

struct structA *Function4(void);

// Функция возвращает указатель

// на структуру

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

Использование объединений значительно экономит память, выделяемую под объекты.

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

Инициализировать объединение при его объявлении можно только заданием значения первого элемента объединения.

Например:

union unionA {

char ch1;

float f1;} a1={ 'M' };

Доступ к элементам объединения, аналогично доступу к элементам структур, выполняется с помощью операторов . и ->.

Например:

union TypeNum

{

int i;

long l;

float f;

};

union TypeNum vNum = { 1 };

// Инициализация первого элемента объединения i = 1

cout<< vNum.i;

vNum.f = 4.13;

cout<< vNum.f;

Элементы объединения не могут иметь модификаторов доступа и всегда реализуются как общедоступные (public).

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

Перечисление задает для каждого мнемонического названия в указываемом множестве свой индекс.

Перечисление может иметь следующее формальное описание:

enum имя_типа {список_значений}

список_объявляемых_переменных;

enum имя_типа список_объявляемых_переменных;

enum (список_элемент=значение);

Перечислимый тип описывает множество, состоящее из элементов-констант, иногда называемых нумераторами или именованными константами.

Значение каждого нумератора определяется как значение типа int. По умолчанию первый нумератор определяется значением 0, второй - значением 1 и т.д. Для инициализации значений нумератора не с 0, а с другого целочисленного значения, следует присвоить это значение первому элементу списка значений перечислимого типа.

Например:

// Создание перечисления

enum eDay{sn, mn, ts, wd, th, fr, st} day1;

// переменная day1 будет принимать

// значения в диапазоне от 0 до 6

day1=st;

// day1 - переменная перечислимого типа

int i1=sn;

// i1 будет равно 0

day1= eDay(0);

// eDay(0) равно значению sn

enum(color1=255);

// Объявление перечисления, определяющего

// именованную целую константу color1

int icolor=color1;

enum eDay2{sn=1, mn, ts, wd, th, fr, st} day2;

// переменная day2 будет принимать

// значения в диапазоне от 1 до 7

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

2. Дружественные классы. Дружественные функции

Доступ к элементам класса из программы и других классов ограничен. Вы можете непосредственно обращаться только к элементам класса, определенным или описанным после ключевого слова public. Однако, в некоторых случаях, требуется определить функцию вне класса или другой класс, методы которого могут обращаться непосредственно ко всем элементам класса, включая элементы объявленные как private и protect.

В Си++ вы можете определить для класса так называемую дружественную функцию, воспользовавшись ключевым словом friend. В классе содержится только объявление дружественной функции. Ее определение расположено вне класса. Вы можете объявить дружественную функцию в любой секции класса - public, private или protect.

Дружественная функция не является элементом класса, но может обращаться ко всем его элементам, включая private и protect. Одна и та же функция может быть дружественной для двух или более классов.

В следующем примере определена функция Clear, дружественная для класса point. Дружественная функция Clear используется для изменения значения элементов данных m_x и m_y, объявленных как private:

//==========================================================

// Класс point

class point

{

public:

// Функция Clear объявляется дружественной классу point

friend void point::Clear(point*);

// Интерфейс класса...

private:

int m_x;

int m_y;

};

//==========================================================

// Функция Clear

void Clear(point* ptrPoint)

{

// Обращаемся к элементам класса, объявленным как private

ptrPoint->m_x = 0;

ptrPoint->m_y = 0;

return;

}

//==========================================================

// Главная функция

void main()

{

point pointTestPoint;

// Вызываем дружественную функцию

Clear(&pointTestPoint);

}

С помощью ключевого слова friend вы можете объявить некоторые методы одного класса дружественными для другого класса. Такие методы могут обращаться ко всем элементам класса, даже объявленным как private и protect, несмотря на то, что сами они входят в другой класс.

В следующем примере мы определяем два класса - line и point. В классе point определяем метод Set и объявляем его в классе line как дружественный. Дружественный метод Set может обращаться ко всем элементам класса line:

// Предварительное объявление класса line

class line;

//==========================================================

// Класс point

class point

{

public:

// Метод Set класса point

void Set(line*);

// ...

};

//==========================================================

// Класс line

class line

{

public:

// Метод Set класса point объявляется дружественной

// классу point

friend void point::Set(line*);

private:

int begin_x, begin_y;

int end_x, end_y;

};

//==========================================================

// Функция Clear

void point::Set(line* ptrLine)

{

// Обращаемся к элементам класса line, объявленным как

// private

ptrLine->begin_x = 0;

ptrLine->begin_y = 0;

// ...

return;

}

//==========================================================

// Главная функция

void main()

{

point pointTestPoint;

line lineTestPoint;

// Вызываем дружественный метод

pointTestPoint.Set(&lineTestPoint);

}

По аналогии с дружественными функциями и методами, можно объявить дружественный класс. Все методы дружественного класса, могут обращаться ко всем элементам класса, включая элементы, объявленные как private и protect.

Так, например, в предыдущем примере вы могли бы определить, что класс point является дружественным классу line. Все методы класса point могут обращаться к любым элемента класса line.

//==========================================================

// Класс point

class point

{

// ...

};

//==========================================================

// Класс line

class line

{

public:

// Класс point объявляется дружественным классу line

friend class point;

};

3. Задача.

Имеется список автомашин, в котором записаны:

- марка автомашине;

- фамилия владельца;

- год выпуска;

- регистрационный номер;

- дата прохождения техосмотра(дд/мм/гггг).

Определите автомашины и их владельцев, не прошедших техосмотр (учесть, что автомашины старше 10 лет должны проходить техосмотр каждый год, остальные - 1раз в 2 года). Подсчитайте количество автомашин, прошедших техосмотр в текущем году в указанном месяце (вводится с клавиатуры) и определите фамилии их владельцев.



#include <iostream.h>

#include <conio.h>

#include <string.h>

#include <stdio.h>

#include <fstream.h>

int outm(int god_vyp, char *date);

FILE *fp;

struct avto {

char marka[40],fam[50];

int god;

char reg_nom[10];

char date[11];

} avtos[100],avtos2[100];

int col=0;

int col2 = 0;

void ReadF()

{

fp =fopen("Autos.txt", "rt");

fread(avtos,sizeof(avtos),1,fp);

fclose(fp);

while (avtos[col].reg_nom[9]!='X')

{

col++;

}

getch();

};

void SaveF()

{

avtos[col+1].reg_nom[9]='X';

ofstream A("Autos.txt");

fp =fopen("Autos.txt", "wt");

fwrite(avtos,sizeof(avtos),1,fp);

fclose(fp);

};

void new_zap() {

clrscr();

cout << "Dobavlenie novoj zapisi.\n\n\n";

cout << "Vvod zapisi #" << col+1 << "\n\n";

cout << "Vvedite marku avto: ";

gets(avtos[col].marka);

cout << "Vvedite familiyu vladel'ca: ";

gets(avtos[col].fam);

cout << "Vvedite god vypuska: ";

cin >> avtos[col].god;

cout << "Vvedite registracionnij nomer: ";

gets(avtos[col].reg_nom);

cout << "Vvedite datu prohozhdeniya tehosmotra (dd/mm/gggg): ";

gets(avtos[col].date);

col++;

cout << "Zapis sohranena. Nazhmite lyubuyu klavishu...";

SaveF();

getch();

}

void kor_zap() {

clrscr();

ReadF();

cout << "Korrektirovka zapisi.\n\n\n";

cout << "Vvedite nomer zapisi: ";

int i;

cin >> i;

i--;

cout << "\nVvedite marku avto: ";

gets(avtos[i].marka);

cout << "Vvedite familiyu vladel'ca: ";

gets(avtos[i].fam);

cout << "Vvedite god vypuska: ";

cin >> avtos[i].god;

cout << "Vvedite registracionnij nomer: ";

gets(avtos[i].reg_nom);

cout << "Vvedite datu prohozhdeniya tehosmotra (dd/mm/gggg): ";

gets(avtos[i].date);

cout << "Zapis izmenena. Nazhmite lyubuyu klavishu...";

SaveF();

getch();

}

void del_zap() {

ReadF();

clrscr();

cout << "Udalenie zapisi.\n\n\n";

cout << "Vvedite nomer zapisi: ";

int i;

cin >> i;

col--;

for (int j=i-1;j<col;j++) {

avtos[j]=avtos[j+1];

}

cout << "\nZapis udalena. Nazhmite lyubuyu klavishu...";

SaveF();

getch();

}

void out_zap() {

ReadF();

clrscr();

cout << "Vyvod vseh zapisej.\n\n\n";

for (int i=0;i<col;i++) {

cout << "Zapis #" << i+1 << endl;

cout << "Marka: " << avtos[i].marka << endl;

cout << "Familiya vladel'ca: " << avtos[i].fam << endl;

cout << "God vypuska: " << avtos[i].god << endl;

cout << "Registracionnij nomer: " << avtos[i].reg_nom << endl;

cout << "Data prohozhdeniya tehosmotra: " << avtos[i].date << endl << endl;

cout << "<Nazhmite lyubuyu klavishu>";

getch();

delline(); gotoxy(1,wherey());

}

cout << "Vyvod zapisej okonchen. Nazhmite lyubuyu klavishu...";

getch();

}

void zad_zap() {

clrscr();

cout << "Zadanie 1. Mashiny, ne proshedshie tehosmotr:\n\n";

int ex=0;

for (int i=0;i<col;i++) {

if (outm(avtos[i].god,avtos[i].date)) {

ex=1;

cout << "Marka: " << avtos[i].marka << endl;

cout << "Familiya vladel'ca: " << avtos[i].fam << endl;

cout << "God vypuska: " << avtos[i].god << endl;

cout << "Registracionnij nomer: " << avtos[i].reg_nom << endl;

cout << "Data prohozhdeniya tehosmotra: " << avtos[i].date << endl << endl;

cout << "<Nazhmite lyubuyu klavishu>";

getch();

delline(); gotoxy(1,wherey());

}

}

if (ex) {

cout << "Vyvod zapisej okonchen. Nazhmite lyubuyu klavishu...";

} else {

cout << "Zapisej po kriteriyu ne najdeno.";

}

getch();

clrscr();

cout << "Zadanie 2. Avtomashiny, proshedshie tehosmotr v opredelennom mesyace:\n\n";

ex=0;

char mg[8];

cout << "Vvedite mesyac i god (mm/gggg): ";

gets(mg);

cout << endl;

for (i=0;i<col;i++) {

if (strstr(avtos[i].date,mg)) {

ex=1;

cout << "Marka: " << avtos[i].marka << endl;

cout << "Familiya vladel'ca: " << avtos[i].fam << endl;

cout << "God vypuska: " << avtos[i].god << endl;

cout << "Registracionnij nomer: " << avtos[i].reg_nom << endl;

cout << "Data prohozhdeniya tehosmotra: " << avtos[i].date << endl << endl;

cout << "<Nazhmite lyubuyu klavishu>";

getch();

delline(); gotoxy(1,wherey());

avtos2[col2] = avtos[i];col2++;

}

}

if (ex) {

cout << "Vyvod zapisej okonchen. Nazhmite lyubuyu klavishu...";

ofstream A("Autos2.txt");

fp =fopen("Autos2.txt", "wt");

fwrite(avtos2,sizeof(avtos2),1,fp);

fclose(fp);

col2 = 0;

} else {

cout << "Zapisej po kriteriyu ne najdeno.";

}

getch();

}

int menu() {

clrscr();

cout << "Vsego zapisej v base: " << col << "\n\n";

cout << "Menu\n\n1.Vvod zapisi\n2.Korrektirovka zapisi\n3.Udalenie zapisi\n4.Vyvod zapisej\n5.Zadanie\n0.Vyhod\n\nVash vybor: ";

int ch;

cin >> ch;

switch (ch) {

case 1: new_zap(); break;

case 2: kor_zap(); break;

case 3: del_zap(); break;

case 4: out_zap(); break;

case 5: zad_zap(); break;

case 0: return 1;

}

return 0;

}

int main() {

while (1) {

if (menu()) {

break;

}

}

return 0;

}

int outm(int god_vyp, char *date) {

int mgod=0;

for (int i=0;i<4;i++) {

mgod=mgod*10+(((int)date[6+i])-48);

}

if (2010-mgod < 1) {

return 0;

} else {

if (2010-mgod > 1) {

return 1;

} else {

if (2010-god_vyp < 10) {

return 0;

} else {

return 1;

}

}

}

return 0;

}

4. Задача

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



#include <iostream.h>

#include <conio.h>

#include <math.h>

class base {

protected:

double x,y;

public:

base(double v1, double v2)

{

base::x = v1;

base::y = v2;

}

~base()

{

cout<<"destroy!";

getch();

}

virtual void Input()

{

cin>>x;

cin>>y;

}

virtual void Get() {

cout<<x<<endl<<y<<endl;

}

};

class proiz:public base {

public:

double z;

proiz(double, double, double);

~proiz();

void Input() {

cout<<"\nInput x";cin>>x;

cout<<"\nInput y";cin>>y;

cout<<"\nInput z";cin>>z;cout<<endl;

getch();

}

void Get()

{

cout<<"x = "<<x<<endl<<"y = "<<y<<endl<<"z = "<<z<<endl;

};

double GetResult() {

return log(pow(y,-sqrt(abs(x))))*(x-y/2)+pow(sin(atan(z)),2);

}

};

proiz::proiz(double x, double y, double z):base(x,y)

{

proiz::z = z;

}

proiz::~proiz()

{

};

main() {

double x,y,z;

clrscr();

proiz obj(1,2,3);

obj.Get();

obj.Input();

obj.Get();

getch();

cout << "Rezultat: " << obj.GetResult() << endl << endl;

getch();

return 0;

}

Список используемых источников

1. Прата Стивен. Язык программирования C++. Лекции и упражнения. Учебник.: Пер. с англ. - М.: Издательство Диасофт, 2004.

2. Буч Г. Объектно-ориентированный анализ и проектирование с примерами приложений на С++. 2-е изд.: Пер. с англ. - М.: Издательство Бином, СПб.: Невский диалект, 1999