Подякувати Студентському архіву довільною сумою
Admin
26.02.2023 12:38
Дякуємо, що користуєтесь нашим архівом!
Відповіді до теоретичних питань 1 - 30
Інформація про навчальний заклад
ВУЗ:
Національний університет Львівська політехніка
Інститут:
Не вказано
Факультет:
Не вказано
Кафедра:
Не вказано
Інформація про роботу
Рік:
2024
Тип роботи:
Державний іспит
Предмет:
Програмування мовою С
Частина тексту файла (без зображень, графіків і формул):
Програмування мовою С
Структура програми написаної мовою програмування СІ.
Прокоментувати програму та вказати результат.
Програма на С складається із сукупності фуекцій, одна з яких повинна називатись main(). Описані функції складаються з із заголовку і тіла функції. Заголовок містить оператори (директиви) передпроцесора, наприклад, #include та і’мя функції. Ім’я пізнається по круглим дужкам, які можуть бути порожніми. Тіло функції береться у фігурні дужки і складається із ряду операторів, кожний з яких закінчується крапкою з комою (мал. 1).
Проста програма, написана, з врахуванням вимог стандарту ISO/ANSI C, повинна мати наступний формат:
#include <stdio.h>
int main(void)
{
оператори
return 0;
}
Мал. 1. Структура програми
Поняття СІ-машини. Сутність передпроцесора. Макровизначення
та макрофункції. Прокоментувати програму та вказати результат.
Сі-Машина
Сі- машину можна зобразити так:
Передпроцесор
Передпроцесор є першим кроком в побудові вихідного коду Сі-програми на стадії компіляції – це унікальна частина компіляторів мови Сі.
До певної міри перед передпроцесор має свою власну мову, яка є потужним засобом програмування. Памятай, що всі директиви (інструкції) передпроцесора починаються з символа #.
Використання передпроцесора надає програмісту такі переваги:
Полекшена розробка програмного забезпечення,
Код легко читається,
Код легко модифікувати
Сі-код лекше портувати на інші машини (архітектури).
Передпроцесор також дозволяє нам модифікувати мову. Наприклад, замінити блок { ... } на такий як у мові PASCAL, тобто begin... end . Це робиться так:
#define begin {
#define end }
Під час компіляції всі всі входження begin та end будуть замінені відповідними позначеннями { або } і тому інші частини компілятора небудуть знати про цю підміну.
#define
define використовується для оголошення констант чи макровизначень. Наприклад:
#define <macro> <replacement name>
#define FALSE 0
#define TRUE !FALSE
Також можна записувати невеликі функції використовуючи #define. Наприклад:
#define max(A,B) ( (A) > (B) ? (A):(B))
Це означає, що де би непоставити рядок max(C INCLUDEPICTURE "http://www.cs.cf.ac.uk/Dave/C/img25.gif" \* MERGEFORMATINET ,D INCLUDEPICTURE "http://www.cs.cf.ac.uk/Dave/C/img25.gif" \* MERGEFORMATINET ) цей текст буде замінено таким рядком як оголошено зверху. Отхе, якщо в коді написати щось таке:
x = max(q+r,s+t);
то після передпроцесора ми отримаємо, якщо на цей код можна було би подивитись:
x = ( (q+r) > (r+s) ? (q+r) : (s+t));
Ще один приклад #define:
#define Deg_to_Rad(X) (X*M_PI/180.0)
/* перетворення градусів в радіани */
#define LEFT_SHIFT_8 <<8
#undef
Ця команда відміняє макровизначення. Для перепризначення макровизначення його необхідно спочатку відмінити.
#include
Ця директива включає додаткові файли в код. У неї є 2 форми:
#include <file> або #include ``file''
<file> вказує компілятору де знаходяться системні файли, а також назву цих файлів. UNIX-системи зберігають файли у директорії INCLUDEPICTURE "http://www.cs.cf.ac.uk/Dave/C/img3.gif" \* MERGEFORMATINET usr INCLUDEPICTURE "http://www.cs.cf.ac.uk/Dave/C/img3.gif" \* MERGEFORMATINET include INCLUDEPICTURE "http://www.cs.cf.ac.uk/Dave/C/img3.gif" \* MERGEFORMATINET .
``file'' виконує те саме, що і вищеописаний, але використовується для модулів написаних вручну (так прийнято для підвищення читабельності коду).
#if
#if оголошує цілочисельну константу. Воно обовязково завершується дируктивою #endif.
Можна також встановити команду else. Ще одним прикладом використання #if є:
#ifdef
-- if defined and
#ifndef
-- if not defined
Це зручно використовувати для перевірки результатів макровизначень.
Наприклад, для встановлення розміру integer для портування програми з TurboC (MSDOS) на Unix (чи іншу архітектуру) . Нагадаю, що TurboC використовує 16 біт/integer ,а UNIX 32 біти/integer.
Це виконується так:
#ifdef TURBOC
#define INT_SIZE 16
#else
#define INT_SIZE 32
#endif
Ще один приклад:
#if SYSTEM == MSDOS
#include <msdos.h>
#else
#include ``default.h''
#endif
#error
Дозволяє генерувати код помилки
#ifdef OS_MSDOS
#include <msdos.h>
#elifdef OS_UNIX
#include ``default.h''
#else
#error Wrong OS!!
#endif
Характеристика типів даних мови програмування СІ.
Перетворення типів даних. Прокоментувати програму та вказати результат.
Типи даних визначають діапазон допустимих значень та набір допустимих операцій.
В мові СІ є стандартний набір типів даних.
EMBED Visio.Drawing.6
Цілочисельні: char, int, short, long, signed,unsigned, const, volatile.
Дійсні: float, double, long double.
Перелічення enum.
Для задання вказівників та масивів ключових слів немає.
Структури (struct) – це комбінований тип, це об'єкт в середині якого можна описати поля різних типів.
Об'єднання (union) – це об'єкт, який дозволяє в різні моменти часу зберігати дані різних типів.
Згідно формату IEEE усі від'ємні дані зберігаються в пам'яті комп'ютера у доповняльному коді.
Для цілочисельних даних допустимі усі операції.
Для задання порядку виконистовується спосіб вирівнювання на середину діапазону: float -127, double – 1023, long double – 16383.
У форматах float та double старша одиниця в мантисі не зберігається.
Перетворення типів даних
розширення
char -> int -> long 8->16->32
Для знакових розширення відбувається шляхом розмноження знакового розряду в старших байтах. Для беззнакових старші розряди заповнюються "0".
Зменшення
long -> int -> char 32->16->8
Перетворення відбувається шляхом відкидання старших байт.
3.
short -> int 16 -> 16
int -> unsigned 16 -> 16
long -> unsigned long 32 -> 32
Не змінює побітового представлення, але дані інтерпретуються згідно інших форматів.
4. Цілі -> Дійсні
Перетворення цілих в дійсні відбувається через тип long.
Перетворення коректне, якщо діапазон дозволяє.
5. Дійсні -> Дійсні
З менших в більші перетворення однозначні. Перетворення з більших в менші відбувається шляхом заокруглення.
6. Дійсні -> Цілі
Перетворення відбувається через тип long. Перетворення відбувається шляхом відкидання дробової частини.
Поняття покажчика в мові програмування СІ. Покажчики та
масиви. Адресна арифметика. Прокоментувати програму та вказати результат.
Мова програмування С відзначається своєю гнучкістю серед інших мов. Це, зокрема, добре видно при роботі із вказівниками. Вказівник – це змінна, що містить адресу певного об’єкту (не плутати з ООП).
специфікатор тип * ідентифікатор[=конст,&змінна],[,…];
Приклад:
int *my_pointer;
int *my_pointer=5;
int *my_pointer=&x;
Вказівник займає 2,4 або 6 байт. У реальному режимі вказівник займає 2 або 4 байти. 2 байти для near (перехід в одному сегменті), 4 для far та huge(нормалізований вказівник) для міжсегментного переходу. В захищеному режимі вказівник займає 6 байт.
Над вказівниками можна виконувати ряд цілочисельних операцій та порівнянь. Дві основні операції – це отримання адреси (&) та звертання за адресою (*). Перед використанням вказівники слід ініціалізувати. Стандарт ANSI C дозволяє використовувати нетиповані вказівники:
void *my_pointer;
Вказівники та масиви тісно повязані між собою. Назва масиву є адресою першого елемента:
my_array==&my_array[0];
В мові С не контролюється вихід за межі масиву.
При використанні вказівників для роботи із масивами слід мати на увазі,що додавання 1 до вказівника, перемістить його на наступний елемент, незалежно скільки байт займає цей елемент. Різниця вказівників дає результат,що рівний кількості елементів (лише для вказівників однакового типу). Доступ до елементів масиву можна здійснювати як за допомогою вказівників
k=*(my_array+5);
так і за допомогою класичного запису:
k=my_array[5];
Записи k=my_array[5] та k=5[my_array] рівнозначні
k=*(my_array+5) k=*(5+my_array)
оскільки від перестановки доданків сума не міняється.
Операції мови програмування СІ та їх пріоритет. Порядок
обчислення виразів. Побічні ефекти. Перетворення та приведення типів. Прокоментувати програму та вказати результат.
INCLUDEPICTURE "http://do.rksi.ru/library/courses/demo/t3_1-1.gif" \* MERGEFORMATINET
Порядок обчислення виразів.
= a=b=c=0; ←
+ -/ % *
/-для цілих – буде тільки ціла частина
%- виключно для цілочисельних даних – залишок від ділення
Інкрементні, декрементні ++,-- цілочисельні, одномісні і застосовуються до операторів в памяті
а++; --в;
Префіксна операція передбачає спершу зміну обєкту, а пізніше участь нового значення в обрахунку решти виразу
Постфіксна передбачає участь старого значення обєкту в обрахунку виразу, а пізніше його зміну
a=++b+2; (b=b+1; a=b+2;)
a=b++ 2; (a=b+2; b=b+1;)
6. Операції відношень – двомісні
7. Результатомоперацій відношення буде ціле число: істина -1, хиба -0
c=2>3; c==0; c=(2<3)+3;
11. 12. Логічні
!-НЕ &&-І ||-АБО
В лог операція любе ціле (в тому числі і відємне) сприймається як істина, 0 сприймається як хиба
Обрахунок виразу припиняється, якщо результат вже відомий
i<5 && c++!=2
Бітові – порозрядні
~ інверсія & конюнкція ↑ додав за мод 2 | дизюнкція << >> зсуви вліво, вправо
Операнд справа зсувається на задану кількість біт, що задає операнд справа
При зсуві вліво праві біти заповнюються нулями
При зсуві вліво розмножується знак
Int b=-16;
Int a; a=b<<2; (a=-64)
Адресні
& -отримати адресу
*-звернутись за адресою для запису або читання
Int a,*b; b=&a;
(тип)-приведення до типу
Int a; a=1.6+1.5; (3.1)
a=(int)1.6+(int)1.5; (2)
sizeof(вираз) – результатом є цілочисельне значення, яке рівне кількості байт памяті для розміщення вказаного обєкту в памяті
sizeof(a)==2; sizeof(int)==2;
Складні перетворення
14. a=a+b; a+=b; x=x+(y-2); x+=y-2;
Умовна операція
вир1?вир2:вир3
вир2 при істині вир1
вир3 при хибі вир1
‘,’ розділяє два підвирази у виразі
Гарантується, що підвирази будуть обраховуватись послідовно зліва направо, якщо це умовний вираз, то результатом умовнго виразу буде значення виразу, що обраховувався останнім
If (a=b,c>a) буде с>a
Операція () – у виразах задає найвищий пріоритет
[]- звертання до масивів
.
-> операції звертання до складних структур типів даних
Struct.name
Ptr_student->name;
Приведення та Перетворення типів даних
Перетворення над обєктами здійснбється явним чином та за замовчуванням
Явним – операція приведення до типу
(тип) вираз;
float,double,long double → long → int → char і навпаки
Перетворення неявним чином
Відбуваються при обчисленні виразів, в операціях присвоєння та при передачі фактичних параметрів у функції:
Long double→long double
double→double
unsigned long→unsigned long
long→long
unsigned→unsigned
char,short→int
unsigned char,unsigned short→unsigned
8→16→32
80→64→32→16→8
1) char→int 8→16
unsigned char→unsigned int 8→16
int→long int 16→32
Для беззнакових зліва додаються 0, для знакових - розмноження знаку
2) short→int 16→16
int →unsigned int 16→16
long→unsigned long 32→32
char →unsigned char 8→8
Перетворення, які не змінюютьс бітового представлення, а дані трактуються згідно інших форматів
3) int→char 16→8
Unsigned →unsigned char 16→8
long→int 32→16
unsigned long→unsigned int 32→16
Перетворення відбуваються відкиданням старших байтів
4) Перетворення цілі-дійсні
Перетворення коректне, якщо діапазон представлення дохволяє
5) дійсні→дійсні
flot→double→long double і назад
З більшого дійсного до меншого дійсного відбувається шляхом заокруглення
6) Дійсні до цілих →long ближчий результат.
Функції та структура програми мовою програмування СІ. Оголошення функцій. Поняття прототипу. Порядок передачі та перетворення аргументів.
Програма складається з сукупності фунцій, одна з яких повина називатися main(). Опис функції складається з заголовка і тіла функції. Заголовок містить оператори(директиви) препроцесора, наприклад, #include і ім'я функції. Тіло функції розташоване у фігурних дужках і складається з ряду операторів, кожен з яких закінчується крапкою з комою. Приклад програми, що буде наведений нижче, містить ще і оператор оголошення, який оголошує ім'я і тип змінної, що буде використовуватися. Крім того в ньому був присутній оператор присвоєння, що присвоює значення змінній.
Коротко кажучи, проста програма, що написана з вроахуванням вимог стандарту ISO/ANSI C, повинна мати наступний формат:
Загловок:
#include<stdio.h> //- Інструкції препроцесора
int main(void) //- ім'я ф-ї з аргументами
Тіло:
{
int q; // - Оператор оголошення
q=1; //Оператор присвоєння
printf(“%d is neat. \n”,q); // Оператор виклику ф-ї
return 0;
}
Функція – це самостійний фрагмент тексту програми, що призначений для виконання конкретної задачі.
Зміст визначення функції очевидний. Це повна характеристика її типу і її параметрів разом із повним текстом її команд, що служать реалізацією функції, наприклад,
int gcd (int m, int n)
{
while (m != n)
if m>n m=m-n; else n=n-m;
//m == n
return m;
}
Кожна функція визначається один раз, а використовується багато разів у різних файлах. Для компіляції викликів компілятору досить мати лише інформацію про кількість і типи параметрів, а також тип результату. Сам код тепер непотрібен. Він буде потрібен лише компонувальнику. Тому користуються оголошенням функції , яке ще називають її сигнатурою . Ось сигнатура попередньої функції
int gcd (int m, int n);
або навіть
int gcd (int, int);
яка читається так: ціла функція двох цілих параметрів. В цьому випадку виконання функції повинне закінчуватись командою виходу, параметром якої служитиме цілий вираз. Його значення і є результатом виконання функції.
Функція може не повертати значення. В цьому випадку її сигнатура починається словом void.
Перед появою стандартної мови ANSI C існувала проблема оголошення ф-й, бо тоді оголошувався тип значення, що повертає ф-я, а не її аргументи. Тому в стандарті ANSI C можна оголошувати і типи аргументів. Результатом є прототип ф-ї.
Приклад
int imax(int, int);
int imax(int a, int b);
Усі параметри, за винятком параметрів типу покажчик та масивів, передаються за значенням. Це означає, що при виклику функції їй передаються тільки значення змінних. Сама функція не в змозі змінити цих значень у викликаючій функції. Наступний приклад це демонструє:
#include<stdio.h>
void test(int a)
{
a=15;
printf(" in test : a==%d\n",a);
}
void main()
{
int a=10;
printf("before test : a==%d\n",a);
test(a);
printf("after test : a==%d\n",a);
}
Наступний приклад демонструє, що при активізації (виклику) функції копії створюються для параметрів, що передаються за значенням, а для параметрів, що передаються за допомогою покажчиків цього не відбувається. У функції два параметри - one, two - передаються за значенням, three - передається за допомогою покажчика. Так як третім параметром є покажчик на тип int, то він, як і всі параметри подібного типу, передаватиметься за вказівником:
#include <stdio.h>
void test(int one, int two, int * three)
{
printf( "\nАдреса one дорівнює %р", &one );
printf( "\nАдреса two дорівнює %р", &two );
printf( "\nАдреса three дорівнює %р", &three );
*three+=1;
}
main()
{
int a1,b1;
int c1=42;
printf( "\nАдреса a1 дорівнює %р", &a1 );
printf( "\nАдреса b1 дорівнює %р", &b1 );
printf( "\nАдреса c1 дорівнює %р", &c1 );
test(a1,b1,&c1);
printf("\nЗначення c1 = %d\n",c1);
}
На виході ми отримуємо наступне:
Адреса а1 дорівнює FEC6
Адреса b1 дорівнює FEC8
Адреса c1 дорівнює FECA
Адреса one дорівнює FEC6
Адреса two дорівнює FEC8
Адреса three дорівнює FECA
Значення c1 = 43
Поняття покажчика на функцію в мові програмування СІ. Приклади використання.
Існують мови програмування, в яких немає відмінності між програмами і даними. Певною мірою ця можливість представлена в С++ указниками функцій. Так визначення
double (*f) (double);
читається як: нехай f указник на довільну дійсну функцію дійсного аргументу.
Інший запис без дужок
double *f (double);
Від оголошення функції, наприклад,
double sqr (double x);
визначення указника відрізняється тим, що оголошення доповнюється одним визначенням імені функції, наприклад,
double sqr (double x) { return x*x; }
в той час як указник може набувати довільних значень
double *f (double) = 0;
f = sqr ;
f = sin;
бути елементом масиву
double (*g[10]) (double);
Визначення типів дозволяють скорочувати запис
typedef double (*F) (double);
Тепер F повноцінне ім’я типу. Можливі будь-які із наведених нижче варіантів
F f = sqr;
F f = 0;
F f;
f = sqr;
Непрямий виклик функції за її указником записується одним з двох рівносильних способів: f(a) або (*f)(a).
Покажчики функцій не замінимі при визначенні функціоналів — функцій, параметрами яких служать інші функції
double Newton (double a, double b, double eps,
double (*f) (double))
//або
//double Newton (double a, double b, double eps, F f)
{
while ( (b-a)>eps)
do
{
if (f(a)*f(0.5*(a+b))<0)
//те ж саме: (*f)(a)*(*f)(0.5*(a+b)
b = 0.5*(a+b);
else
a = 0.5*(a+b);
}
return a;
}
Виклики функції запишуться, наприклад, так
x1 = Newton (-1.0, 2.0, 0.00001, sqr);
x2 = Newton (0, pi, 0.00001, cos);
Багатомодульне програмування засобами мови СІ. Поняття файлу проекту. Використання директив умовної компіляції. Навести приклади.
Модулі
При багатомодульному програмуванні всі (або більшість) констант, змінних, функцій... зберігаються в модульних файлах. Проблеми виникають коли декілька файлів повинні використовуть змінні, що зберігаються в них. Найкраще є централізовано зберігати всі визначення в 1 файлі , і цей файл буде використовуватись всіма файлами. Такий файл називається модулем. Модульні файли не є виконавчими.
Існують стандартні бібліотечні файли, наприклад:
#include <stdio.h>
Можна також створювати та підключати власні модулі:
#include ``my_head.h''
Розглянемо такий приклад:
INCLUDEPICTURE "http://www.cs.cf.ac.uk/Dave/C/mod.gif" \* MERGEFORMATINET
main.c:
/*
* main.c
*/
#include "header.h"
#include <stdio.h>
char *AnotherString = "Hello Everyone";
main()
{
printf("Running...\n");
/*
* Call WriteMyString() - defined in another file
*/
WriteMyString(MY_STRING);
printf("Finished.\n");
}
WriteMyString.c:
/*
* WriteMyString.c
*/
extern char *AnotherString;
void WriteMyString(ThisString)
char *ThisString;
{
printf("%s\n", ThisString);
printf("Global Variable = %s\n", AnotherString);
}
header.h:
/*
* header.h
*/
#define MY_STRING "Hello World"
void WriteMyString();
Кожен модуль компілюється окремо. Файл main викликає функцію WriteMyString() з файлу WriteMyString.c. Прототип цієї функції описаний в модулі Header.h
Переваги багатомодульного програмування
Можливість командної роботи над програмою.Кожен програміст розробляє свій модуль.
Обєктно-орієнтований стиль написання програм. Кожен файл може «спеціалізуватись» на 1 обєкті і мати фукції обробки лише його. Крім того, реалізація обєкта є прихованою від інших користувачів.
Добре зроблені функції (чи обєкти ) можна використовувати для інших програм, що полекшує процес створення нових програм.
Користувач такого файлу неповинен звертати увагу на різні низькорівневі нюанси роботи
При зміні функції (чи обєкту) лише 1 файл має бути перекомпільований.
Директиви умовної компіляції це те саме, що і директиви передпроцесора
(див. пит. 2)
Класи пам’яті в мові програмування СІ. Глобальні та локальні змінні. Прокоментувати програму та вказати результат.
Кожна змінна чи функція належить до якогось класу пам’яті. Клас пам’яті задається за замовчуванням чи явним чином. Клас пам’яті визначає: місце розташування (стек, регістри чи оперативна пам’ять), час існування та область видимості.
Місце розташування. За замовчуванням усі змінні належать до автоматичного класу пам’яті, тобто зберігаються у стеку. Вони утворюються при виділенні кадру стеку і пропадають при звільнені кадру стеку. Статичні змінні містяться в оперативній пам’яті. Ця пам’ять виділяється при завантажені програми до виконання і звільняється при закінчені роботи програми. Динамічні змінні містяться у області пам’яті, що називається “купа” (heap).
Час існування. На час блоку: появляються при вході в блок та зникають при виході із блоку (розміщуються у стеку). На час функції та на час усієї програми.
Область видимості. В межах блоку (локальні та глобальні), в межах функції та в межах файлу. Одноіменна локальна змінна відміняє дію у блоці аналогічної глобальної змінної.
Класи пам’яті задаються явним чином специфікаторами: auto, register, static, extern.
auto. Автоматичний клас. Всі локальні змінні та формальні параметри функції за замовчуванням відносяться до автоматичного класу. Автоматичні змінні завжди зберігаються у стеку (породжуються при вході у блок і зникають при виході). При виділенні – пам’ять не обнуляється. Можлива ініціалізація за допомогою виразів, де зустрічаються інші змінні.
register. При використанні цього специфікатора, локальні змінні та формальні параметри зберігаються у регістрах процесора. У регістрах можна зберігати тільки ті дані які не перевищують розрядності регістрів. Оскільки регістри працюють на частоті процесора то дані регістрового класу доцільно використовувати у місцях де ці дані часто використовуються (наприклад лічильники циклів). Клас пам’яті register – це тільки рекомендація компілятору розмістити змінні у регістрах. Якщо немає вільних регістрів то змінні стають класу auto. Адресу регістрової змінної отримати неможливо. При виділенні – пам’ять не обнуляється.
static. До цього класу відносяться всі зовнішні та внутрішні статичні змінні. Пам’ять виділяється в оперативній пам’яті. Час існування на весь час роботи програми. При виділенні – пам’ять обнуляється. Статично в пам’яті зберігаються рядки. Статичні змінні класу static як внутрішні так і зовнішні, іх область видимості обмежена. Для внутрішньої області видимості є в межах блоку, хоча час існування – на весь час роботи програми, але область видимості обмежена блоком. Для зовнішньої змінної статичниого класу пам’яті область видимості обмежена файлом. Будь – яка глобальна змінна за замовчуванням відноситься до зовнішнього класу extern.
Оголошення та ініціалізація масивів в мові програмування СІ.
Зв'язок масивів з покажчиками. Прокоментувати програму та
вказати результат.
Масив – це набір об’єктів однакового типу, розташованих один за одним у пам’яті комп’ютера. Масив можна описати наступним чином:
тип_даних ім’я_масиву [розмір_масиву]
Кожний масив має ім’я. Значення індексу повинні знаходитись у діапазоні від нуля до величини, що на одиницю менше розміру масиву, вказаного під час його опису. Тип_даних задає тип елементів масиву. Розмір_масиву – константа чи константний вираз, що задає кількість елементів масиву. Ім’я масиву є вказівником-константою, що дорівнює адресі початку масиву (першого байта першого елемента масива). Доступ до окремих елементів масива може здійснюватись або за допомогою імені масива та індексу (порядковому номеру) або за вказівником (операція *). Іншими словами, наступні посилання будуть повністю еквівалентними:
array[i] *(array+i)
Масиви також можуть бути багатомірними:
тип_даних ім’я_масиву [розмір1] [розмір2] [розмір3]…. [розмірN] – оголошення масиву
int a[10]; //ініціалізація масиву на 10 елементів
int i=0;
for (i=0;i<10;i++)
{
a[i] = i; //заповнення масиву числами відповідними їх номеру
}
printf(“Виведення масиву:\n”);
for (i=0;i<10;i++)
{
printf(“ %d”, a[i]);
}
Оголошення масивів вказівників в мові програмування СІ.
Використання командного рядка аргументів. Привести приклад.
Масиви вказівників оголошуються наступним чином:
тип_даних * ім‘я_масиву []
Масиви вказівників часто застосовуються для керування великими структурами даних або стрічками. Вони дозволяють при їх сортуванні не переписувати великі дані із комірки в комірку, а змінювати тільки значення вказівників, що значно пришвидшує роботу.
Одним із застосувань також являється передача аргументів з командної стрічки, яка здійснюється у наступному форматі:
int main(int argc, char * argv[])
argc – параметр, який містить кількість переданих параметрів
argv – параметр, який є масивом вказівників на кожен із параметрів, переданих через командний рядок.
Першим параметром завжди йде шлях до виконуваної програми. Наприклад:
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
if (argc>1)
{
if (!strcmp(argv[1],"hello"))
{
printf("Hello :-))\n");
}
}
printf("Bye!\n");
return 0;
}
Дана програма при передачі через командний рядок їй параметра hello вітається у відповідь, якщо параметр не був переданий – нічого не відбувається.
Для прочитання складного виразу необхідно:
почати зі змінної і читати направо до закриваючої дужки;
зустрівши закриваючу дужку починати читати від змінної до відкриваючої дужки;
і т.д. рекурсивно;
int * a;
a = (int*)malloc(sizeof(int));
*a = 10;
printf("++*a = %d\n", ++*a);
Результатом виконання програми буде виведення числа 11.
Використання структур в мові програмування СІ. Опис типу, оголошення та ініціалізація змінних. Операції звертання до структурних змінних. Прокоментувати оголошення та вказати результат операції sizeof().
Структурна змінна – це об’єкт, який складається з одного чи кількох полів, можливо різних типів, об’єднаних під одним іменем. Класичним прикладом структурної змінної є об’єкт, який відображає облікову картку працівника. Для роботи зі структурами необхідно:
оголосити структурний тип, який визначає правила виділення пам’яті під об’єкт та правила звертання до членів структури;
оголосити структурну змінну, тобто виділити пам’ять під об’єкт.
Структурних типів може бути безліч, вони відрізняються за іменем типу:
struct[ім’я_типу] {
тип1 поле1;
тип2 поле2;
..................;
типN полеN; };
Членами структур можуть бути дані будь-якого типу, за винятком функцій та тієї самої структури.
Примітка: інша структура може бути членом даної структури.
Ім’я типу записується за правилами ідентифікаторів і має бути унікальним в межах області сприйняття.
Ім’я структурного типу може співпадати з іменем поля структури, бо це імена різних класів. Імена полів структури є внутрішінми в межах блоку, тобто в різних структурних типах імена полів можуть співпадати.
Приклад:
struct BOOK
{
char name [20];
char title [40];
int year;
float price;
};
Опис сприйняття шаблону може бути в межах блоку і функції або в межах файлу. Extern-описи структурних типів не використовуються.
struct BOOK – ім’я типу
sizeof (struct BOOK) == 66
Оголошення змінних.
Можна оголошувати окремим записом:
тип ідентифікатор ;
struct BOOK one_book;
sizeof(one_book)==66;
Опис типу та оголошення змінних можна об’єднати за наступним принципом:
struct BOOK
{
………… ;
………… ;
} first_book;
Всі поля структури розміщені підряд в порядку оголошення:
Адреса структурної змінної співпадає з адресою першого поля.
Якщо дано:
struct A
{
float x;
float y;
};
то можна записати:
struct A
{
float x, y;
};
Приклад:
struct BOOK one_book, two_book, *ptr_book;
one_book=two_book;
Звертання до членів структури:
За іменем:
ім’я_змінної.ім’я_поля
приклад:
one_book.year=2004;
two_book.year=one_book.year;
strcpy(one_book.name, “Kolyada”);
strcpy(&one_book.name[0], “Kolyada”);
За адресою. Можна обчислити адресу змінної або адресу окремого поля.
ptr_book=&one_book;
(*ptr_book).price=23.45;
two_book=*ptr_book;
ptr_book->price=56.2;
&one_book.price;
&ptr_book->price;
Ініціалізація структури.
В момент оголошення структурні змінні можна ініціалізувати. В якості ініціалізатора використовують константи відповідних типів. Ініціалізатори мають бути задані в такій послідовності, щоб вони відповідали послідовності полів структурного типу.
struct BOOK one_book =
{
“Kolyada”,
“System programming”,
1990,
45.99
};
Вкладені структури.
Приклад:
struct UDC
{
char class;
int number;
}
struct BOOK
{
struct UDC udc;
struct UDC *p_udc;
char name[20];
char title[40];
int year;
float price;
} book, *ptr;
book.udc.number=200;
Звертання за іменем до полів вкладених структур здійснюється оператором, в якому послідовність задається ієрархією імен до самого нижнього.
book.p_udc=&book.udc;
book.p_udc->number=201;
ptr=&book;
ptr->p_udc->number=202;
Структура не може входити сама в себе, а вказівник на відповідну структуру може.
1. struct BOOK0
{
struct BOOK0 *last;
struct BOOK0 *next;
char info[100];
};
2. struct BOOK1
{
struct BOOK1 book; – ПОМИЛКА!
char info[100];
};
В С дозволено оголошувати масиви структур.
struct BOOK lib[100];
lib[i].name;
(*(lib+i)).name;
(lib+i)->name;
Структури та функції.
Структурні змінні можуть опрацьовуватись функціями як за значенням так і за допомогою адреси. У випадку передачі структурної змінної в якості аргумента за значенням, вона повністю копіюється у стек. Функції можуь повертати структурні об’єкти як результат. Швидкодія програми в цьому випадку низька. У випадку передачі вказівника на структуру швидкодія збільшується і це більш вживана практика програмування.
Приклад 1:
#include <stdio.h>
#include <string.h>
typedef struct {…} BOOK;
BOOK example (BOOK);
void main (void)
{
BOOK first={“Kasatkin”, “SysProgramming”, 1992, 79.99};
BOOK ret;
ret=example(first);
printf(“%s%s%d%f\n”, first.name, first.title, first.year, first.price);
printf(“%s%s%d%f\n”, ret.name, ret.title, ret.year, ret.price);
}
BOOK example (BOOK book)
{
strcpy(book.name, “Kernighan”);
strcpy(book.title, “C Programming”);
book.year=1993;
book.price=69.88;
}
Приклад 2.
#include <stdio.h>
struct lib
{
char *last_name;
char *first_name;
int number;
};
void main (void)
{
struct lib data[3]={“Last_Name1”, “First_Name1”, 1,
“Last_Name2”, “First_Name2”, 2,
“Last_Name3”, “First_Name3”, 3,
};
print_data(data+2); //Адреса 3-го елемента
}
void print_data(struct lib *d)
{
printf (“\n Last name is %s and first name is %s”, d->last_name,
d->first_name);
}
Приклад 3.
#define LEN 20
struct name1
{
char first[LEN];
char last[LEN];
} A1;
struct name2
{
char *first;
char *last;
} B1;
A1
sizeof(A1)==40
B1
sizeof(B1)==4
struct name2 A1 = {“Kolyada”, “Serhiy”};
Використання об’єднань в мові програмування СІ. Опис типу, оголошення та ініціалізація змінних. Операції звертання до змінних типу об’єднань. Прокоментувати програму та вказати результат.
Тип обєднання подібний до структури, тобто може містити поля різних типів, при цьому всі поля розміщаються в одній спільній області памяті.
В конкретний момент часу змінна типу обєднання може містити дані лише одного поля.
Обсяг памяті, що виділяється під таку змінну = розміру поля найбільшої довжини.
Визначення типу та оголошення змінних подібно структурам, за виключенням union
Для опису типу використовується шаблон
Union [імя_типу] {
тип1 поле1;
тип 2 поле2;
...
тип n поле n;
};
Оголошення змінної
Union імя_типу імя_змінної;
Можна обєднувати опис типу та оголошення змінної.
Тип члена обєднання може бути довільним, в тому числі структури та інші обєднання
В середину обєднання не може входити оголошення ф-й і не може входити само в себе.
В момент оголошення змінної типу обєднання її можна ініціалізувати. Ініціалізація відбувається завжди по першому полю.
Обєднання використовуються для буферизації даних різних типів в одному місці.
Звертання до полів обєднань аналогічно структурам, тобто за іменем та за адресою
union record *ptr;
ptr=&data;
data.i==ptr->i;
Дозволяється використовувати масиви обєднань.
Обєднання можуть зявлятися в середині структур, а структури в середині обєднань
struct {
double r;
union {char s[20];
int i;} x;
int b:7;} d;
Опис типу, оголошення та ініціалізація змінних
Опис – встановлює властивості обєкту
Оголошення – встановлює властивості та виділяє память під обєкт
В сі є специфічний спосіб визначення власних типів даних
Typedef –специфікатор типу даних
typedef <oldname><newname>;
typedef float REAL;
Оголошення змінних
Змінні перед використанням необхідно оголосити при цьому вони типізуються
[клас памяті][мод1]тип [мод][*] [мод2]ідент[=зн][,ідент][=зн]…
Int a;
Int a,b,c;
Int a,b=3,c=1;
Клас памяті визначає місце розташування обєкту, час існування та область сприйняття.
Auto
Register
Static
External
мод2-за замовч. Всі імена програми сприймаються як імена мови С
це можна задати явним чином cdec, Pascal, Fortran, prolog
мод1 – const, volatile
const –передбачає, що обєкт не можна змінювати
volatile-змін, за замовч
const float pi=3.14;
const volatile int a=2; текучим процесом обєкт змінити не можна, а зовнішнім можна.
[мод][*] імя, яке оголошуєтьься справа буде вказівником
ncar-2 б
far – 4 б
huge – 4 б
[0002:0005]
Нормалізовані вказівники можна порівнювати а far –ні
Вказівник можна ініціалізувати константою, або через операцію отримання адреси.
Int *p=100;
Int *p=&a;
Int *const pi=&a;
Const int *cost p=&a;
Int *far ptr;
Практика програмування мовою СІ з використанням структур даних типу черг, списків, дерев. Функції динамічного розподілу пам’яті. Написати фунцкцію згідно завдання.
В програмуванні виникає необхідність формувати власні структури даних типу масиви невизначеної довжини, черги, списки, дерева, графи тощо. Це передбачає динамічне використання пам’яті. Мова програмування С містить спеціальні функції для забезпечення динамічного розподілу пам’яті:
void *malloc (size_t size);
Функції сімейства malloc розміщують в пам'яті блок завдовжки принаймні <size> байт. Блок може бути більш ніж <size> байт, оскільки потрібне місце для регулювання і для збереження інформації. Місце в пам'яті, на яке показує повернуте значення, гарантує надійне розміщення oб’єкта будь-якого типу. Функція malloc повертає NULL якщо не вдається виділити блок пам’яті розміром <size> байт
void *calloc(size_t num,size_t size);
Функція calloc виділяє місце для зберігання масиву з <num> елементів, кожний завдовжки <size> байт і автоматично анулює елементи виділеної пам’яті
void *realloc( void *memblock, size_t size );
Функція realloc змінює розмір раніше виділеного блоку пам'яті. Аргумент <memblock> вказує на початок блоку. Якщо він рівний NULL, то функція realloc (подібно malloc) виділяє новий блок завдовжки <size> байт. Якщо <memblock> не NULL, він повинен бути вказівником, що повертається calloc, malloc або раніше викликаним realloc. Аргумент <size> задає новий розмір блоку в байтах.
Функція realloc повертає void-покажчик на новий блок пам'яті. Повертається значення NULL, якщо <size> = 0 або якщо пам'яті недостатньо, щоб розширити блок до заданого розміру. В першому випадку початковий блок звільняється. В другому випадку, він залишається незмінним. Крім того, якщо в поточному просторі пам’яті, де розміщений <memblock> не вистачає місця для розширення, то виділяється місце в іншому просторі пам’яті
void free(void *memblock );
Функція звільнює розміщений в пам”яті блок (задається параметром <memblock> , який раніше був розміщений calloc, malloc или realloc). Якщо <memblock>=NULL, то він не опрацьовується.
Абстрактні типии даних:
Список – це скінчена сукупність даних одного типу, між якими налагоджений зв'язок. Елемент списку складаються з двох частин: поля даного (даних) і вказівника на наступний елемент списку.
Однозв’язний лінійний список (елемент) містить поле даних і вказівник на наступний елемент.
Двозв”язний лінійний список (елемент) містить поле даних, вказівник на наступний елемент і вказівник на попередній елемент.
Циклічний список – останній елемент містить вказівник на перший (немає null)
INFO
INFO
INFO
INFO
INFO
INFO
NULL
begin
Для списків характерні такі операції: додавання елементу, перевірка на порожність, видалення елементу, підрахунок кількості елементів, заміна елементів (обмін місцями), звертання до елементу списку, видалення елементу, пошук за ключем.
Не стидайтесь, додавайте від себе, бо мені влом писати цей брєд :) :
Стек – подібний до списку, але працює за принципом LIFO. Тобто додавання і вилучення елементів відбувається лише в кінці списку. Для стеку не характерне вилучення довільного елементу.
Черга – (FIFO) подібна до списку, але додавання елементів відбувається до кінця списку а вилучення з початку списку.
Дерево – вид списку, в якому елемент може бути зв’язаним з декількома. Якщо елемент може бути зв’язаний максимум з двома елементами, то таке дерево бінарне (думаю у всіх вистачить розуму намалювати дерево :))
Граф – вид дерева, в якому будь-який елемент може бути зв’язаний з будь-яким іншим. Кількість зв’язків не обмежена, можливі цикли на відміну від дерев, а також деякі елементи можуть бути не зв’язані з іншими елементами графу взагалі.
Ділись своїми роботами та отримуй миттєві бонуси!
0%
Оголошення від адміністратора