Програмиране и Използване на Компютри – част I
(Компютри и Приложения)
Учебна година: 2009/10 ОКС:
бакалавър Специалност: ККЕТ-ФЕА
ПРОТОКОЛ N 8 от
лабораторно упражнение на тема:
Основни елементи
на езика С. Структура на програмата.
|
Фак. N
|
Студент име
|
|
355
414
|
Митко
Димитров Кацев
|
Проучете много внимателно
информацията и примерите от Приложение 1. Отговорете на поставените
по-долу въпроси максимално точно и ясно и не веднага на момента,
а когато считате, че отговорът Ви ще бъде максимално точен и ясен. Санкционират
се: неверни отговори, неточни отговори, неясни отговори, правописни грешки.
|
1.
|
Какво не е наред с всяко от изброените имена на
променливи?
1) _test_ 4) sum 1
2) 2variable 5) temp-sum-1
3) $dollar 6) num_0043-1
|
|
Имената
на променливите могат да бъдат съставени от всякакви символи, цифри и букви.
Не могат да се използват само думите които служат за команди. Следователно
няма проблем с изброените имена на променливи.
|
|
|
|
|
|
2.
|
За какво се използват стандартните библиотечни функции
в езика С?
|
|
За
извършване на стандартни операции, които са групирани в различни
заглавни(хедърни) файлове за да могат по лесно да се извикат и изпълнят.
Такива функции са: за входно-изходни операции, математически функции, функции
за работа с низове и др.
|
|
|
|
|
|
3.
|
Какво е предназначението на хедърните файлове и как се
добавят към програмата?
|
|
Хедърните
файлове се използват за да съхранят стандартните библиотечни функции и да
улеснят тяхното използване. Хедърните файлове се добавят в началото на
програмата, извикват се с командата “#include”, следва името на хедърният
файл в скоби “< >”, като
името завършва с разширението “.h”.
|
|
|
|
|
|
4.
|
Дайте примери за стандартни функции от езика С и
посочете хедърните файлове, които съдържат информация за техните прототипи!
|
|
Функции
за входно-изходни операции: <stdio.h>
Математически
функции: <math.h>
Функции
за работа с низове: <string.h>
|
|
|
|
|
|
5.
|
Кои са 5-те основни типа данни, поддържани от С?
|
|
void, char, int,
float,
double
|
|
|
|
|
|
6.
|
Как се поставят коментари в програма на С? Дайте
пример!
|
|
Като накрая на жаления ред поставим “//” и след тях
запишем коментара, като за коментар се счита всичко след “//”.Другият вариант
е след даден ре се записва “/*”, след
това записваме коментара, без значение на колко реда е и накрая записваме “*/”,
като в този случай за коментар се смята всичко между “/*” и “*/”.
Пример:
int Prom //декларираме променлива от
целочислен тип
|
|
|
|
|
|
7.
|
Може ли да съществуват вложени коментари на езика С?
|
|
Многоредовите
коментари не могат да бъдат вложени, а едноредовите могат да бъдат вложени в многоредов.
|
|
|
8.
|
Посочете разликите между локална и глобална променлива!
|
|
Локалните
са дефинирани в тялото на дадена функция и могат да се използват само в нея.
А глобалните са дефинирани извън всички функции и могат да се използват във
всяка една функция от програмата.
|
|
|
9.
|
Кога се създават и кога унищожават локалните
променливи?
|
|
Всяка
локална променлива се
създава
само когато функцията бъде извикана и се унищожава, след като се излезе от функцията.
|
|
|
10.
|
Кога се създават и кога унищожават глобалните
променливи?
|
|
Глобалните
променливи се създават преди началото на конкретна/ни функция/и и се
унищожават когато програмата завърши.
|
|
|
|
|
|
11.
|
Какво съдържа прототипът на дадена функция? Дайте
пример!
|
|
Прототипът
на дадена функция съдържа: името на функцията, типа на резултата и списъка с
аргументите й.
int func(void)
float func2(int a, float b)
int main()
|
|
|
|
|
|
12.
|
За какво се използват прототипите на функциите?
|
|
Прототипът указва на компилатора, че определена функция
съществува, но тялото на функцията е някъде другаде.
|
|
|
|
|
|
13.
|
За какво се използват функциите printf() и scanf()? Дайте примери!
|
|
За
изход и вход на информация.
printf(“Въведете
число: ”); //Извежда текста: “Въведете число: ” на екрана.
scanf("%d", &P); //Присвоява на променливата P стойността на десетичното
число, въведено от клавиатурата.
|
|
|
|
|
|
14.
|
За какво се използват форматиращите параметри при
извикване на функциите printf() и scanf()? Дайте примери!
|
|
За да
определят броя и вида на въвежданите/ извежданите аргументи.
|
|
|
|
|
|
15.
|
Каква е разликата между декларация и дефиниция на
функция?
|
|
Декларацията определя името и типа на данните, докато дефиницията прави
не само това, но и казва на компилатора да запази памет за променливата.
|
|
|
|
|
|
16.
|
Как функциите връщат стойност на извикващите ги конструкции?
|
|
Връщането на стойност в извикващата конструкция става
чрез ключовата дума return. Пише се:
return <<стойността която се връща>;
|
|
|
|
|
|
17.
|
Функция, наречена myfunction()
притежава 3 параметъра: един int, наречен test1, един float, наречен test2 и един char, наречен test3.
Функцията не връща стойност. Напишете нейния прототип!
|
|
int myfunction(int test1, float test2, char test3)
|
|
|
|
|
|
18.
|
Напишете програма, която изисква от вас да въведете
цяло число, дробно число и символ, след което изобразява въведените стойности
на екрана.
|
|
#include
<stdio.h>
void
main(void)
{int
a;
float
b;
char
c;
printf("vyvedete
cqlo 4islo, drobno 4islo i simvol: ");
scanf("%d
%f %s", &a, &b, &c);
printf("cqloto
4islo e %d,drobnoto e %f i cimvola e %c",a,b,c);}
|
|
|
19.
|
Напишете програма, която изисква от вас въвеждането на
две цели числа и след това изобразява тяхната сума, частното и остатъка от
делението им на екрана.
|
|
#include <stdio.h>
int main()
{int a,b,suma,chastno,ostatyk;
printf("vyvedete 2 celi 4isla");
scanf("%d" "%d", &a, &b);
suma=a+b;
chastno=a/b;
ostatyk=a%b;
printf("sumata e %d,chastnoto e %d i ostatyka e
%d",suma,chastno,ostatyk);
return 0;}
|
|
|
20.
|
Напишете програма, която изисква от вас въвеждането на
дробно число и след това го отпечатва с противоположен знак.
|
|
#include
<stdio.h>
int
main()
{float
a;
printf("a=");
scanf("%f",&a);
printf("-%f",a);
return
0;}
|
|
|
|
|
|
21.
|
Напишете програма, която изисква въвеждането на число и
отпечатва квадратен корен от него.
|
|
#include
<stdio.h>
#include
<math.h>
int
main()
{float
a;
printf("a=");
scanf("%f",&a);
a=sqrt(a);
printf("%f",a);
return
0;}
|
|
|
|
|
|
22.
|
Напишете програма, която намира и извежда на екрана
лицето на куб. Нека програмата да изисква от потребителя да въведе всеки един
от размерите.
|
|
#include <stdio.h>
int main()
{float a;
printf("vyvedete stranata na kuba");
scanf("%f",&a);
a=6*a*a;
printf("liceto na pylnata povyrhnina na kuba e %f",a);
return 0;}
|
|
|
|
|
|
23.
|
Напишете програма, която изчислява броя на секундите в
1 час, 1 седмица, 1 месец и 1 година.
|
|
#include <stdio.h>
int main()
{long int chas,sedmica,mesec,godina;
chas=60*60;
sedmica=7*24*chas;
mesec=30*24*chas;
godina=365*24*chas;
printf("sekundite v 1 4as, 1 sedmica, 1 mesec i 1 godina sa
syotvetno %d,%d,%d,%d",chas,sedmica,mesec,godina);
return 0;}
|
|
|
|
|
|
24.
|
Напишете програма, която разменя стойностите на две
променливи А и В (ако А=3, В=5, да стане А=5, В=3).
|
|
#include <stdio.h>
int main()
{int A,B,P;
printf("vyvedete A i B");
scanf("%d""%d",&A,&B);
P=A;
A=B;
B=P;
printf("%d,%d",A,B);
return 0;}
|
|
|
|
|
|
25.
|
Напишете програма, която намира и извежда на екрана
обиколката и лицето на произволен правоъгълник.
|
|
#include
<stdio.h>
int
main()
{int
a,b,S,P;
printf("vyvedete
stranite na pravoygylnika");
scanf("%d""%d",&a,&b);
S=a*b;
P=2*a+2*b;
printf("Liceto
i obikolkata sa syotvetno: %dkv.sm.,%dsm.",S,P);
return
0;}
|
|
|
|
|
|
26.
|
Напишете програма, която намира и извежда на екрана
обиколката и лицето на произволен триъгълник по зададени ъгъл a(Alpha) и прилежащите му страни b и c. За намиране на
лицето да се използва формулата:
 |
|
#include
<stdio.h>
#include<math.h>
int
main()
{int
b,c;
float
alfa,S;
printf("vyvedete
2 ot stranite na triygylnika i ygyla zakliu4en mejdu tqh: ");
scanf("%d""%d""%f",&b,&c,&alfa);
S=b*c*sin(alfa)/2;
printf("Liceto
e: %f",S);
return
0;}
|
|
|
|
|
|
27.
|
По дадена температура на въздуха по Фаренхайт, да се
изчисли температурата по Целзий. Връзката между двете скали е следната:
 ,
където C е температурата по Целзий, а F - температурата
по Фаренхайт.
|
|
#include
<stdio.h>
int
main()
{float
C,F;
printf("Wyvedete
temperaturata po farenhait ");
scanf("%f",&F);
C=(F-32)*5/9;
printf("Temperaturata
po celzii e : %fgradusa",C);
return
0;}
|
|
|
|
|
|
28.
|
Напишете програма, която намира сумата на първите n естествени числа, като се използва
формулата за намиране на сумата на първите n члена на аритметична прогресия.
|
|
#include
<stdio.h>
int
main()
{int
S,i,n;
printf("n=
");
scanf("%d",&n);
S=(1+n)*n/2;
printf("Sumata
na pyrvite %d 4lena na progresiqta e %d",n,S);
return
0;}
|
|
|
|
|
|
29.
|
Напишете програма, която изчислява лицето на триъгълник
по дадени три страни a, b и c. Използвайте формулата
 , където p е полупериметърът на триъгълника. |
|
#include
<stdio.h>
#include
<math.h>
int
main()
{int
a,b,c;
float
p,S;
printf("wyvedete
stranite na triygylnika");
scanf("%d""%d""%d",&a,&b,&c);
p=(a+b+c)/2;
S=sqrt(p*(p-a)*(p-b)*(p-c));
printf("Liceto
na triygylnika e %fkv.sm.",S);
return
0;}
|
|
|
|
|
|
30.
|
Напишете програма за изчисляване и отпечатване на
разстоянието между две точки в равнината, зададени чрез координатите си (x1, y1) и (x2, y2).
|
|
#include
<stdio.h>
#include
<math.h>
int
main()
{int
x1,x2,y1,y2;
float
a,b,c;
printf("wyvedete
kordinatite na dvete to4ki");
scanf("%d""%d""%d""%d",&x1,&y1,&x2,&y2);
b=abs(y1-y2);
a=abs(x1-x2);
c=sqrt(a*a+b*b);
printf("raztoqnieto
mejdu to4kite e %f.",c);
return
0;}
|
|
|
|
|
|
31.
|
Напишете програма, която намира и извежда на екрана
стойността на израза
 |
|
#include
<stdio.h>
#include
<math.h>
int
main()
{float
x,y,e,z;
printf("wyvedete
x i y");
scanf("%f""%f",&x,&y);
e=2.71828183;
e=pow(e,y/3);
z=(abs(x-y)*e)/(1/2+cos(x/2));
printf("z=
%f",z);
return
0;}
|
|
Приложение
1
Езикът С е много мощен и гъвкав структурен език. Първата
разработка е на Денис Ричи съвместно с Кен Томпсън през 1972.
Като всеки език и той се характеризира със свои азбука, синтаксис и семантика.
1.
Азбука – набор от допустими символи
(букви, цифри и специални символи)
а)
A ¸ Z и
a ¸ z
б)
0 ¸ 9
в)
специални символи : _ ~ @ # $ % ^ & * ( ) - + / { } : ; “
< > , ? ‘ \ . =
2.
Лексеми
а) ключови думи – думи които не могат да се използват за имена на функции или променливи,
например: auto, break, case, char, const,
else, if, for... (32 думи);
б) числени, низови и символни константи – константите са стойности (числа, еденични символи или символни последователности), зададени
чрез директното им записване в програмният код. Те имат постоянна стойност която след
компилирането присъства като част от машинният код на програмата. Константите могат да бъдат:
Ø цели числови:
–
десетични със знак (+ или –) (+ се подразбира и може да се
пропуска) +12 12
-12
–
осмични със знак (+ или –) (означават се с 0 пред осмичното число) +014 014
-014
–
шестнадесетични със знак (+ или –) (означават се с 0x пред
числото) +0xB2 0xB2 -0xB2
Ø дробни числови: 12.0 или +12.0; -12.23; .12; -321; -2.14e-17.
Ø символни: един символ в апострофи: ’0’ след компилирането представлява байт
със стойност 48 (ASCII кода на символа 0). Възможно е
задаването на символни константи за специални не печатими символи като ’\n’. Това става аналогично на начина описан по-долу.
Символът за единична кавичка се задава чрез удвояване ’’’’
или чрез предхождаща го обратно
наклонена черта ’\’’.
Ø
низови:
последователност от допустими символи, затворени в двойни кавички. Дължината е
неограничена. Допуска се използването на специални не печатими символи, които
се записват с помоща на точно определен печатим символ предшестван от обратно наклонена черта например: \n – символ
за нов ред; \t –
хоризонтална табулация; \r –
връщане на каретата; \0 – байт
със стойност 0 и други. Допуска се и използването директно на ASCII кода на
символа който е необходим като след обратната наклонена се записва стойността,
която може да е три или по-малко цифрено осмично число (например \214) или дву
или по-малко цифрено шестнадесетично число, предшествано от x (например \x1F).
Самата обратно наклонена черта се записва чрез удвояването й –
”този низ съдържа една единствена обратно
наклонена черта (\\)”. Символът
за двойни кавички се записва така: \” или така: ””. След
компилирането низовата константа присъства в продуцирания машинен код като
последователна поредица от байтове със стойностите на съответните ASCII кодове
на символите и в края й (след последният байт) автоматично е поставен байт със
стойност 0. Например: ”това е низ”; ”това\40също\x20e низ\n”; ”” – низ с нулева дължина (след
компилирането се представя чрез самостоятелен байт със стойност 0)
3.
Оператори:
•
аритметични;
•
логически;
•
управляващи;
4.
Разделители:
•
шпация;
•
табулация;
5.
Коментар: при компилиране коментарът се
замества с интервал и се разглежда като разделител. Не присъства по никакъв
начин в продуцирания машинен код. Поставянето на коментари е от първостепенна
важност при разработването на сериозен софтуер, то може силно да улесни
четенето и разбирането на програмният код от множество програмисти работещи по
даден проект, а и от самият програмист писал даден код, когато се наложи да
„преоткрие” идеите си след известно време.
/*..........
..........*/
- многоредов коментар
//.................... - едноредов коментар
6.
Идентификатор: последователност от допустими букви и цифри, която се използва за име
на функция или променлива и винаги започва с буква. Долната черта (_) се приема
за буква. Идентификаторите отговарят на следните условия:
•
не се допускат разделители;
•
различават се от ключовите думи;
•
прави се разлика между малки и големи букви;
7.
Променлива – именувана част от паметта, която
може да съдържа различни стойности по време на изпълнение на програмата. Всички
променливи трябва да се дефинират, преди да могат да се използват. Дефиницията
на променливата показва на компилатора от какъв тип е използваната променлива
(цяла, дробна и др.). Общият вид на конструкцията за дефиниция е:
<тип> <име_на_променлива>;
където <тип> е тип за данни в С, а <име_на_променлива> е име (идентификатор) на променливата.
Съществуват две места, където може да се дефинират променливи: в тялото на някоя
функция или извън всички функции. Променливите, дефинирани извън всички
функции, се наричат глобални и могат да се използват (достъпни са) във всяка
функция в програмата. Променливите, дефинирани в тялото на дадена функция, се
наричат локални и са достъпни само във функцията, в която са дефинирани.
В стандартното C локални
променливи могат да се дефинират само в самото начало на функцията.
8.
Присвояване на стойност – присвояването на стойност на
дадена променлива се извършва чрез оператора за присвояване „=”. Името на
променливата се поставя от лявата страна на оператора за присвояване, а
стойността, която искаме да й присвоим – отдясно. Например:
sum = 0;
След
извършване на операцията по присвояване самата тя се интерпретира като стойност
(равна на токущо присвоената) и може да участва в изрази. Например:
Sum1 = Sum2 = 0; Sum1 = 4 + (Sum2 = 0);
9.
Типове данни – типът на данните определя:
•
множеството допустими стойности;
•
необходимата памет;
•
множеството допустими операции;
С поддържа 5 основни (вградени) типа данни:
|
Тип
|
Значение
|
|
void
|
Специален тип данни; означава
„без стойност”; Ползва се при дефини-ции и декларации на функции и като възможен
тип за сочените от указател данни.
|
|
char
|
Символи
(по-точно ASCII код на символи),
записвани в 8 бита (-128 ÷ 127); Могат да се интерпретират
както като символи така и като числени стойности, в зависимост от контекста в
които се използват.
|
|
int
|
Цели числа със знак,
записвани в 16 (-32768 ÷ 32767), 32 (-2147483648 ÷ 2147483647) или 64 бита.
Определя се от типа на платформата
(16, 32 или 64–битов процесор) за която се компилира програмата.
|
|
float
|
Числа с плаваща
запетая, записвани в 32 бита
(-3.4E-38 ÷ +3.4E+38); точност до шестия знак
|
|
double
|
Числа с плаваща запетая с двойна точност, записвани в 64 бита
(-1.7E-308 ÷ +1.7E+308); точност до десетия знак.
|
Примери: int i, j = 2;
float p, l, k;
Тези основни типове, с изключение
на void, могат да се модифицират за
по-точно описание чрез използването на модификаторите на типове:
|
long
|
За числа с по-голям
размер
|
|
short
|
За числа с по-малък
размер
|
|
signed
|
За определяне на
целочислена стойност със знак
|
|
unsigned
|
За определяне на
целочислена стойност без знак
|
Модификаторът на тип предшества
името на типа, например:
unsigned int x;
•
signed, unsigned – тези два
модификатора могат да се приложат при целите числа и символите. По същество, тези модификатори не
променят размера на разрядната решетка, а само тълкуването на данните в нея.
Модификаторът signed означава, че данните се тълкуват като записани в допълнителен код.
Модифицираните със signed данни могат да приемат положителни
и отрицателни стойности. Модификаторът unsigned означава, че данните се тълкуват
като записани в прав код и данните могат да заемат само положителни стойности и
0. Тези модификатори могат да се прилага и в комбинация с long и short. Модификаторът signed може да бъде пропуснат, тъй като
това е модификаторът по подразбиране за данните от тип int и char. Когато се работи с данни от тип unsigned int, ключовата дума int може да бъде
пропусната, тъй като се подразбира.
•
short, long – тези модификатори могат да се
приложат при целите и реалните числа. Двата модификатора променят размера на
разрядната решетка в зависимост от някои установени конвенции на конкретния
компилатор. Модификаторът short задава два пъти по-къса разрядна решетка от нормално заделяната за
даденият тип, а long - два пъти по-дълга. За типа long float е дефинирана и се използва
специална ключова дума – double. Възможно е при дадени условия някой от модификаторите да не указва
влияние върху размера на разрядната решетка. Например при 32-битова платформа int и long int имат еднакъв
размер (32 бита).
10.
Етапи в процеса на компилиране
•
Предпроцесор. Това по същество е помощно
средство, което не извършва никакви действия по същинското компилиране на
програмата и смисълът от съществуването и ползването му е в това, че създава
немалък брой улеснения в процеса на създаването на сорс кода на програмата. Работата
му се ограничава на ниво сорс код и се изразява главно в това, че
непосредствено преди компилирането в зависимост от поставените в самият сорс
код команди към предпроцесора наречени предпроцесорни директиви се
извършват автоматични интервенции върху него, чрез които той се привежда в
окончателен вид необходим за същинският процес на компилиране. Всички
предпроцесорни директиви се отличават от кода на C по това че започват със знака #. Някои от най
често използваните от тях са:
–
#include: Вмъкване на текстови файл. Директивата е последвана от името на файла,
който ще се вмъква оградено в знаците < и > или от двойни кавички, като
разликата е, че в първият случай файла се търси в директорията с хедърни
файлове зададена по подразбиране, а във вторият – първо в текущата директория и
после в тази с хедърните файлове. Резултата от изпълнението й е, че текста на
зададеният файл се вмъква на мястото където е срещната.
–
#define: Дефиниране
на макрос. Макросите са имена, отговарящи на
условието за идентификатори. Директивата позволява задаване на „стойност” на
макроса, която може да е произволна комбинация от символи. Например: #define MAIN void main(void) Тук MAIN е името на макроса, а void main(void) е „стойността” му. След дефинирането си, макроса е познат на предпроцесора
и всяко срещане на името му в текста на програмата бива заместено с
дефинираната стойност. Възможно е дефиниране на макроси без стойност и такива с
параметри. Първите намират приложение главно при директивите за условно
компилиране, където и в зависимост от това дали е дефиниран даден макрос
определен участък от сорс кода може да се премахне или не. Вторите се явяват
мощно средство за минимизация на повторното писане на сходен код когато това по
някаква причина не може да бъде избегнато чрез дефиниране на функция и за
създаване на по-лесно четим код.
–
Други: Съществуват още редица директиви
за условно компилиране и такива предоставящи възможност за контрол на
настройките на компилатора.
•
Компилатор. Той получава като вход
обработеният от предпроцесора сорс файл и извършва компилацията му като
продуцира машинен код. Резултата от работата му е обектен файл, съдържащ
смесица от машинен код и указания и команди към свързващият редактор (Линкера).
•
Линкер. Той извършва свързване на
обектните файлове продуцирани от компилатора (понеже в реалността проектите се
състоят от повече от един модул (файл със сорс код) продуцираните от
компилатора обектни файлове в общият случай са повече от един) и код от
библиотеки за статично свързване (ако в обектните файлове има обръщения към
функции намиращи се в тези библиотеки). Резултата от работата на линкера е
изпълним файл.
11.
Структура на програма, написана на
С - най-общо, една С програма съдържа
следните основни части:
/* включване на хедърни файлове */
/* прототипи на функции */
/* главна функция*/
void main(void)
{
/* … */
}
тип_на_резултат име_на_функция_1(списък_с_аргументи)
{
/* … */
}
...
тип_на_резултат име_на_функция_N(списък_с_аргументи)
{
/* … */
}
Всички програми на С се състоят от
части (програмни единици), наречени функции. Броят им е неограничен.
Само една функция обаче се дефинира като главна – функцията main() и всяка С програма трябва да я притежава. Тя осъществява връзка с ОС и по
същество е мястото, откъдето започва изпълнението на програмата. Друг важен
компонент във всички програми на С са стандартните библиотечни функции,
групирани в различни раздели – функции за входно-изходни операции,
математически функции, функции за работа с низове и др. Прототипите на
стандартните функции и декларациите на евентуално ползвани от тях структури от
данни, константи и др. се намират в т. нар. заглавни (хедърни) файлове
– файлове с разширение .h. Ако в програмата се ползват стандартни функции, заглавният файл, който ги
описва трябва задължително да бъде включен. С-компилаторът използва
информацията от тези файлове, за да обработи правилно извикваните функции.
Функцията е
набор от последователно записани оператори, които осъществяват действия,
представящи логическа цялост. Обикновено, синтаксисът на една С функция е
следният:
<тип_на_резултат> име_на_функция(списък_с_аргументи)
{
поредица от оператори
}
Типът на резултата определя типа
на данните, връщани от функцията и може да е всеки един от поддържаните от
езика типове данни, включително и void. Име на функция може да бъде всеки
валиден идентификатор, който до момента не е бил използван по друг начин.
Аргументите (параметрите) на функцията се използват за предаване на информация
и ако са повече от един, се разделят със запетаи. Аргументите на функциите се дефинират,
като се зададе типът и името им. Например:
int function1(int x, float y, double z)
{
поредица от оператори
}
Ако функцията не използва аргументи,
нейният списък с аргументи трябва да се състои от ключовата дума void или може
да бъде оставен празен.
Поредицата от оператори се нарича
тяло на функцията и задава действията, които функцията трябва да извърши.
Пример:
#include <stdio.h>
int main(void)
{
printf("Това е моята първа програма.\n");
return 0;
}
Когато създавате ваши собствени
функции, връщането на стойност в извикващата конструкция става чрез ключовата
дума return. Общата форма на конструкцията е
return стойност;
return може да се използва нееднократно навсякъде в тялото на функцията като
винаги изпълнението й предизвиква приключване на функцията.
Според приетата конвенция,
стойност 0, връщана от main() показва, че програмата е
завършила своето изпълнение нормално.
Възможно е да се
използва функция преди реално тя да е дефинирана (все пак дефинирането й в
по-късен момент на компилация на текущият модул, в друг модул или в библиотека
е неизбежно). За да се осъществи такова използване е необходимо тя да се
декларира. Това става, като се запише прототипът на функцията. Прототипът се
състои от името на функцията, типа на резултата и списъка с аргументите й. Той завършва
с точка и запетая. След като е намерил прототип на функция компилатора
позволява тя да бъде извиквана като евентуалното и дефиниране също е допустимо,
но то трябва да съответства на прототипа.
12.
Аритметични и логически операции
|
Аритметични операции и приоритет
|
|||
|
C символ
|
Приоритет
|
Функция
|
Пример
|
|
( )
|
1
|
операция в скоби
|
(a + b) / c
|
|
*
|
2
|
умножение
|
a * b
|
|
/
|
2
|
деление
|
a / b
|
|
%
|
2
|
остатък при целочислено деление
|
a % b
|
|
+
|
3
|
събиране
|
a + b
|
|
-
|
3
|
изваждане
|
a – b
|
|
=
|
4
|
присвояване
|
a = b
|
|
Операции за отношение
|
||
|
C символ
|
Значение
|
Пример
|
|
==
|
a равно на b
|
a == b
|
|
<
|
a по-малко b
|
a < b
|
|
<=
|
a по-малко
или равно b
|
a < = b
|
|
>
|
a по-голямо b
|
a > b
|
|
>=
|
a по-голямо или равно b
|
a >= b
|
|
!=
|
a различно b
|
a != b
|
|
Логически операции
|
||
|
C символ
|
Значение
|
Действие
|
|
!
|
Логическо “не”
|
NOT
|
|
||
|
Логическо “или”
|
OR
|
|
&&
|
Логическо “и”
|
AND
|
13.
Елементарен вход – изход
а)
функция printf() – използва
се за извеждане на информация. Общият й вид е: printf(“форматиращ_низ”, аргументи);
•
форматиращ_низ – знаков низ който освен че се изписва на екрана също определят броя
показвани аргументи и вида на представянето им. Той може да съдържа форматиращи
параметри, който се обозначават със знака %.
•
аргументи – променливи или изрази, които ще извеждаме. В общият случай броят им
съвпада с броя форматиращи параметри в знаковият низ. Важно е да се отбележи,
че съвпадението на броя, типовете и последователността на аргументите с броя,
определяните типове и последователността на форматиращите параметри е
отговорност на програмиста и всички некоректни в този аспект варианти, които са
синтактично и семантично верни биха се компилирали без проблем, като дори не
бих предизвикали генериране на предупреждение. В общият случай резултата от
това е силно изненадващ изход на дисплея, но в ситуацията когато броя
форматиращи параметри е по – голям от броя аргументи е почти сигурно, че ще се
стигне до прекратяване на изпълнението на програмата.
•
Примери:
printf(“С
не е толкова труден”);
printf(“,
нали? \n”);
printf(“%5d %3d”, x, y);
|
Форматиращи
параметри
|
|
|
Параметър
|
Значение
|
|
%c
|
извежда един символ
|
|
%d
|
извежда десетично цяло число със знак
|
|
%e
|
означение (3.6E-5) за представяне на много голямо или много малко реално число
|
|
%f
|
извежда
десетично число с плаваща запетая
|
|
%g
|
общ формат за представяне на e или f
|
|
%o
|
извежда
осмично
число
|
|
%p
|
извежда
указател
|
|
%s
|
извежда
низови
стойности
|
|
%u
|
извежда
десетично цяло число без
знак
|
|
%x
|
извежда шестнадесетично
число
|
|
%%
|
Извежда знака за процент
|
б)
функция scanf() - тази
функция осигурява форматиран вход от
стандартно входно устройствово – клавиатура. Общият й вид е:
scanf(“форматиращ_низ”, аргументи);
• форматиращ_низ – поставят се в двойни кавички и
определят броя и вида на въвежданите аргументи. Всеки форматиращ параметър
започва с %.
• аргументи – това са адресите на променливите,
които ще приемат въвежданите стойности. Необходимо е съответствие между
параметри и аргументи по брой, тип и място в списъка. В противен случай
опасностите са като при printf(), но тук вероятността да се стигне до прекратяване на изпълнението на програмата
е далеч по-голяма. Важно е и да не се забравя използването на оператора за
извличане на адрес (&), който е задължителен за коректната работа на scanf(), но изпускането му не би довело
до грешка или предупреждение при компилиране, но за сметка на това със
сигурност ще доведе до изключително странно поведение на програмата при
изпълнението й и нерядко до прекратяване на изпълнението. Пример:
scanf(“%d %f”, &i, &x);
в)
функция getchar() - тази функция въвежда един символ, или
по-точно неговия ASCII
код, от клавиатурата. Не изисква аргументи, но скоби трябва да има както и при
всяко извикване на функция, неизискваща аргументи. Функцията връща кода на
символа:
име_на_променлива = getchar( );
М = getchar( );
При въведен символ Y, М = 89, кода на Y.
14.
Троен оператор
void main(void)
{
int a, b = 4, c = 8;
a = (b > c) ? b :
c;
printf("Ако b
> c то a = b, иначе a = c: %d", a);
}
15.
Унарни оператори
|
sum = sum++;
|
sum =
sum + 1;
|
|
sum = sum--;
|
sum =
sum – 1;
|
|
sum = a + b++;
|
sum =
a + b; b = b + 1;
|
|
sum = a + b--;
|
sum = a + b; b = b – 1;
|
|
sum = a+ ++b;
|
b = b + 1; sum = a + b;
|
|
sum = a+ --b;
|
b = b - 1; sum = a + b;
|
16.
Операции върху битове
|
a
|
1 0 0 1 0 0 1 1
|
|
b
|
1 1 1 1 0 0 0 0
|
|
a & b
|
1 0 0 1 0 0 0 0
|
|
a | b
|
1 1 1 1 0 0 1 1
|
|
a ^ b
|
0 1 1 0 0 0 1 1
|
|
a = b >> 2
|
0 0 1 1 1 1 0 0
|
|
a = a << 3
|
1 0 0 1 1 0 0 0
|
|
a = ~ b
|
0 0 0 0 1 1 1 1
|
|
C символ
|
Значение
|
|
&
|
И
|
|
|
|
ИЛИ
|
|
^
|
изключващо ИЛИ
|
|
>>
|
отместване на
дясно
|
|
<<
|
отместване
на ляво
|
|
~
|
инвертиране
|
17.
Комбинирани оператори
|
a *= b;
|
a = a * b;
|
|
a /= b;
|
a = a / b;
|
|
a += b;
|
a = a + b;
|
|
a -= b;
|
a = a - b;
|
|
a %= b;
|
a = a % b;
|
|
a <<= b;
|
a = a << b;
|
|
a >>= b;
|
a = a >> b;
|
|
a &= b;
|
a = a & b;
|
|
a |= b;
|
a = a I b;
|
|
a ^= b;
|
a = a ^ b;
|
Примери: Въведете примерите, компилирайте, изчистете от
грешки и изпълнете програмите в среда на С.
Осмислете синтаксиса, структурата на С
програма и действието на разглежданите функции:
а) Програма, която изчислява средно
аритметично на 3 числа:
#include
<stdio.h>
void main(void)
{
float a, b, c, d, average;
printf("Въведете три числа:");
scanf("%f %f %f", &a, &b, &c);
d = a + b + c;
average = d/3.0;
printf("Средно аритметичното е %f", average);
}
б) Програма, която при въведен
радиус, изчислява площта и дължината на окръжност:
#include <stdio.h>
#define PI 3.14159
void main(void)
{
float area, circum, radius;
printf("На колко е равен radius?\n");
scanf("%f", &radius);
circum = 2*PI*radius;
area = PI*radius*radius;
printf("Параметрите на окръжността са следните:\n");
printf("Дължина на окр.= %1.2f, Площ =
%1.2f\n", circum ,area);
}
в) Програма, която изписва квадрата
на число, въведено от клавиатурата. Квадратът се изчислява чрез функцията calculate_square():
#include <stdio.h>
int calculate_square(void);
void main(void)
{
int square;
square = calculate_square();
printf("Квадратът е: %d”, square);
}
int calculate_square(void)
{
int number;
printf(“Въведете
число: ”)
scanf("%d", &number);
return number*number;
}
Няма коментари:
Публикуване на коментар