Шпоры по информатике4

Модульное прогр-е. Ф-ции.

В яз С минимальным исполняемым прогр-ным модулем яв-ся ф-ция. Сложная задача при прогр-и на С может быть разделена на более простые ф-ции (подзадачи). Это позволяет упростить стр-ру проги, избежать избыточности кода (ф-ция запис-ся 1 раз, а вызыв-ся многократно), упростить процесс отладки и сопровождения проги, поместив часто исп-е ф-ции в библиотеки. Разработанные ф-ции можно сгруппировать в отдельные файлы (модули), компилируемые отдельно, кот-е затем объед-ся в исполняемую прогу с помощью компоновщика.

Понятие ф-ции.

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

Объявл-е ф-ции задает имя ф-ции, тип возвращаемого знач-я и список параметров.

Определение ф-ции содержит кроме заголовка тело ф-ции.

Можно задать класс памяти ф-ции (он опред-ет область видимости ф-ции). Класс extern задает глобальную видимость ф-ции во всех модулях проги; static задает видимость только в пределах модуля, в кот-м определена ф-ция.

Тип возвращаемого знач-я может быть любым кроме массива или ф-ции, но может быть ук-ль на массив или ф-цию.

Имя ф-ции – идентификатор, задаваемый прогр-стом (для гл ф-ции - main).

Список формальных параметров – (тип имя_пар1, тип имя_пар2…). Формальные параметры – имена, формально присутствующие в ф-ции и определяющие тип и место подстановки фактических параметров. Фактич параметра – реальные данные проги, заменяющие в теле ф-ции при ее вызове формальные. Именно над фактич параметрами производятся д-я.

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

Вызов ф-ции – имя ф-ции (список фактических параметров).

В объявл-и, опред-и и вызове 1 и той же ф-ции должно соблюдаться правило соотв-я типов и порядка следования параметров.

Обмен инф-цией м/у ф-циями.

Обмен инф-цией м/у ф-циями можно осуществить: 1) с помощью глобальных перем-х; 2) ч/з возвращаемое ф-цией знач-е (return); 3) ч/з параметры.

1) Глобальные перем-е “видны” во всех ф-циях. С их помощью передавать данные м/у ф-циями не рекомендуется, т.к это затрудняет отладку проги и препятствует помещению ф-ции в библиотеки общего пользования.

2) С помощью опер-ра return можно передать одно единственное знач-е из вызванной ф-ции в вызывавшую. а) return выр-е; б) return; а) return вып-ет 2 д-я: 1 – указывает на то, что знач-е будет присвоено ф-ции (при этом тип возвращаемого знач-я преобраз-ся в тип ф-ции); 2 – завершает вып-е ф-ции и передает управл-е следующему опре-ру в вызывающей ф-ции. б) только завершает вып-е ф-ции и передает управл-е следующему опре-ру в вызывающей ф-ции.

3) Сущ-ет 3 способа передачи параметров в ф-цию: 1- по знач-ю: в стек заносятся копии знач-й аргументов (фактич-х пар-ров) и опер-ры ф-ции работают с этими копиями. Доступа к исх знач-ям пар-ров у ф-ции нет, => нет и возможности их изменить; 2- по адресу: в стек заносятся копии адресов аргументов, а ф-ция осущ0ет доступ к ячейкам памяти по этим адресам и может изменить исх знач-я аргументов.; 3- по ссылке (С++): в ф-ция передается адрес указанного при вызове пар-ра, а внутри ф-ции все обращ-я к пар-ру неявно разыменовываются. Исп-е ссылок место ук-лей улучшает читаемость проги, а исп-е ссылок место передачи по знач-ю более эффективно, т.к. не требует копирования пар-ров.

Библиотечные ф-ции.

Библиотека графич ф-ций.

Любая прога на С содержит обращ-е к стандартным библиотекам. На стадии препроцессорной обработки проги происходит подстановка прототипов (заголовков) перед осн ф-цией, сами же библ ф-ции хранятся в скомпилированном виде и подкл-ся к осн проге на этапе компоновки. Библ ф-ции можно разбить на ф-ции: ввода-вывода, матем, для обработки строк, для управл-я графич-й системой и др. В графич изображ-и наименьшим эл-том яв-ся пиксель. Чтобы подкл графич-е библ - #include <graphics.h>. Она вкл в себя ф-ции: управл-я цветом; для созд-я изображ-й различных форм; управл-я курсором; ввода текста и др. Экран в графич режиме можно предст-ть в виде (0,0) (0,639)

