Пример иерархической структуры

#include <iostream>

using namespace std;

int main()

{

//простые структуры

struct adress

{

char city[20]; char street[10];

int house;

};

struct person

{

char Pname[15]; char Lname[20];

};

//иерархические структуры

struct employ

{

Person p;//вложенная структура

adress addr;//вложенная структура

};

//объявление переменной указателя

employ *p = new employ;

//ввод значений элементов

cin >> p -> p.Frame; cin >> p -> p.Lname;

cin >> p -> addr.city;

cin >> p -> addr.street;

cin >> p -> addr.house;

return 0;

}

В листинге программы представлен тип иерархической структуры employ, который включает в качестве элементов две переменные. Одна из которых имеет тип структуры person, другая тип структуры adress. Указател *p содержит адресс, выделенного блока памяти для размещения переменной типа employ, чтобы получить доступ к элементам

этой переменной испольуезтся операция стрелка. Для получения доступа к элементам вложенных структур р и addr используется операция (.)

Инициализация структур.

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

Пример инициализации переменных структурного типа

#include <iostream>

using namespace std;

int main()

{

struct Time

{

int hour; int minute; int second;

};

struct Interval

{

Time top; Time end;

};

//инициализация простой структуры

Time top = {5, 30, 0};

Time end = {15, 30, 45};

//инициализация иерархической структуры

Interval il = {{5, 30, 0}, {15, 30, 45}};

//вывод структурной переменной il

cout << il.top.hour << “:”;

cout << il.top.minute << “:”;

cout << il.top.second << “_”;

cout << il.end.hour << “:”;

cout << il.end.minute << “:”;

cout << il.end.second << endl

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

struct Book

{

char author[2][50];

char title [100];

};

//иерархическая структура

struct BooCard

{

int number;

Book book;

};

//вывод структурной переменной

cout << c.number << “_”;

cout << c.book.author [0] << “,”;

cout << c.book.author [1] << “/”;

cout << c.book.title << endl;

return 0;

}

Массивы структур

Массивы структур ничем не отличаются от массивов встроенных типов данных, и обрабатываются, как обычно.

#include <iostream>

using namespace std;

//названия железных дорог

const char* pName[] = {“East-siberian”, “Far-East”, “October”, “Krasnoyarsk”, “Moscow”, “Sakhalin”, “Northern”, “Southeast”, “South-Ural”};

//Эксплуатационная длина железных дорог

double len[] = {3848.1, 6000.0, 10143, 3157.9, 8984, 833.8, 5951.7, 4189.1, 4806.6};

int main()

{

//вычисление размера массива len

int size = sizeof (len)/sizeof (len[0]);

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

struct road {char name[30];

double length;}

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

Road roadArray[20];

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

int i = 0;

while (i<size)

{

strcpy_s (roadArray[i].name, 30, pName[i]};

roadArray[i].length = len[i++];

}

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

Road* pRailRoad = new Road[size];

//прир-е массивов

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

*(pRailRoad +i) = roadArray[i];

//вывод значений из массива с адресом pRailRoad

Road*p = pRailRoad;

do

{

cout << p -> name << ‘\t’ << p -> length << ‘\n’;

p++;

}

while (p < pRailRoad + size);

//вычисление общей длины дорог

double total = 0;

for (i = 0, p = pRailRoad, i < size; i++)

total += p++ -> length;

cout << “\n Summary length = “ << total << endl;

return 0;

}

В листинге программы показана работа с массивом структур roadArray типа road. И с массивом объявлена и pRailRoad на тот же структурный тип Road. В массив RoadArray помещаются названия железных дорог из глобального массива pName и эксплуатационная длинна дорог из глобального массива len. Заполнение массива происходит в цикле while до тех пор, пока индекс массива меньше размера size глобального массива len. Для доступа к элементам массива roadArray используется операция индексации, а для доступа к элементам структуры – операция «точка». Для доступа к элементам массива RoadArray через указатель pRailRoad применяется оператор new, при помощи которого выделяется необходимый блок памяти и цикл for, в котором копируются элементы массива RoadArray. Каждый элемент i этого массива переписывается по адресу pRailRoad + I, для вывода состояния, полученного после копирования массива, используются указатель “p” и цикл Do while, управляющий изменением указателя на элементы массива. В цикле сначала выводится очередной элемент массива структуры, на который указывает «p», затем указатель увеличивается на единицу, обеспечивая доступ к следующему элементу в новой итерации цикла. В конце программы вычисляется и выводится общая длина всех дорог. Summary length = 479172 км.

Функции

Функции – строительные блоки С++, из которых формируется код программы.

Правило действия областей видимости функции:

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

Существует 3 вида переменной:

1. Глобальные переменные

2. Локальные переменные

3. Формальные параметры

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

#include<IOstream> using namespase std; void f1(); int main(){ char str[]=” Это массив str в функции main();” cout<<str<<”/n”; f1() cout<<str<<”n”; return 0; } void f1(){ cout<<”Enter string”; cin>>str; cout<<str<<”/n”; }

Символьный массив str объявляется дважды. Первый раз – в функции main и еще раз в функции F1. При этом массив str, объявленный функцией main не имеет никакого отношения к одноименному массиву из функции F1. Каждый массив (str) известен только блоку кода, в котором он объявлен. Локальные переменные можно объявлять в любом месте блока кода и эта переменная не существует, пока не будет выполнен вход в блок. Она является локальной по отношению к этому блоку. При выходе из блока, локальная переменная разрушается. При вызове функции, ее локальные переменные создаются, а при выходе из нее – разрушаются. Таким образом, локальные переменные не сохраняют своих значений между вызовами функций.

Формальные переменные

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

Глобальные переменные.

Глобальные переменные во многом противоположны локальным. Они известны на протяжении всей программы. Их можно использовать в любом месте кода. Они сохраняют свои значения во время выполнения всего хода программы. То есть их область видимости расширяется до всего объема программы. Глобальная переменная создается путем ее объявления вне какой-либо функции и к ней можно получить доступ из любой части программы. Если глобальная и локальная переменная имеют одинаковые имена, то преимущества на стороне локальной переменной. Хранение глобальных переменных осуществляется в специальной области памяти, выделяемой программой. Глобальные переменные полезны, когда в нескольких функциях программы используются одни и те же данные или когда переменная должна хранить свое значение на протяжении всей программы.

Недостатки использования глобальных переменных:

1. Они занимают память в течение всего выполнения программы, даже когда в них нет необходимости.

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

3. Использование большого количества глобальных переменных может привести к ошибкам в программе и проявлению неизвестных и нежелательных побочных эффектов.

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

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

Вызов функции с указателем.

include<IOstream> using namespase std; void f(int*g); int main(){

int I;

int *p;

p=&I

f(p) cout<<I;

return0;

} void f (int *j)

{ *j=100

}

В этой программе функция f принимает 1 параметр, это указатель на целочисленное значение. В функции main указатель p присваивается переменная i. Затем из функции main вызывается функция f,а указатель p передается ей в качестве аргумента. После того, как параметры указателя g получит значение аргумента, он как и p будет указывать на переменную i, определенную функцией main. Таким образом при выполнении операции присваивания g*=100, переменная i получит значение 100.