Шпоры по информатике2
.doc
Модульное прогр-е. Ф-ции. В яз С минимальным исполняемым прогр-ным модулем яв-ся ф-ция. Сложная задача при прогр-и на С может быть разделена на более простые ф-ции (подзадачи). Это позволяет упростить стр-ру проги, избежать избыточности кода (ф-ция запис-ся 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(); |
|
|
|
||||||||||||||||||||||||||||||
|
|
|
|
|
|||||||||||||||||||||||||||||
|
|
|
|
|