(319,239)

(0,479) (639,479)

Инициализация графич режима осущ-ся ф-цией initgraph(&gd,&gm,”путь к файлу bgi”). Для обработки ошибок при работе с графикой исп-ся ф-ция graphresult(): если код=0 =>Gr OK. grapherrormsg(код ошибки).

Для установки цвета фона исп-ся ф-ция setbkcolour(цвет); установка цвета линий и символов setcolour(цвет); установка стиля текста settextstyle(шрифт, напр-е, размер): шрифт 0-станд,1-жирн,2-уменьш,3-книжный,4-готич, напр-е 0-гориз, 1-вертикальный, разм 1…10; установка стиля линий setlinestyle(вид, образец, толщина): толщина 1..3, вид 0-сплошная линия, 1-из точек,2-из точек и тире,3-пунктирная, 4-опред-ся пользователем, образец только в том сл, если вид=4. Можно установить стиль закраски setfillstyle(тип закраш, цвет): тип закраски 0…12. Очистка экрана в графич режиме – cleardevice(); Макс знач-я координат getmaxx(); getmaxy(); Текущие координаты getx(); gety(); moveto(x,y)-уст позиции, переустановка ук-ля позиции. moverel(dx,dy)-смещение. Чтобы вывести текст в графич режиме исп-ся outtext(“строка”);-в текущ позицию; outtextxy(x,y,”строка”);-в заданную.

Реш-е графич примитивов.

1) Линия: line(x1,y1,x2,y2); lineto(x,y);-из текущ позиции в т(x,y); linerel(dx,dy); - из текущ позиции в смещенную точку.

2) Прямоуг-к: rectangle(x1,y1,x2,y2); drawpoly(кол-во вершин, ук-ль на массив усл);

3) Окр-сть: circle(x,y,r);

4) Дуга круга: arc(x,y,нач угол, кон угол, r);

Дуга эллипса(---“---“---“---“---,rx,ry);

5) Закраш: bar(x1,y1,x2,y2);

bar3D(x1,y1,x2,y2,глуб,крыша(0-1));

6)Закраш эллипс: fillellipse(x,y,rx,ry);

7)Закраш сектор круга: pieslise(x,y,нач уг,кон уг,r);

8)Закраш сектор эллипса: sector(x,y,нач уг,кон уг,rx,ry);

9)Закраш произв замкн область: floodfill(x,y,граница);

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

Классы памяти.

В компе память предст-ся разделенной на сегменты. Исполняемая прога состоит из сегментов кода, в кот-х расположены машинные команды; сегментов данных, в кот-х глобальные перем-е и константы; сегментов стека, в кот-х расположены локальные перем-е. Остальная, доступная проге память, - динамическая (heap) – в ней располагаются динамические перем-е.

Под всякую перем-ю, исп-ю в проге, должно быть выделено место в памяти ЭВМ. Выделение памяти может происх-ть либо на стадии компиляции (компоновки проги), либо во вр вып-я проги (для динамич-х перем-х).

Каждая перем-я имеет опред-й тип, кроме того, она имеет класс памяти. Сущ-ет 4 класса памяти: 1) extern(внешний);2) auto(автоматич-й);3) static(статич-й); 4) register (регистр).

Класс памяти опред-ся местом ее опис-я и ключевым словом. Класс памяти опред-ют: 1) область видимости (д-я) перем-й; 2) время жизни (продолжительность хран-я перем-й в памяти).

В яз С перем-я может иметь 1 из 3 областей видимости: 1) в пределах файла; 2) в пределах блока; 3) в пределах прототипа ф-ции. Время жизни может быть либо на протяж-и вып-я проги, либо на протяж-и блока.

Внешний класс.

Перем-я, описанная вне ф-ции, - внешняя (глобальная). Если опис-ся внутри ф-ции, то должно быть слово extern.

Файл1 Файл2

int V; void f()

void main() {extern int V;

{extern int V; V=10*V;}

V=5;

f();

cout<<V;}

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

Автоматич класс.

Перем-я, описанная внутри ф-ции, - локальная. По умолч-ю перем-е, объявленные в ф-ции, яв-ся автоматич-ми.

{int m; {auto int m;

float x; auto float x;

...........} .................}

Перем-е автоматич класса размещ-ся в сегменте стека и изнач-но не обнуляются. Область д-я и вр жизни - блок, в кот-м описана эта перем-я.

Статич класс.

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

void f()

{static int K;

...................}

Регистровый класс.

Регистровая память выдел-ся под локальные перем-е - это самый быстрый и маленький вид памяти. Его не рекоменд-ся исп-ть, т.к. эта память исп-ся компилятором.

register int q;

Указатели.

В проце компиляции проги имена перем-х преобраз-ся в адреса ячеек памяти, в кот-х хранятся знач-я перем-х.

Прогр-ст может определить собсв-е перем-е для хранения адресов областей памяти - ук-ли. Ук-ль не яв-ся самост-м типом, он всегда связан с к/либо др конкр типом.

Объявл-е ук-ля: тип *имя перем-й; напр, int *pti; void *pp; - примен-ся в тех сл, когда конкр-й тип объекта, адрес кот-го требуется хранить, неопределен.

Ук-ль может быть константой или перем-й, а т.ж. указ-ть на нее.

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

Знач-е ук-ля перед его исполнением обязательно должно быть иниц-но. Способы иниц-ции: 1) присваивание ук-лю адреса существующего объекта(операция взятия адреса). int a=5; int *pti=&a;

2) присваивание пустого знач-я. ptf=NULL; (NULL - константа, определенная в stdio.h). Это значит, что отсутств-ет конкр адрес ссылки.

3) выдел-е участка динамич памяти и присваивания адреса ук-лю.

Динамическая память.

Доступ к участкам динамич-й памяти осущ-ся только ч/з ук-ли. Для работы с дин памятью исп-ся операции new для выдел-я памяти и delete для освобожд-я.

1)int *n=new int; 2) int*m=new int(10); int *q=new int[10];

1) выделяется участок ДП, достаточный для размещ-я величины типа int, и адрес начала этого участка запис-ся в перем-ю n.

2) кроме того, что осущ-ся в 1 пункте, произв-ся иниц-ция выделенной ДП знач-ем 10.

3) выд-ся память под 10 величин типа int, адрес начала этого участка запис-ся в перем-ю q, кот-я может трактоваться как имя массива.

Освобожд-е ДП: delete n; delete m; delete [] q;.

Операции с указателями.

Операции: 1) разадресация (косвенное обращ-е к объекту х); 2) присваивание; 3) арифметич операции (слож-е с конст, вычит-е, инкремент (++), декремент (--), сравнение, преобраз-е типа, получ-е адреса (&)).

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

int a=5,b,d;

int *pti=&a;

...................

d=*pti;

d=*pti+2;

cout<<b<<d;

- Арифметич операции с ук-лями автоматически учитывают размер типа величин, адресуемых ук-лями.

pti=pti+1 или pti++ //зн ук-ля pti изм на2

ptc++// ptc на 1

ptf++// ptf на 4

Эти операции применяются при работе с стр-рами данных, последовательно размещенными в памяти (напр, с массивами). Инкремент перемещает ук-ль к следующему эл-ту массива, декремент - к предыдущему. Если ук-ль на опред-й тип увелич-ся или уменьш-ся на конст-ту, его знач-е изм-ся на величину этой конст-ты, умноженную на размер объекта данного типа. Разность 2 ук-лей - это разность их знач-й, деленная на размер типа в байтах. Суммирование ук-лей не допускается! Сравнивать можно только ук-ли одного типа. Операция & не может применяться к константе и выр-ям.

Указатели и массивы.

Они тесно связаны м/у собой в С. Имя массива трактуется как ук-ль-константа на массив. Пусть объявлен массив int x[10]; в этом сл х яв-ся ук-лем на нулевой эл-т массива. В связи с этим истинным яв-ся х=&x[0].

x=&x[0]

│ │ │ │ │ │ │ │ │ │ │

x[0] x[1] x[9]

Т.о для доступа к эл-там массива, кроме индексированных имен, можно исп-ть разадресованные ук-ли:

имя[индекс]<=>*(имя+индекс)

x[i]<=>*(x+i)

x[5]<=>*(x+5)

Вот почему индекс первого эл-та массива всегда нулевой; его адрес должен совпадать с адресом массива.

x[i]<=>*(x+0)

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

int x[10], y[10];

int *px=x;

int *py=y;

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

{*py++=*px++;}

Массив как параметр ф-ции.

При исп-ии в кач-ве пар-ра массива в ф-цию передается ук-ль на его первый эл-т (0), т.е. массив всегда передается по адресу, при этом инф-ция о кол-ве эл-тов массива теряется, следует передавать его размерность ч/з отд пар-ры.

Передать массив в ф-цию можно:

func(int ar[N], int N);

func(int ar[ ]; int N);

func(int *ar, int N);

Динамические массивы.

Если до начала работы проги неизвестно, сколько в массиве эл-тов, следует исп-ть динамич массивы. Память под них выд-ся с помощью new в дин области памяти heap во вр вып-я проги. Адрес ее нач-ет запис-ся в ук-ль.

int n=10;

int *a=new int[n];

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

a[3]<=>*(a+3)

Если дин массив в какой-то мом проги больше не нужен, нужно освободить область памяти кот-ю он занимает, с помощью delete[]a;.

Для создания дин многомерного массива необх ук-ть в операции new все его размерности. Самая левая размерность может быть его перем-1.

int nstr=5;

int **m=(int**)new int[nstr][10];

или

int n;

const int m=5;

cin>>n;

int [*a][m]=new int [n][m];

Структуры.

Стр-ра - сложный тип данных, представляющий собой совокупность разнотипных эл-тов. Тип стр-ры обычно исп-ся при разработке инф-ционных сисетм и баз данных. Определение стр-ры -

struct[имя типа]

{ тип_1 эл-т_1;

тип_2 эл-т_2;

.......................

тип_n эл-т_n;}

[список описателей];

Эл-ты стр-ры - поля стр-ры, они могут иметь любой тип, кроме типа этой же стр-ры, но может быть ук-лем на нее.

struct student //имя стр-рного типа, кот-й

{char fam[30]; может быть назначен некот

int kurs; орым перем-м, напр, struct

char group[6]; student stud1,stud2; - перем-

float srball;}; е стр-рного типа.

Может быть совмещено опис-е типа стр-ры и объявл-е перем-х этого типа, напр,

struct student

{char fam[30];

int kurs;

char group[6];

float srball;}

stud1,stud2,*pst; //объявл-е ук-ля на стр-ру student/

Поля стр-ры могут быть данными типа стр-ра, напр,

struct point struct rect

{float x; {struct point p1;

float y;}; struct point p2;};

Иниц-ция перем-х стр-рного типа:

student stud1={"Иванов",1,"РС-118",4.5};

point z={0.5,1};

rect r={{3,4},{5,2}};

Можно иниц-ть перем-е стр-рного типа при описании.

struct point

{float x;

float y;} z={0.5,1};

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

student *pst=new student;

Доступ к эл-там стр-р осущ-ся с помощью операции выбора (операция точка) при обращении к полю ч/з имя стр-ры или с помощью операции "стрелочка" при обращении ч/з ук-ль.

student *pst, stud1;

pst=&stud1;

К каждому эл-ту стр-рной перем-й stud1 можно обратиться 3 способами: 1) stud1.fam; 2) (*pst).fam; 3) pst→fam;

Если эл-том стр-ры яв-ся др стр-ра, то доступ к ее эл-там вып-ся ч/з 2 операции выбора, напр,

struct A

{ int a;

double x;};

struct B

{struct A b;

double x;}S,x;

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

Операции над структурами.

1) Присваивание стр-р, если они имеют одинак тип, при этом происх-т их поэлементное копир-е

пр1: struct student stud1,stud2, *ps;

................................................

stud2=stud1;

(*ps)=stud1;

пр2: struct point a,b;

a.x=1;

a.y=1;

b=a;<=>{b.x=a.x

{b.y=a.y

2) Ввод-вывод стр-р производится, как и для массивов, поэлементно, напр,

cin>>stud.fam>>stud.kurs;

cout<<stud.fam<<" "<<stud.kurs<<endl;

3)Получение адреса стр-ры.

ps=&stud1;

В отличие от массива, имя стр-ры не имеет никакого знач-я.

4) Стр-ру можно возвращать в кач-ве знач-я ф-ции или передавать в ф-цию,напр,

struct point

{float x,y;}

struck point make(float x1, float y1)

{struct point z;

z.x=x1;

z.y=y1;

return z;}

…………….

//вызов ф-ции b=make(1,1)

Передача структуры в ф-цию.

struct point add1(struct point a, struct point b)

{struct point c;

c.x=a.x+b.x;

c.y=a.y+b.y;

return c;}

В этом сл стр-рные перем-е передаются по знач-ю.

При вызове ф-ции в кач-ве фактич аргументов, указ-ся имена стр-рных перем-х.

struct point x,y,z;

z=add1(x,y);

пр2: struct point add2 (struct point *pa, struct point *pb)

{struct point c;

c.x=pa→x+pb→x;

x.y=pa→y+pb→y;

return c;}

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

struct point x,y,z;

………………..

z=add2(&x,&y);

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

Стр-ры, как и др перем-е, могут объединяться в массивы. Массив стр-р – это удобное ср-во представл-я и обработки табличной инф-ции. Так, напр, сведения о 100 студентах могут храниться в массиве стр-р student stud[100], тогда доступ к первому студенту будет осущ-ся: stud[1].fam; stud[5].kurs;

Файлы.

Под вводом-выводом в прогр-и поним-ся проц обмена инф-цией м/у опер памятью и внешними устр-вами. Осн понятие, связанное с инф-цией на внешних устр-вах,- понятие файла. Всякая операция вв/выв трактуется как операция обмена с файлами=>организация вв/выв в яз пргр-я – это организация работы с файлами.

Различают понятия внутр-го (логического) и внешнего (физического) файла. Аналогом понятия внутр файла в С++ яв-ся понятие потока. Поток (stream) – это послед-сть байтов, передаваемая в проце вв/выв и не зависящая от конкр устр-ва, с кот-м произ-ся обмен.

Чтение данных из потока – извлечение. Запись данных в поток – помещение (включение).

Потоки можно разделить на входные (данные вв-ся в память), выходные (выводятся) и двунаправленные. Кроме того, потоки можно разделить на: стандартные (для передачи данных с кл-ры и на экран); файловые (для обмена иф-цией с файлами на внешн носителях); строковые (для работы с массивами символов в опер памяти).

Для поддержки потоков библ С++ содержит иерархию классов, построенную на основе базового класса ios. Класс ios содержит общие для вв/выв поля и методы.

ios

istream ostream

ifstream iostream ofstream

fstream

Стандартные потоки.

Прямыми потомками класса ios (производными классами) яв-ся классы istream (класс вх потоков), ostream (класс вых потоков), их потомком яв-ся iostream (класс двунапр-х потоков вв/выв).

Объект cout принадлежит классу ostream и предст собой поток вывода, связанный с дисплеем. cout<<a; - поместить в поток

и означает, что знач-е а должно быть выведено из памяти на дисплей. cin>>a; - извлечь из потока и означает, что а должно быть введено с кл-ры в память.

Файловые потоки.

При обработке файлов в С++ исп-ся 3 класса: ifstream (класс вх файловых потоков), ofstream (класс вых файловых потоков, осущ-ет операцию ввода), fstream (класс двунапр-х файловых потоков). Эти классы яв-ся производными от классов istream, ostream, iostream, поэтому они наследуют операции <<и>>.

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

Текстовые файлы.

Запись данных в текстовый файл.

I подключаем <fstream.h>

II а) объявляем файловую перем-ю выходного файлового потока ofstream fout; - (файл перем-й).

б) открываем физический файл fout.open(“output.txt”); ofstream fout(“output.txt”[, режим открытия файла]);

III записываем в файл инф-цию fout<<”x=”<<x<<endl;

IV закрываем файл fout.close();

Чтение данных из файла.

I подкл <fstream.h>

II объявл-ем перем-ю входного файлового потока ifstream fin; fin.open(“input.txt”);

III fin>>x;

IV fin.close();