C KALBŲ ABC - VPU biblioteka - Vilniaus pedagoginis universitetas

VILNIAUS PEDAGOGINIS UNIVERSITETAS 

FIZIKOS IR TECHNOLOGIJOS FAKULTETAS 

Aušra Kynienė 

C KALBŲ ABC 

Metodinė priemonė 

VILNIUS, 2004 

1

Darbas apsvarstytas ir rekomenduotas skelbti Teorinës fizikos 

ir informaciniø technologijø katedros posëdyje 2004 m. spalio 

mën. 06 d., protokolo Nr. 2. 

Recenzavo: prof. Joana Lipeikienë 

dr. Artûras Acus 

2 

© Aušra Kynienė, 2004 

© Vilniaus pedagoginis universitetas, 2004

TURINYS 

PRATARMË ...................................................................................5 

C KALBOS PRANAÐUMAI .........................................................6 

PROGRAMAVIMO PROCESAS .................................................8 

OPERATORIAI..............................................................................9 

PAPRASTOS PROGRAMOS STRUKTÛRA .............................12 

DUOMENØ IR KINTAMØJØ TIPAI .....................................14 

UÞDUOTYS.................................................................................15 

SIMBOLINËS EILUTËS, FUNKCIJOS PRINTF ( ) IR 

SCANF ( ) ....................................................................................15 

UÞDUOTYS.................................................................................19 

VEIKSMAI, REIÐKINIAI IR OPERATORIAI .........................20 

PAGRINDINIAI VEIKSMAI ....................................................22 

UÞDUOTYS.................................................................................26 

LOGINËS OPERACIJOS ...........................................................27 

OPERATORIUS IF .....................................................................27 

SÀLYGINËS OPERACIJOS .......................................................29 

LOGINËS OPERACIJOS ...........................................................30 

SÀLYGINË OPERACIJA: ?: .......................................................31 

OPERATORIUS SWITCH .........................................................31 

UÞDUOTYS.................................................................................33 

CIKLAI IR KITI PROGRAMOS VALDYMO BÛDAI ............33 

KITI VALDANTIEJI OPERATORIAI.......................................36 

MASYVAI ....................................................................................37 

UÞDUOTYS.................................................................................38 

KAIP TEISINGAI NAUDOTIS FUNKCIJOMIS? ..................38 

PAPRASTOS FUNKCIJOS KÛRIMAS IR JOS 

PANAUDOJIMAS ......................................................................40 

GLOBALIEJI (IÐORINIAI) IR LOKALIEJI (VIETINIAI) 

KINTAMIEJI ..............................................................................43 

UÞDUOTYS.................................................................................44 

REKURSINËS FUNKCIJOS .....................................................44 

UÞDUOTIS ..................................................................................45 

MASYVAI IR RODYKLËS .........................................................45 

3

ÁVESTIES IR IÐVESTIES BYLOS C KALBOJE .......................48 

SIMBOLINIØ EILUÈIØ PAKEITIMAS ..................................52 

UÞDUOTYS.................................................................................52 

LITERATÛRA ..............................................................................53 

PRIEDAS ......................................................................................53 

C KALBOS RAKTAÞODÞIAI ...........................................................53 

PROGRAMOS VYKDYMO VALDYMAS .............................................54 

4

PRATARMË 

„C kalbos ABC” metodinio leidinio paskirtis – supaþindinti 

su C kalbos programavimo pagrindais. Knygelë skirta visiems, 

kurie nori iðmokti ðiuolaikinës programuotojø kalbos. 

Programuojant, kaip ir uþsiimant bet kuria kita veikla, patirtis 

ágyjama dirbant, todël ðioje metodinëje priemonëje pateikiama 

daug uþduoèiø dirbti savarankiðkai. Ði metodinë 

priemonë ðiek tiek praplësta: pateikiamos ir sudëtingesnës 

temos, kuriø gali prireikti, kuriant sudëtingesnes programas. 

Èia visiðkai nekalbama apie grafikos kûrimo elementus. 

Leidinyje gausu pateiktø programø pavyzdþiø, taèiau dalis 

programø yra nebaigtos ir, norint, kad ðios programos 

veiktø, paèiam skaitytojui reikës jas papildyti. Leidinio pabaigoje 

pridedamas priedas, kuriame patekiama C kalboje 

naudojamø funkcijø santrauka. 

Ðis leidinys studentams turëtø padëti suprasti C kalbà ir 

pramokti patiems ðia kalba raðyti programas. Norintiems daugiau 

susipaþinti su C ir C++ kalba rekomenduojama paskaityti 

literatûros sàraðe minimas knygas [1–5]. 

5

C KALBOS PRANAÐUMAI 

C programavimo kalba – tai dideliø galimybiø programavimo 

kalba, vis labiau naudojama visame pasaulyje. Dabartiniu 

metu ði kalba – pagrindinë profesionalø programavimo 

kalba, kuri sëkmingai vartojama tiek sisteminei, tiek 

taikomajai árangai kurti. Pirmà kartà C kalbà apraðë B. W. Karnighan 

ir D. M. Ritchie 1978 m. iðleistoje knygoje „C programavimo 

kalba”. C kalbos variantas su klasëmis pavadintas 

C++ kalba. Ði kalba – kaip instrumentas programuotojams 

– praktikams. Be pastarosios yra ir kitø programavimo 

kalbø, pvz., Paskalio, t. y. grieþto programavimo kalba, Beisiko, 

kurios sintaksë artima anglø kalbai. Ið esmës C++ yra 

nauja programavimo kalba, pritaikyta sudëtingoms programø 

sistemoms ir instrumentinëms programavimo priemonëms 

kûrti, panaudojant objektinio programavimo technologijà. Ði 

kalba yra glaudþiai susijusi su klasikine C kalba. 

C – ðiuolaikinë, efektinga programavimo kalba. 

Jos dëka geriausiai iðnaudojamos kompiuterio galimybës. 

C kalba paraðytos programos yra kompaktiðkos ir greitai vykdomos. 

C – mobilioji programavimo kalba. Tai reiðkia, jei programa 

paraðyta ðia kalba, ji gali bûti lengvai, su nedideliais 

pataisymais arba visai be jø perkeliama á kitas skaièiavimo 

sistemas, pvz., ið IBM kompiuterio programos veikimà perkelti 

á UNIX. 

C – galinga ir lanksti programavimo kalba. Didelë dalis 

galingos UNIX ir Windows operacinës sistemos paraðyta C 

kalba. Ja paraðytos programos naudojamos fizikiniams ir techniniams 

uþdaviniams spræsti, taip pat animacijai kurti. 

C – turi galimybæ panaudoti nemaþai valdanèiøjø konstrukcijø, 

kurios paprastai asocijuojasi su asembleriu. Asem- 

7

lerio programavimo kalba labai sudëtinga (þr. 1 pav.). Tai 

skaièiai ir kodai, kuriuos ne specialistui suprasti sunku, kadangi 

ji raðoma procesoriaus kalba (þr. 2 pav.). 

8 

B8 23 01 MOV AX,0123 

05 25 00 ADD AX,0025 

8B D8 MOV BX,AX 

03 D8 ADD BX,AX 

8B CB MOV CX,BX 

2B C8 SUB CX,AX 

2B C0 SUB AX,AX 

90 NOP 

CB RETF 

1 pav. Asembleriu praðyta programa 

B8 23 01 05 25 00 8B D8 03 D8 8B CB 2B C8 2B C0 

90 CB D0 A2 17 04 1F C3 1E 52 2E 8E 34 00 AE 1A 

45 04 B4 41 CD 21 BA 94 04 B4 41 CD 21 5A E8 93 

02 C6 06 44 04 00 1F C3 BA 87 80 E8 DA FF 0E 1F 

E9 AB F8 9C E8 9D FC 50 52 BA 78 81 E8 C9 FF 0E 

1F E8 08 31 5A 58 9D 3D 41 00 75 03 E9 8F F8 E9 

12 BA 8E 1E 3A D0 FE 06 44 04 06 57 1E 56 1E 06 

1F BE 8D 87 26 C6 06 A3 E5 00 E8 EA F0 1F 72 1F 

2 pav. Procesoriaus kalba 

Asembleriu paraðyta programa yra labai didelës apimties, 

nes kompiuteriui reikia detaliai aiðkinti kiekvienà atliekamà 

veiksmà. Asembleris – tai sisteminë programuotojø kalba, kuri 

leidþia panaudoti visas kompiuterio galimybes. Fortranas puikiai 

suskaièiuoja sinusà, taèiau sunkiai pavaizduoja taðkà ekrane. 

C kalba – tai aukðto lygio programavimo kalba, kuri 

kaip ir asembleris leidþia panaudoti visas kompiuterio galimy-

es. Ðiuo metu C kalba yra sisteminë programuotojø kalba. 

Tai struktûrinë kalba, taèiau ji nëra labai grieþta ir per 

daug nevarþo programuotojo. 

PROGRAMAVIMO PROCESAS 

Programos raðymas ir parengimas vykdyti yra gana ilgas 

procesas, kuris schematiðkai yra pavaizduotas 3 pav. Ið pradþiø 

pasinaudojus turimu redaktoriumi, raðomas programos 

tekstas. Èia svarbu neapsirikti renkant programos tekstà ir 

parinkti bylos vardà, kurioje bus programa. Programos teksto 

byla – *.cpp arba *.c (pirmoji – C++ kalba, antroji – C). 

Toliau paraðytà programà kompiliuojame, t. y. mûsø paraðytà 

programà perraðome kompiuterio kalba ir gauname objektinæ 

bylà *.obj. Tai gali bûti tik nedidelë programos dalis. 

Visus programø gabaliukus á vienà *.exe bylà sujungia kita 

programa, vadinama komponuotoju (Linker). Ði programos 

dalis átraukia ir bibliotekos funkcijas. Taèiau gautoji programa 

yra klaidinga, todël jà reikia derinti ir taisyti. Tai atliekama 

derintojo (Debugger) programa. 

Programa 

.for 

.bas 

.pas 

.c 

.cpp 

Redaktorius 

Editor 

.asm 

3 pav. Borland’o kompiliatorius 

Kompiliatorius 

Compiler 

.obj 

.lib 

.obj 

Komponuotojas 

Linker 

.exe 

.com 

Derintojas 

Debugger 

Rezultatas 

9

OPERATORIAI 

10 

„=” 

Ið pradþiø pabandysime pasiaiðkinti visiðkai paprastà programà. 

Pabandykite suprasti, kà daro ði programa? 

#include 

main ( ) /* paprasta programa*/ 

{ 

int num; 

num = 1; 

printf (”Að paprasta”); 

printf (”skaièiavimo maðina. \n”); 

printf (”Mano mëgstamiausias skaièius %d todël, kad 

tai pirmas skaièius. \n”, num); 

return 0; 

} 

Jei manote, kad programa kaþkà parodys ekrane, tai Jûs 

esate visiðkai teisûs. 

Programos rezultatas: 

Að paprasta skaièiavimo maðina. 

Mano mëgstamiausias skaièius 1 todël, kad tai pirmas skaièius. 

Paraðytos programos apþvalga 

#include – á programà átraukiama papildoma 

byla. Ði byla paprastai yra bet kuriame C kompiliatoriaus

pakete. Gali bûti nurodoma ne viena, o kelios reikalingos 

bibliotekos. Programuotojai tai vadina programos antraðte. Ði 

eilutë net nëra C kalbos operatorius. # nurodo, kad programai 

vykdyti reikës C kompiliatoriaus bibliotekos. 

main ( ) – funkcijos vardas. Programa, kuri yra paraðyta 

C kalba, pradedama vykdyti nuo funkcijos main ( ). Todël C 

kalbos visos paprogramës gali turëti ávairius vardus, iðskyrus 

valdanèiàjà. Paprogramë – tai atskira nepriklausoma programos 

dalis, á kurià nukreipta pagrindinë funkcija. Skliausteliai 

po main ( ) nurodo, kad tai ne kintamasis, o funkcija. 

Ðiuose skliaustuose gali bûti nurodoma ðios funkcijos gràþinama 

informacija. Nurodytoje programoje funkcijai nieko neperduodama, 

todël ir ji nieko negràþina. 

/* paprasta programa*/ – komentaras. 

Komentarai – tai pastabos, kurios padeda suprasti programos 

esmæ. Komentarai skirti tik programuotojui, kompiliatorius 

jø nepastebi. Komentarus galima raðyti toje pat eilutëje, 

kurioje nurodomos operacijos. 

{ – funkcijos pradþia. 

int num; – kintamojo tipo apraðymas. Apraðydami kintamuosius 

nurodome jø tipà ir vardà. Ðiuo atveju nurodome, 

kad bus naudojamas kintamasis num, kuris bus sveikas skaièius 

(int). 

Programuojant yra bûtina nurodyti naudojamø kintamøjø 

tipà. Programa pradedama raðyti nuo kintamøjø apraðymo, 

kurie bus naudojami programoje, nurodant jø tipà. Kintamaisiais 

gali bûti ne tik sveikieji skaièiai, bet ir simboliai bei 

slankaus kablelio skaièiai. Kabliataðkiu baigiamas raðyti bet 

11

koks operatorius C kalboje. Kintamøjø tipai gali bûti ávairûs: 

char, int, float, double ir t. t. 

Pasirenkant kintamøjø vardus taip pat laikomasi tam tikrø 

taisykliø: kintamojo pavadinimas gali bûti nuo vieno iki septyniø 

daugiau simboliø. Kintamojo vardo pirmasis simbolis 

bûtinai turi bûti raidë, o toliau – skaièiai, didþiosios ir maþosios 

raidës ir „_” simbolis, kuris suprantamas kaip raidë. 

12 

Teisingi vardai Klaidingi vardai 

Wiggly $Z^** 

cat1 1cat 

Hot_Tub Hot-Tub 

_kcaB don’t 

num = 1; – priskyrimo operatorius. „=” kintamajam num 

priskiria vienetà. Apibrëþus kintamojo tipà, kompiuterio atmintyje 

kintamajam buvo iðskirta atminties vieta, o su priskyrimo 

operatoriumi mes tà vietà uþpildëme. Ðis operatorius 

irgi baigiamas kabliataðkiu. 

printf (”Að paprasta”); – iðvedimo ekrane operatorius. 

Ðis operatorius ekrane paraðo frazæ: Að paprasta. 

printf ( ) – iðvedimo ekrane funkcija. Kad tai yra funkcija, 

parodo skliaustai. Simboliø eilutë, esanti skliaustuose, perduodama 

funkcijai printf ( ). Ði funkcija perþiûri visus simbolius 

tarp kabuèiø ir juos paraðo. Tarp kabuèiø raðomi simboliai 

– tai funkcijai perduodami argumentai. 

\n – kompiliatoriui nurodo á kitos eilutës pradþià. Tai 

simbolis, kuris atitinka ávedimo klaviðo paspaudimà. Simbolis 

\t – þymi tabuliacijos klaviðo paspaudimà ir pan. 

%d – nurodo, kur ir kokiu formatu paþymëti kintamojo

num vertæ. % – nurodo, kad ðioje vietoje turi bûti spausdinamas 

skaièius, o d – nurodo, kad þymimas sveikasis skaièius 

turi bûti deðimtainëje sistemoje. 

} – pagrindinës main ( ) funkcijos pabaiga. 

PAPRASTOS PROGRAMOS STRUKTÛRA 

Susipaþinsime su pagrindinëmis C kalbos programos raðymo 

taisyklëmis. Paprastai programà gali sudaryti viena ar kelios 

funkcijos, ið kuriø viena bûtinai turi vadintis main ( ). Funkcijà 

pradedame apraðyti nuo antraðtës, toliau apraðoma funkcija. 

Funkcijos struktûros paprasta schema pateikta 4 pav. 

Antraštė 

#include 

main( ) 

int num; 

num = 1; 

Funkcijos 

aprašymas 

printf("%d tai 

skaičius.\n", num); 

4 pav. C kalbos funkcijos struktûra 

Pagalbinės bibliotekos 

Funkcijos vardas ir 

argumentai 

Kintamojo aprašymas 

Priskyrimo operatorius 

Funkcijos iškvietimo 

operatorius 

13

Programuojant nereikëtø visko raðyti á vienà eilutæ. Kompiliatorius 

paraðytoje programoje á tuðèias eilutes nereaguoja. 

Todël galima detaliai atskirti kiekvienà funkcijos dalá. 

14 

Pateiksime ðiek tiek sudëtingesnæ programà: 

#include 

main ( ) /* skaièiø daugyba*/ 

{ 

int a, b; 

a = 6; 

b = 2 * a; 

printf (”%d padauginus ið dviejø gausime %d. \n”, a, b); 

return 0; 

} 

Ðios programos rezultatas: 6 padauginæ ið dviejø gausime 

12. Kaip matome, jei ekrane reikia iðvesti kelis kintamuosius, 

tai po kabuèiø ið eilës nurodomi kintamieji, kuriø reikðmes 

ekrane norime iðvesti. 

Uþduotys 

1. Paraðykite programà, kuri ekrane iðvestø Jûsø vardà ir 

pavardæ. 

2. Paraðykite programà, kuri ekrane iðvestø Jûsø amþiø, 

kai nurodyti Jûsø gimimo metai.

DUOMENØ IR KINTAMØJØ TIPAI 

Duomenø ir kintamøjø tipai bei jø raktiniø þodþiø paaiðkinimas 

yra pateiktas 1 lentelëje. 

1 lentelë 

Duomenø tipai ir jø raktaþodþiai 

Raktiniai žodžiai: int, long, short, unsigned, 

char, float, double. 

int – jei kintamasis sveikasis skaičius su 

ženklu. 

long arba long int – dideli sveikieji skaičiai 

short arba short int – nedideli sveikieji 

skaičiai 

unsigned int, unsigned long, insigned short – 

gali būti nulis arba teigiamas sveikasis skaičius 

char – simbolinis kintamasis 

float – teigiamas ir neigiamas slankaus 

kablelio skaičius. 

double arba long float – dvigubo tikslumo 

arba ilgas dvigubas skaičius 

Skaičiai nuo –32768 iki 32767 

–2147483648 iki 2147483647 

–32768 iki 32767 

skaičiai nuo 3,4 . 10 -38 

iki 3,4 . 10 38 

1,7 . 10 -308 iki 1,7 . 10 308 

Þmogui skirtumas tarp sveikojo skaièiaus ir slankaus 

kablelio skaièiaus – tai tik skirtingas uþraðymo bûdas, o 

kompiuteriui – ðiø skaièiø uþraðymas á kompiuterio atmintá. 

Sveikøjø skaièiø pavyzdþiai: 2, –23, 2456. Tuo tarpu 3,14 

arba 2/3 jau nëra sveikieji skaièiai. 

Pagrindiniai ðiø skaièiø skirtumai: 

1. Sveikieji skaièiai neturi trupmeninës dalies, o slankaus 

kablelio skaièiai gali bûti sveiki arba trupmeniniai. 

2. Veiksmai su trupmeniniais skaièiais atliekami ilgiau. 

Norint, kad ekrane bûtø paraðytas sveikasis skaièius, reikia 

raðyti %d, simbolá – %c, slankaus kablelio skaièiø – %f. 

15

Uþduotys 

Studentas paraðë programà, kurioje gausu klaidø. Suraskite 

jas. 

16 

#include 

main ( ) 

( 

float g; h; 

float tax, rate; 

) 

g = e21; 

tax = rate * g; 

SIMBOLINËS EILUTËS, FUNKCIJOS PRINTF ( ) IR 

SCANF ( ) 

Ðiame skyriuje pabandysime iðsiaiðkinti, kaip reikia apibrëþti 

simbolines konstantas ir kaip dirbti su simbolinëmis 

eilutëmis. Ið pradþiø pateiksime programos pavyzdá ir pabandysime 

suprasti, kà ji daro: 

/* dialogas*/ 

#define DENSITY 1200 /*þmogaus kûno tankis*/ 

#include 

#include 

#include 

main ( ) 

{ 

float weight, volume;

int size, letters; 

char name[40]; 

clrscr (); 

printf (”Labas! Koks Jûsø vardas? \n”); 

scanf (”%s”, name); 

printf (”%s, kokia Jûsø masë?\n”, name); 

scanf (”%f”, &weight); 

size = sizeof (name); 

letters = strlen (name); 

volume = weight/DENSITY; 

printf (”Nuostabu, %s, Jûsø tûris %2.2f kubiniai metrai.\n”, 

name, volume); 

printf (”Be to, Jûsø vardas sudarytas ið %d raidþiø. \n”, 

letters); 

printf (”Ir jis kompiuterio atmintyje uþima %d baitø.\n”, 

size); 

getch ( ); 

} 

return 0; 

Programos veikimo rezultatas: 

Labas! Koks Jûsø vardas? 

Viktorija 

Viktorija, koks Jûsø svoris? 

64 

Nuostabu, Viktorija, Jûsø tûris 0,053 kubiniai metrai 

Be to, Jûsø vardas sudarytas ið 9 raidþiø, 

Ir jis kompiuterio atmintyje uþima 40 baitø. 

Perþiûrësime, kas gi nauja atsirado ðioje programoje: 

17

1. Èia buvo apibrëþtas masyvas, kuriame saugomas vartotojo 

ávestas vardas. 

2. Vedant ir iðvedant simbolinæ eilutæ buvo naudota iðvedimo 

specifikacija %s. 

3. Buvo apibrëþta konstanta DENSITY. 

4. Ávesta ávesties funkcija scanf ( ), kuri nuskaito vedamus 

duomenis. 

5. Ávestos eilutës ilgiui nustatyti naudota funkcija strlen ( ). 

6. Masyvo dydþiui nustatyti panaudota nauja funkcija sizeof 

( ). 

scanf ( ) ir printf ( ) funkcijø viduje ávesta ir norima iðvesti 

informacija raðoma kabutëse, kurios nurodo eilutës pradþià 

ir pabaigà. Simbolinei eilutei ávesi panaudotas masyvas – tai 

kompiuterio atmintyje iðskirta vieta, kurioje ðalia patalpinama 

tarpusavyje logiðkai susijusi vienodo tipo informacija (þr. 

5 pav.). 

V I K T O R I J A \0 

5 pav. Eilutës iðdëstymas masyve. Kiekvienas masyvo elementas uþima 1 baità. \0 – C 

kalboje þymi eilutës pabaigà 

Pateiktame pavyzdyje yra apibrëþtas 40 elementø masyvas, 

kiekviename masyvo elemente galima patalpinti vienà 

simbolá. Lauþtiniai skliaustai rodo, kad name kintamasis yra 

masyvas, kuris turi 40 elementø, o char nurodo, kad elementø 

tipas yra simbolinis: 

18 

char name[40]; 

Simbolis %s nurodo funkcijai printf ( ) þymëti simbolinæ 

eilutæ. Funkcija scanf ( ) skaito simbolius ið klaviatûros, kol

sutinka tarpo, tabuliacijos klaviðo ir ávedimo klaviðo simbolá. 

Duomenims ávesti arba nuskaityti C kalboje yra ir daugiau 

funkcijø, pvz.: gets ( ), getchar ( ). 

Raðant programas, daþnai tenka susidurti su konstantomis, 

kuriø nuolat prireikia skaièiuojant. Todël konstantos yra 

apibrëþiamos pradþioje #define, paskui nurodomas konstantos 

vardas, o po tarpo nurodoma konstantos reikðmë. Jei tai simbolinë 

konstanta, tai jos reikðmë nurodoma kabutëse: 

#define DENSITY 1200 – skaitinë konstanta; 

#define PHRAISE ”Ðtai ir að” – simbolinë eilutë – konstanta. 

Kiekvienoje programos vietoje, kur sutinkamos nurodytos 

konstantos, á jø vietà ið karto áraðomos konstantø reikðmës. 

Funkcijos scanf ( ) ir printf ( ) – ávedimo ir iðvedimo 

funkcijos. Norint, kad ðios funkcijos iðvestø arba ávestø kintamàjá, 

reikia nurodyti kintamøjø formatà. Toliau pateikti iðvedimo 

/ ávedimo formatai ir iðvedamos / ávedamos informacijos 

tipas: 

Formatas Iðvedamos / ávedamos informacijos tipas 

%d deðimtainis sveikasis skaièius; 

%c vienas simbolis; 

%s simboliø eilutë; 

%e slankaus kablelio skaièius, iðvedimas eksponentiniu 

formatu; 

%f slankaus kablelio skaièius, deðimtaininis iðvedimas; 

%g naudojama vietoj f ir e, jeigu jis yra trumpesnis; 

%u deðimtainis sveikasis skaièius be þenklo; 

19

20 

%o aðtuntainës sistemos skaièius be þenklo; 

%x ðeðioliktainës sistemos skaièius be þenklo. 

Galima tarp % ir simbolio nurodyti skaièius: 

%4d – spausdinamam skaièiui skirti 4 simboliai, pildoma 

ið deðinës á kairæ 

_ _ _ 5; 

%4.5f – skaièius po taðko nurodo iðvedimo tikslumà, t. y. 

kiek skaièiø po kablelio iðvesti ekrane; 

%ld – atitinka long duomenø tipà; 

%-10d – iðvedimui skirta 10 simboliø, spausdinama ið kairës 

á deðinæ. 

Áraðant duomenis klaviatûra, kaip matëme scanf ( ) funkcijoje, 

nurodant kintamàjá, kuriam bus priskirta nuskaityta 

reikðmë, naudojamas simbolis &. Ðis simbolis reiðkia nuorodà 

á kintamàjá, arba kintamojo adresà. Jei kintamasis apibrëþtas 

*p, tai kintamojo adresas bus p; jei kintamasis apibrëþtas p, 

tai kintamojo adresas bus &p. 

Uþduotys 

1. Paraðykite programà, kuri paklaustø Jûsø vardo, pavardës, 

gimimo metø. Po to iðvestø Jûsø amþiø, suskaièiuotø 

raides ir pasakytø, kiek vietos kompiuterio atmintyje uþima 

Jûsø duomenys. 

2. Suraskite klaidas: 

define B oi-oi 

define X 10 

main ( ) 

{

int age; 

char name; 

printf (”Koks Tavo vardas?”); 

scanf (”%s”, name); 

printf (”nuostabu, %c, kiek jums metø?\n”, name); 

scanf (”%f”, age); 

xp = age + X; 

printf (”%s! Jums tikriausiai %d ?\n”, B, xp); 

} 

VEIKSMAI, REIÐKINIAI IR OPERATORIAI 

Ðiame skyrelyje aptarsime duomenø apdorojimo operacijas: 

sudëtá, atimtá, daugybà ir dalybà; suþinosime apie ciklà. 

Ciklas – tai eilë veiksmø, kurie nuolatos yra kartojami. Vienas 

ið ciklo operatoriø – while. Panagrinëkime programos 

pavyzdá: 

/*batø dydis*/ 

#define OFFSET 7,64 

#define SCALE 0,325 

main ( ) 

{ 

/* perskaièiuoja batø dydá á pëdos dydá coliais*/ 

float shoe, foot; 

printf (”Batø dydis Pëdos dydis\n”); 

shoe = 3,0; 

while (shoe < 18,5) 

{ 

21

22 

foot = SCALE*shoe + OFFSET; 

printf (”%13.2f %16.2f coliai\n”, shoe, foot); 

shoe = shoe + 1,0; 

} 

printf(”Jei Jums ði avalynë tinka, neðiokite jà. \n”); 

return 0; 

} 


Batø dydis Pëdos dydis 

3,01 8,61 coliai 

4,0 8,94 coliai 

.. .. 

17,0 13,16 coliai 

18,0 13,49 coliai 

Jei Jums ði avalynë tinka, neðiokite jà. 

while ciklo darbas: sàlyga, kuri turi bûti tenkinama, nurodoma 

skliaustuose. Kol sàlyga shoe < 18,5 bus tenkinama, tol 

ciklas bus vykdomas. Pradinis rezultatas – shoe = 3,0. Apskaièiuotas 

pëdos dydis paraðomas, o shoe kintamojo reikðmë 

padidinama vienetu: shoe = shoe +1,0;. Ciklo pradþià ir 

pabaigà þymi riestiniai skliaustai {}. Tarp jø esantys operatoriai 

kartojami tol, kol ciklo sàlygos yra tenkinamos. Kai sàlyga 

netenkinama, tada iðeinama ið ciklo ir vykdoma kita komanda 

printf ( ). Ðià programà galima pakeisti, jei vietoj 

SCALE reikðmës paraðysime 1,8, o vietoj OFFSET – 32,0, 

Tuomet gausime programà, kuri temperatûrà þymi ne pagal 

Celcijaus, o pagal Farenheito skalæ.

PAGRINDINIAI VEIKSMAI 

Pagrindinës operacijos yra skirtos aritmetiniams veiksmams 

atlikti. 

1. Priskyrimo veiksmas: „=”. 

C kalboje ðis þenklas nereiðkia lygybës. Jis paþymi kintamajam 

priskirtà reikðmæ, pvz., 

Bmw = 2003; 

Toks uþraðas reiðkia, kad kintamajam Bmw priskirta reikðmë 

2003, t. y. kintamojo vardas – Bmw, kintamojo reikðmë 

– 2003. 

Paþiûrëkime á pavyzdá: 

i = i + 1; 

Matematiniu poþiûriu tai bûtø neteisinga, o C kalboje tai 

reiðkia, kad reikia paimti kintamàjá vardu i ir jo vertæ padidinti 

vienetu. Trumpai tai galima uþraðyti: i++, t. y. pats 

kaip ir i = i + 1. 

2. „+” – tai sumavimo veiksmas. 

Sudedami du dydþiai, esantys operatoriaus kairëje ir deðinëje 

pusëje. Pvz., printf (”%d”, 4 + 20); 

Ekrane bus iðvesta 24. 

Sumuojami dydþiai gali bûti ir kintamieji, ir konstantos. 

3. „–” – tai atimties veiksmas. 

Atima kintamøjø arba konstantø reikðmes: ið kairëje þenklo 

pusëje stovinèio kintamojo reikðmës atimama deðinëje 

þenklo pusëje stovinèio kintamojo reikðmë. 

23

24 

4. „–” – tai þenklo pakeitimo veiksmas. 

Pakeièia kintamojo þenklà prieðingu. 

5. „* ” – tai daugybos veiksmas. 

Padaugina kintamuosius ar konstantas. Specialaus operatoriaus 

laipsniui kelti C kalboje nëra. 

6. „ / ” – tai dalybos operatorius. 

Operatoriaus kairëje pusëje esanèio kintamojo reikðmë yra 

dalijama ið kintamojo reikðmës, esanèios operatoriaus deðinëje 

pusëje. 

Toliau pateiktos programos pavyzdys parodo, kaip atliekama 

dalybos operacija ir kuo skiriasi sveikøjø skaièiø dalyba 

nuo slankaus kablelio skaièiø dalybos: 

/*dalybos pavyzdþiai*/ 

... 

main ( ) 

{ 

printf (”sveikøjø skaièiø dalyba: 5/4 tai %d \n”, 5/4); 

printf (”sveikøjø skaièiø dalyba: 6/3 tai %d \n”, 6/3); 

printf (”slankiuoju kableliu: 7,0/4,0 tai %2.2f \n”, 7,0/4,0); 

return 0; 

} 


sveikøjø skaièiø dalyba: 5/4 tai 1

sveikøjø skaièiø dalyba: 6/3 tai 2 

slankaus kablelio skaièiø dalyba: 7,0/4,0 tai 1,75 

7. „%” – tai liekanos operatorius. 

Jei turime uþraðà 13%5, tai rezultatas bus 3: 13, kurá galima 

uþraðyti 2*5 + 3, liekana yra 3. Tai ir yra operatoriaus 

veikimo rezultatas. 

8. „++” ir „– –” – tai didinimo ir maþinimo operatoriai. 

„++” – padidina kintamojo vertæ 1, o „– –” sumaþina 

vertæ 1. Ðiems operatoriams vykdyti yra galimi keli variantai. 

Tai priklauso nuo to, kur ðie operatoriai raðomi: prieð funkcijà 

ar po jos. Veikimo rezultatas tas pats, tik reikðmës pakeitimo 

laikas skirtingas. 

Paanalizuokime toliau pateiktà programà: 

/* sumavimas*/ 

main ( ) /*operatoriaus raðymas ið kairës ir ið deðinës*/ 

{ 

int a = 1, b = 1; 

int aplus, plusb; 

aplus = a++; 

plusb = ++b; 

printf (”a aplus b plusb”); 

printf (”%3d %5d %5d %5d \n”, a, aplius, b, pliusb); 

return 0; 

} 


A aplus b plusb 

2 1 2 2 

25

Abiejø kintamøjø reikðmës padidëjo vienetu, taèiau kintamajam 

aplus a reikðmë buvo priskirta prieð padidinimà: kintamajam 

priskirta sena reikðmë a ir tik po to a reikðmë padidinama; 

o plusb – po padidinimo: kintamojo reikðmë padidinama, 

o tik po to ta reikðmë priskiriama naujam kintamajam. 

Analogiðkai veiksmai atliekami ir su maþinimo operatoriumi: 

„– –”. 2 lentelëje pateikiamos C kalbos operacijos ir jø 

atlikimo tvarka. 

2 lentelë 

Aritmetiniai veiksmai ir jø atlikimo tvarka 

Aritmetiniai veiksmai 

+ Prie kairėje pusėje stovinčio kintamojo 

pridedama dešinėje stovinčio kintamojo 

reikšmė. 

– Iš kairėje stovinčio kintamojo atimama 

dešinėje stovinčio kintamojo reikšmė. 

– Pakeičia dešinėje šio ženklo pusėje 

stovinčio kintamojo ženklą. 

* Padaugina kintamuosius. 

/ Kairėje pusėje esantį kintamąjį padalija iš 

dešinėje pusėje esančio kintamojo. 

% Išveda skaičiaus liekaną, kai dalijama šio 

operatoriaus kairėje stovinčio kintamojo 

reikšmė iš šio operatoriaus dešinėje pusėje 

esančio kintamojo reikšmės. 

++ Kintamojo vertę padidina vienetu. 

– – Kintamojo vertę sumažina vienetu. 

Veiksmai (išdėstyti atlikimo tvarka) Kaip vykdoma operacija 

() {} -> . Iš kairės į dešinę 

! ~ ++ – – – * & sizeof( ) Iš dešinės į kairę 

* / % Iš kairės į dešinę 

+ – Iš kairės į dešinę 

> Iš kairės į dešinę 

< < = > > = Iš kairės į dešinę 

= = ! = Iš kairės į dešinę 

& Iš kairės į dešinę 

^ Iš kairės į dešinę 

| Iš kairės į dešinę 

&& Iš kairės į dešinę 

|| Iš kairės į dešinę 

?: Iš kairės į dešinę 

= + = – = * = / * % = Iš dešinės į kairę 

, Iš kairės į dešinę 

26

Dabar pabandysime pasiaiðkinti anksèiau neminëtas operacijas. 

+ = – prideda deðinëje esantá kintamàjá prie kairëje 

esanèio kintamojo: a + = 2, tai atitinka a = a + 2. 

Analogiðkai atliekami ir tokie veiksmai: – =, * =. 

< = – maþiau arba lygu; 

= = – lygu; 

! = – nelygu; 

&& – loginis veiksmas reiðkiantis ir; 

|| – loginis veiksmas reiðkiantis arba; 

! – loginis veiksmas ne. 

Uþduotys 

1. Paraðykite programà, kuri pavaizduotø skaièiaus x nuo 

1 iki 10 vertæ, jo kvadratà, kubà ir 1/x: 

x x 2 x 3 1/x 

1 1 1 1 

2 4 8 0,50 

3 9 27 0,33 

.. .. .. .. 

10 100 1000 0,10 

2. ASCII kodø lentelë. Tai standartinë kompiuteryje naudojamø 

simboliø lentelë. Operatorius printf (”%4d %c”, 97, 

97) iðspausdina ekrane tokius simbolius: 97 a. Mat, pirmasis 

97 skaièius spausdinamas kaip sveikasis, o antrasis – kaip 

simbolis, paþymëtas numeriu 97. Iðspausdinkite visus 256 simbolius. 

3. Paraðykite programà, kuri paþymëtø skaièius nuo 1 iki 

16 deðimtainëje, aðtuntainëje, ðeðioliktainëje sistemose. 

4. Paraðykite programà, kuri papraðytø, kokio skaièiaus 

kvadratø sumà norite suþinoti. Pvz., 4 – 1*1 + 2*2 + 3*3 + 

4*4 = 30. Ekrane bus iðvesta 30. 

27

LOGINËS OPERACIJOS 

28 

Raktaþodþiai: if, else, switch, break, case, default 

Operacijos: 

> > =

Ðis operatorius kompiuteriui nurodo didinti kintamojo lin vertæ 

vienetu, jei klaviatûros simbolis yra nauja eilutë „\n”. Jei klaviatûros 

simbolis neatitinka naujos eilutës simbolio, tai toliau, vykdant 

operatoriø while, imamas kitas simbolis. Operatorius getchar 

( ) yra skirtas vienam simboliui ávesti ið klaviatûros. Vienam 

simboliui iðvesti naudojamas operatorius putchar ( ). 

EOF – tai „-1”. Paprastai automatiðkai tokiu simboliu yra 

pabaigiama byla. 

Ðiame pavyzdyje operatoriui if priklauso tik vienas veiksmas 

lin++, todël ðis veiksmas baigiamas kabliataðkiu. Jei 

operatoriui priklausytø daugiau veiksmø, juos reiktø atskirti 

skliaustais {}. Galima patobulinti programà, kad ji skaièiuotø 

simbolius ir eilutes: 

#include 

void main ( ) 

{ 

int ch; 

int lin = 0, sim = 0; 

while ((ch = getchar ( )) ! = EOF) 

{ 

sim++; 

if (ch = = ‘\n’) 

lin++; 

} 

printf (”suskaièiavau %d eilutes ir %d simbolius \n”, 

lin, sim); 

} 

Operatoriaus if galimybes galima iðplësti panaudojus operatoriø 

else. Naudojant konstrukcijà if else, tikrinama ope- 

29

atoriaus if sàlyga ir, jei ji netenkinama, tuomet vykdomi 

else operatoriaus veiksmai: 

Jei nebûtø operatoriaus else, tai ið karto bûtø spausdinama. 

Po operatoriaus else galima vël kartoti operatoriø if. Tokiu 

bûdu galima patikrinti didesná sàlygø skaièiø. 

SÀLYGINËS OPERACIJOS 

Kai kurias C kalbos sàlygines komandas jau naudojome 

anksèiau, dabar susipaþinkime su visomis galimomis ðios kalbos 

sàlyginëmis operacijomis: 

30 

if 

n = 2*n; 

(n > 10) printf("%d \ n",n); 

else 

Tiesa 

n = 10*n; 

Operacija Reikðmë 

< maþiau 

< = maþiau arba lygu 

= = lygu 

> = daugiau arba lygu 

> daugiau 

! = nelygu 

Sàlyginës komandos naudojamos su if ir while operatoriais. 

Atkreipiame dëmesá – jokiu bûdu lyginimui negalima 

naudoti operatoriaus =, nes tai yra priskyrimo operatorius. 

Deja, sàlyginiø komandø negalima naudoti eilutëms lyginti.

Jei dirbama su trupmeniniais skaièiais, patartina naudoti tik 

< ir > lyginimo komandas. 

LOGINËS OPERACIJOS 

Daþnai tenka panaudoti ne tik sàlygines operacijas, bet ir 

logines. Pavyzdþiui, mums reikia suskaièiuoti, kiek byloje yra 

tuðèiø simboliø, t. y. tarpo simboliø, naujos eilutës ir tabuliacijos 

klaviðo. 

/*simboliø skaièius*/ 

#include 

main ( ) 

{ 

int sim; 

int t = 0; 

} 

while ((sim = getchar( ))! = EOF) 

if (sim = =’ ‘ || sim = = ”\n” || sim = = ”\t”) 

t++; 

printf (”Ið viso yra %d tuðèiø simboliø”, t); 

return 0; 

Taigi || yra loginë komanda „arba”. C kalboje yra trys 

loginës komandos: 

Operacija Reikðmë 

&& ir 

|| arba 

! ne 

Paþiûrëkime, kaip jos vykdomos. Tarkime, turime du sàly- 

31

ginius operatorius a ir b: 

1. a&& b sàlyga bus teisinga ir vykdoma, kada bus teisingos 

a ir b sàlygos. 

2. a||b teisinga, jei yra teisinga a arba b sàlyga, arba teisingos 

abi sàlygos. 

3. !a teisinga, jei a sàlyga yra neteisinga. 

Paimkime keletà konkreèiø pavyzdþiø: 

5 > 2 && 4 > 7 – neteisinga, nes viena sàlyga nëra patenkinta. 

5 > 2 || 4 > 7 – teisinga, nes viena sàlyga yra patenkinta. 

!(4 > 7) – teisinga, nes 4 ne didesnis uþ 7. 

SÀLYGINË OPERACIJA: ?: 

Ði operacija – tai trumpas if – else operatoriaus uþraðymas. 

Pateiksime operatoriaus iðraiðkà absoliutinei skaièiaus 

reikðmei rasti: 

32 

x = (y < 0)? – y : y; 

Tai atitiktø uþraðymà: 

if (y < 0) 

x = –y; 

else 

x = y; 

OPERATORIUS SWITCH 

Jei reikia pasirinkti vienà galimà variantà ið eilës duomenø, 

tuomet nepatogu naudoti if–else konstrukcijà. Tada pra-

vartu naudotis operatoriumi switch. Pateiksime pavyzdá programos, 

kuri nuskaito raidæ ir nurodo ið tos raidës prasidedanèio 

gyvûno pavadinimà. 

/*gyvûnas*/ 

void main ( ) 

{ 

char ch; 

printf (”Áveskite bet kokià raidæ, o að iðvesiu gyvûno pavadinimà 

ið Jûsø nurodytos raidës. \n”); 

printf (”Jei norite darbà nutraukti, áveskite # simbolá.\n”); 

while ((ch = getchar ( ))!=”#”) 

{ 

if ( ch!=” ”) /*nelygu tarpo simboliui*/ 

switch (ch) 

{ 

case ”a”: printf (”avis, naminis gyvûnas.\n”); 

break; 

case ”b”: printf (” barsukas, laukinis gyvûnas.\n”); 

break; 

… 

default: printf (”tokio gyvûno neþinau.\n”); 

break; 

} 

else 

printf (”Jûs ávedëte tarpo klaviðà. Áveskite raidæ 

arba, norëdami baigti darbà, simbolá #”); 

} 

} 

33

Tikriausiai aiðku, kad paraðytoji programa nuskaito ið klaviatûros 

ávestà simbolá. Patikrina, ar tai ne tarpo simbolis arba 

pabaigos simbolis „#”. Jei sàlygos tenkinamos, tuomet 

ieðko switch operatoriuje nurodytos raidës ir veiksmø, kà 

toliau daryti su duomenimis. default – bus naudojama visiems 

anksèiau nenurodytiems atvejams; break skirtas iðeiti 

ið switch operatoriaus. 

Uþduotys 

1. Paraðykite programà, kuri tikrintø, ar ið klaviatûros ávestas 

skaièius yra teigiamas, ar neigiamas. Neigiamas skaièius 

turi bûti paverstas teigiamu ir iðvestas ekrane, tai praneðant, 

o teigiamas – tik praneðant, kad tai teigiamas skaièius. 

2. Paraðykite programà, kuri skaièiuotø nurodyto skaièiaus 

faktorialà. 

3. Paraðykite programà, kuri pateiktø meniu. Meniu bûtø 

galima pasirinkti: ar iðvesti nurodyto skaièiaus kubà, ar kvadratinæ 

ðakná, ar faktorialà. 

CIKLAI IR KITI PROGRAMOS VALDYMO BÛDAI 

34 

Raktaþodþiai: while, do, for, break, continue, goto 

Operacijos: 

+= – = * = / = % = 

Priminsime, kad ciklo while bendriausia uþraðymo forma 

yra: 

while (sàlyga) 

Operatorius (veiksmai, kurie bus atliekami)

Ðiame cikle turime nurodyti, kaip turi keistis á sàlygà 

áeinantis kintamasis. Kitaip ciklas bus begalinis, ir ið jo niekada 

neiðeisime. 

Ciklas for – jame ið karto nurodomos ciklo pradinës ir 

galinës sàlygos, ciklo atlikimo þingsnis. 

…. 

for (a = 1; a < = 10; a++) 

printf (” man puikiai sekasi!”); 

…. 

Ðios programos fragmento vykdymas: ekrane deðimt kartø 

pasirodys frazë „man puikiai sekasi!”. 

Pateikiame su ðiuo ciklo operatoriumi paraðytà programà, 

kuri skaièiuoja skaièiø kubus nuo 1 iki 6. 

/*kubai*/ 

#include 

#include 

void main ( ) 

{ 

int a; 

} 

for (a = 1; a < = 6; a++) 

printf (”%5d %5d \n”, a, a*a*a); 

Jei á ciklà áeina ne vienas, o keletas sakiniø, tuomet jie turi 

bûti atskirti skliaustais {}. To nereikia, jei ciklui priklauso tik 

vienas sakinys. 

35

for ciklo pranaðumai: 

1. Sàlygos ir þingsniai uþraðomi ið karto. 

2. Þingsná galima ne tik didinti (a++), bet ir maþinti 

(a– –). 

3. Ciklo þingsná galima keisti bet kokiu nurodytu dydþiu: 

a + = 13 (a = a + 13). 

4. Galima naudotis ne tik skaièiais, bet ir simboliais. Naudojantis 

simboliais, jie nurodomi tarp kabuèiø: 

36 

... 

for (a = ”a”; a

… 

a = 2; 

for (n = 3;a < = 25;) 

a = a*n; 

… 

Tai bus vykdoma, kol a bus maþiau arba lygu 25. 

8. Galima nurodyti ne vienà, o kelias pradines sàlygas. Jos 

tarpusavyje turi bûti atskirtos kableliu. 

… 

for(a = 2, b = 0; b < 100; a* = 2) 

b + = a; 

… 

Kiti valdantieji operatoriai 

break, continue, goto 

Operatorius break naudojamas daugiausiai ið visø trijø operatoriø. 

Já jau sutikome while cikle, kuris baigiamas tik ðio 

operatoriaus dëka. Operatorius break tikrai netinka naudoti 

su if operatoriumi. Taèiau jei atsitinka taip, kad operatoriø 

break reikia naudoti, tuomet bûtina perþiûrëti paraðytos programos 

algoritmà, kad ðio operatoriaus nereikëtø. 

Operatorius continue gali bûti naudojamas visuose cikluose, 

iðskyrus switch. Jis skirtas perðokti kai kurias ciklo 

iteracijas. Ðie operatoriai geriausiai praverèia, kai reikia sutrumpinti 

if–else sàlygos veikimà. 

Operatorius goto yra prastas. Jis C kalboje nenaudojamas. 

Ðio operatoriaus naudojimas – prasto programavimo 

poþymis. 

37

MASYVAI 

Jau anksèiau minëjome, kas yra masyvas ir kaip já reikia 

apibrëþti. Dar kartà prie jo gráðime, kadangi programavimo 

procese jis yra svarbus. Pvz., 

38 

float a[20]; 

Kintamojo apraðymas reiðkia, kad turime masyvà a, kurá 

sudaro dvideðimt elementø. Pirmas masyvo elementas yra 

a[0], antras – a[1] ir t. t. Paskutinis masyvo elementas – 

a[19]. Kadangi masyvo tipas yra float, tai kiekvienas masyvo 

elementas irgi bus float tipo. Masyvai gali bûti bet kokio 

anksèiau nurodyto tipo. Masyvo uþpildymas ir jo elementø 

skaitymas atliekamas ciklu. Svarbu neuþmirðti, kad masyvo 

pirmas elementas yra a[0]. 

… 

for (i = 0; i < = 19; i++) /*masyvo uþpildymas*/ 

scanf (”%lf”, &a[i]); 

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

printf (”%f”, a[i]); /*masyvo elementø iðspausdinimas*/ 

… 

Masyvø elementus galima lyginti, atlikti aritmetinius veiksmus: 

… 

if (a[i] > b) 

b = a[i]; 

…

Jei masyvo i-tasis elementas didesnis uþ b, tuomet b kintamajam 

reikia priskirti i-tàjá masyvo elementà. 

Svarbu: masyvui uþpildyti nurodomas adresas: &a[i]. 

Masyvo dydá galima apibrëþti pasinaudojus konstantomis: 

… 

#define MAX 45 

main ( ) 

{ 

int a[MAX]; 

… 

} 

Uþduotys 

1. Paraðykite programà, kuri iðvestø daugybos lentelæ. 

2. Paraðykite programà, kuri leistø vartotojui uþpildyti masyvà 

ið 6 elementø. Uþpildyto masyvo elementus iðdëstykite 

didëjanèia tvarka ir iðveskite ekrane. 

3. Paraðykite programà, kuri sudëtø dviejø masyvø elementus 

(masyvai sudaryti ið 10 elementø; sudëtis turi bûti: 

pirmo masyvo pradþia sudedama su antro masyvo pabaiga) 

ir rezultatà suraðytø á treèià masyvà, o padalintus masyvo 

elementus sudëtø á ketvirtà masyvà. Ekrane turi bûti pavaizduoti 

pradiniai masyvai, jø sumos ir dalybos masyvai. 

KAIP TEISINGAI NAUDOTIS FUNKCIJOMIS? 

Raktaþodis: return 

Programuojant C kalba naudojamës funkcijomis. Anksèiau 

jau buvo pasinaudota printf ( ), scanf ( ), getch ( ), putchar 

(), strlen ( ) funkcijomis. Ðios funkcijos yra sisteminës, bet 

39

mes esame sukûræ ir savø funkcijø, pvz., main ( ). Programa 

visada prasideda komandomis (jos yra main ( ) funkcijoje), 

kuriomis galima kreiptis ir á kitas funkcijas. Dabar 

iðsiaiðkinkime, kaip patiems sukurti funkcijas, á kurias galëtø 

bûti nukreipta main ( ) funkcija ir kitos sukurtos funkcijos. 

Funkcija – tai savarankiðka programos dalis, skirta 

konkreèiam veiksmui atlikti. Pvz., funkcija printf ( ) iðveda 

informacijà ekrane. Naudojant funkcijas, nereikia dar kartà 

programuoti besikartojanèiø veiksmø. Jei programoje koká 

nors veiksmà reikia kartoti keletà kartø, tà veiksmà uþtenka 

apraðyti funkcija ir, reikalui esant, á jà kreiptis. Be to, ðià 

funkcijà galima naudoti ne tik vienoje programoje, bet ir 

kitose. 

Tarkime, norime paraðyti programà, kuri ávestø skaièiø 

rinkiná, já suskirstytø ir rastø vidutinæ reikðmæ. Minëtà 

programà galima uþraðyti taip: 

40 

... 

main ( ) 

{ 

float list[50]; 

} 

readlist (list); 

sort (list); 

average (list); 

return 0; 

Aiðku, kad pagrindinë funkcija nukreipta á funkcijas 

readlist ( ), sort ( ) ir average ( ), kurios atlieka veiksmus, o 

pagrindinei funkcijai pateikia rezultatà. Naudojant pagalbines 

funkcijas, pagrindiná dëmesá galima skirti programos struktûrai

negaiðtant laiko jø detalëms. 

Apie funkcijas reikia þinoti, kaip jos turi bûti apraðomos, 

kaip á jas kreiptis ir kaip nurodyti ryðá tarp programos ir 

paraðytos funkcijos. 

PAPRASTOS FUNKCIJOS KÛRIMAS IR JOS 

PANAUDOJIMAS 

Paraðysime programà, kuri spausdintø firminá blankà ir 

sukursime naujà funkcijà, kuri brëþtø 65 simbolius „*”. 

/*firminio blanko virðus*/ 

#define Name ”Vilniaus pedagoginis universitetas” 

#define Address ”Studentø 39” 

#define Vieta ”Vilnius” 

#include 

void starbar ( ); 

void main ( ) 

{ 

starbar ( ); 

printf (”%s\n”, Name); 

printf (”%s\n”, Address); 

printf (”%s\n”, Vieta); 

starbar ( ); 

} 

/*funkcija starbar ( )*/ 

#include 

# define Riba 65 

41

42 

void starbar ( ) 

{ 

int count; 

for (count = 1; count < = Riba; count ++) 

putchar (”*”); 

putchar (”\n”); 

} 


******************************************* 

Vilniaus pedagoginis universitetas 

Studentø 39 

Vilnius 

******************************************* 

Á funkcijà starbar ( ) mes kreipëmës ið funkcijos main ( ), 

nurodydami tik reikalingos funkcijos vardà. Kaip veikia programa: 

pirma, ji ið karto kreipiasi á starbar ( ) funkcijà, kuri 

paþymi simbolius, toliau main ( ) funkcija kreipiasi á sistemines 

funkcijas, kurios atspausdina tekstà ir galiausiai – vël á 

starbar ( ), kuri spausdina simbolius. Kuriant pagalbinæ funkcijà, 

ji raðoma pagal tokias paèias taisykles kaip ir main ( ) 

funkcija. Èia abi funkcijos buvo uþraðytos á vienà bylà *.cpp. 

Paprastai geriau raðyti atskiras funkcijas á atskiras bylas, kurias 

bûtø galima panaudoti kitose programose. 

Mûsø paraðytoji programa nieko neturi gràþinti funkcijai main 

( ), todël priekyje buvo nurodomas jos tipas void. Jei programa 

turëtø gràþinti reikðmæ, reiktø nurodyti, kokio tipo reikðmæ funkcija 

gràþins, taip pat gràþinamo argumento reikðmæ: int starbar 

(int a); tai reikðtø, kad funkcija starbar ( ) gràþins sveikà skaièiø 

ir apdorojimui gaus taip pat sveikà skaièiø a. Tuomet sukurtos 

funkcijos viduje reikia pasinaudoti operatoriumi return, kuris 

sukurtai funkcijai nurodo, kà ji turi gràþinti.

Pasiaiðkinsime toliau pateiktà programà: 

/*absoliutinës reikðmës*/ 

#include 

int abs (int x); 

void main ( ) 

{ 

int a = 10, b = 0, c = –22; 

int d, e, f; 

d = abs(a); 

e = abs(b); 

f = abs(c); 

printf (”%d %d %d\n”, d, e, f); 

} 

int abs (int x) 

{ 

int y; 

} 

y = (x < 0)? – x : x; 

return y; 


10 0 22 

Pagrindinë funkcija kreipiasi á kità funkcijà, kuri skaièiuoja 

skaièiaus modulá. Suskaièiavusi modulá return komanda 

pateikia rezultatà pagrindinei funkcijai, kuri pastaràjá pavaizduoja 

ekrane. 

43

GLOBALIEJI (IÐORINIAI) IR LOKALIEJI 

(VIETINIAI) KINTAMIEJI 

Kintamuosius mes apraðëme funkcijos viduje, todël tai buvo 

tos funkcijos lokalieji (vidiniai) kintamieji, kurie nebuvo 

þinomi kitoms funkcijoms. Todël vienai funkcijai perduoti kintamojo 

vertæ buvo naudojama komanda return. 

C kalboje daþnai tenka naudoti globaliuosius kintamuosius, 

kuriuos naudos keletas funkcijø. Jei kintamasis yra apibrëþtas 

ir vienoje, ir kitoje funkcijoje tuo paèiu vardu, já kompiliatorius 

vis tiek supranta kaip atskirà kintamàjá. Panagrinëkime 

programà, kuri sukeièia kintamøjø reikðmes: 

44 

/*kintamøjø sukeitimas*/ 

#include 

#include 

int interchange (int *u, int *v); 

void main ( ) 

{ 

int x = 5, y = 10; 

printf (”esamos x = %d ir y = %d reikðmës\n”, x, y); 

interchange (&x, &y); 

printf (”sukeistos x = %d ir y = %d reikðmës \n”, x, y); 

} 

int interchange (int *u, int *v) 

{ 

int a; 

a = *u; 

*u = *v; 

*v = a;

} 

return *u, *v; 

Ðioje programoje funkcija main ( ) siunèia ne kintamàjá, o 

kintamojo adresà &x, &y. Tuo tarpu funkcijos interchange 

() kintamieji apibrëþiami kaip rodyklës *u, *v. Rodyklë – tai 

kintamojo, esanèio nurodytu adresu, reikðmë, t. y. a = *u. 

Tai reiðkia kintamajam a priskirti x vertæ, nes ði funkcija 

gavo ne reikðmæ, bet adresà. Tokiu bûdu, naudojant lokaliuosius 

kintamuosius, vienai funkcijai galima perduoti kitos 

reikðmes. 

Globalieji kintamieji apibrëþiami prieð funkcijà main ( ) 

naudojant extern komandà (extern – nurodo, kad tai bus 

iðorinis, visoms funkcijoms bendras kintamasis). 

Uþduotys 

1. Perraðykite meniu programà pasinaudodami savo sukurtomis 

funkcijomis skaièiaus kubui, kvadratinei ðakniai, faktorialui 

skaièiuoti. 

2. Paraðykite funkcijà, kuri, gavusi kintamøjø x ir y reikðmes, 

jas pakeièia jø suma ir skirtumu bei jas iðspausdina. 

3. Paraðykite atskiras funkcijas, kurias naudoja pagrindinë 

funkcija skaièiø sumai, sandaugai ir faktorialui skaièiuoti. 

REKURSINËS FUNKCIJOS 

Rekursinë funkcija – tai funkcija, kuri kreipiasi pati á 

save. Pasiaiðkinkime, kaip paraðyti funkcijà faktorialui skaièiuoti. 

Faktorialà galima apskaièiuoti dviem bûdais: 

n! = 1·2···(n-1)·n 

45

46 

arba 

n! = n·(n-1)!, 0!= 1. 

Antrasis faktorialo uþraðymo bûdas – faktorialo lygtis. Pagal 

pirmàjá apibrëþimà faktorialo skaièiavimo programà Jûs 

jau raðëte. Dabar pateiksime faktorialo skaièiavimo funkcijà 

pagal antàjá apibrëþimà: 

… 

int fact (int n) 

{ 

if (n = 0) return 1; 

else return n*fact (n–1); 

} 

… 

Kaip matome, funkcija uþraðoma trumpiau ir nëra jokio 

ciklo. Ði funkcija kreipsis pati á save tol, kol nebus lygu nuliui. 

Rekursinës funkcijos naudingos, kai reikia programuoti 

veiksmus su neþinomu operacijø skaièiumi. 

Uþduotis 

1. Paraðykite programà, kuri ekrane uþraðo deðimt pirmøjø 

Fibonaèi skaièiø. Fibonaèi skaièiai tenkina tokià diskretinæ 

lygtá: 

f n = f n–1 + f n–2 , f 0 = 0, f 1 = 1. Ðiai lygèiai reikia paraðyti 

rekursinæ funkcijà. 

MASYVAI IR RODYKLËS 

Jau þinome, kas yra masyvai ir kaip apibrëþti statiná (apibrëþto 

dydþio) masyvà. Apibrëþto masyvo elementams gali-

ma ið karto priskirti reikðmes: 

#include 

#include 

int days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 

31}; 

void main ( ) 

{ 

int i; 

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

printf (” %d mënuo turi %d dienø. \n”, i+1, days[i]); 

} 

Ðiuo atveju masyvas apibrëþtas kaip iðorinis, todël paèioje 

funkcijoje jo apibrëþti nereikia. Galima ir nenurodyti masyvo 

elementø skaièiaus. Tuomet pats kompiliatorius suskaièiuos 

lauþtiniuose skliaustuose pateiktas reikðmes: 

int days [] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; 

void main ( ) 

{ 

int i; 

for (i = 0; i < sizeof (days) / sizeof (int); i++) 

printf (” %d mënuo turi %d dienø. \n”, i + 1, 

days [i]); 

} 

Ðiuo atveju pats kompiliatorius apibrëþë masyvo dydá. Cikle 

for norint nurodyti masyvo dydá mes funkcijos sizeof ( ) pa- 

47

galba masyvo dydá apskaièiuojame baitais. Kadangi masyvo 

elementai yra sveiko tipo kintamieji, kurie uþima du baitus 

kompiuterio atmintyje, tai norint gauti masyvo skaièiø, padalijame 

jo uþimamà vietà ið 2 ir gauname masyvo elementø 

skaièiø. 

Siunèiant masyvà funkcijai, elgiamasi taip pat kaip ir su 

kintamaisiais – naudojant rodykles ir adresus. 

Iki ðiol buvo naudotas tik vienmatis masyvas. Daþnai prireikia 

dvimaèiø arba trimaèiø masyvø. Pvz., 

float rain [5][12]; 

Èia apibrëþtas penkiø elementø masyvas, kurio kiekvienà 

elementà sudaro 12 elementø. Tokio tipo masyvà galima pavaizduoti 

taip: 

5 

48 

rain [0][0] rain [0][1] 

12 

rain [0][2] 

rain [1][0] rain [1][1] 

rain [1][2] 

rain [2][0] 

rain [0][3] 

Keièiant masyvo elementus, elgiamasi taip pat, kaip ir dirbant 

su vienmaèiu masyvu. Reikia pabrëþti, kad C kalbos 

masyvai yra labai paprasti, todël galima manyti, kad jø ið viso 

nëra. 

Jei masyvo dydis bus apskaièiuotas tik veikiant programai, 

tai masyvà reikia apibrëþti kaip rodyklæ:

.... 

float *J0; 

.... 

J0 = (float *) malloc (zz * sizeof (float)); 

.... 

Anksèiau pateiktame pavyzdyje masyvas ið pradþiø apibrëþtas 

kaip rodyklë, veikiant programai apskaièiuota, kiek 

reikës masyvo elementø zz. Tuomet funkcija malloc ( ) yra 

sukuriamas reikiamo dydþio masyvas. Primename, kad zz yra 

masyvo elementø skaièius, o sizeof (float) nurodo float tipo 

kintamøjø uþimamà vietà kompiuterio atmintyje baitais. 

ÁVESTIES IR IÐVESTIES BYLOS C KALBOJE 

Teks raðyti programas, kurioms duomenys bus imami ið 

bylos, o skaièiavimo rezultatai taip pat bus iðvesti byloje. Ið 

pradþiø pasiaiðkinsime paprastas bylos skaitymo funkcijas fopen 

( ), fclose ( ), getc ( ), putc ( ). 

Panagrinëkime programà, kuri skaito bylos test turiná ir já 

iðveda ekrane. 

#include 

void main ( ) 

{ 

FILE *in; /* apraðo nuorodà á bylà*/ 

int ch; 

if ((in = fopen (”test”,”r”))! = NULL) 

/*atidaro bylà skaitymui ir tikrina ar yra tokia byla*/ 

{ 

49

50 

while ((ch= getc(in))!=EOF) 

putc (ch, stdout); 

/* iðveda bylà ekrane*/ 

fclose (in); /*uþdaro bylà*/ 

} 

else 

printf (”bylos atidaryti negalëjau”); 

} 

Bylos atidarymas: fopen ( ) 

Funkcijai fopen ( ) reikia perduoti tris duomenis: 1) bylos 

pavadinimà; 2) nurodyti, kaip naudosime bylà: 

”r”: bylà skaitysime 

”w”: á bylà áraðysime duomenis 

”a”: papildysime bylà 

3) rodyklë á bylà: 

FILE *in; 

in = fopen (”test”, ”r”); 

Dabar in yra rodyklë á bylà „test”. 

Jei fopen ( ) negali atidaryti bylos, ji gràþina vertæ 

„NULL”. 

Bylos uþdarymas: fclose ( ) 

Pateiktame pavyzdyje tai yra 

fclose (in); 

Atkreipiame dëmesá, kad jos argumentas yra rodyklë in, 

o ne byla test. Ði funkcija, jei bylà pavyko uþdaryti sëkmingai, 

gràþina 0, jei ne – „–1”. 

Bylos duomenø ávedimas ir iðvedimas: getc ( ) ir putc ( )

Ðios funkcijos veikia analogiðkai kaip ir funkcijos getchar 

( ) ir putchar ( ). Skirtumas tik tas, kad reikia praneðti, kokià 

bylà reikia naudoti. Todël getchar ( ): 

ch = getchar ( ); 

reikia pakeisti: 

ch = getc (in); 

Analogiðkai putc ( ): 

putc (ch, out); 

skirta simbolio ch uþraðymui byloje, á kurià siunèia FILE 

tipo rodyklë out. 

Mûsø atveju buvo naudota stdout – tai rodyklë standartiniam 

iðvedimui. 

Bylos ávedimas – iðvedimas: fprintf ( ), fscanf ( ), fgets 

( ), fputs ( ) 

Kintamojo ir informacijos iðvedimo skirtumas yra tik tas, 

kad iðvedant informacijà byloje reikia naudoti rodyklæ, kurios 

tipas yra FILE. Pvz: 

.... 

FILE *out; 

... 

out = fopen (”rez.dat”, ”w”)); 

.... 

fprintf (out, ”\n j1= %f v2= %d ”, J11, v111); 

.... 

Funkcijos fprintf ( ) ir fscanf ( ). 

Ðios funkcijos panaðios á funkcijas printf ( ) ir scanf ( ), tik 

joms reikalingas papildomas argumentas, rodantis siuntimà á 

bylà. Tai nurodoma paèioje pradþioje. Pvz.: 

51

52 

#include 

void main ( ) 

{ 

FILE *fi; /* apraðo nuorodà á bylà*/ 

int age; 

if ((fi = fopen (”test”,”r”))!=NULL) 

{ 

/*atidaro bylà skaitymui ir tikrina, ar yra tokia byla*/ 

fscanf (fi, ”%d”, &age); /*fi rodo á test*/ 

fclose (fi); 

fi = fopen (”data”,”a”); /*papildymas*/ 

fprintf (fi, ”test is %d.\n”, age); /* fi nurodo data*/ 

fclose (fi); 

} 

} 

Panaði yra ir funkcija fgets ( ), kuri nuo funkcijos gets () 

skiriasi papildomu kintamuoju: 

/* bylà nuskaito eilutëmis*/ 

#include 

#define MAXLIN 80 

main ( ) 

{ 

FILE *f1; 

char *string [MAXLIN]; 

} 

f1 = fopen (”story”,”r”); 

while (fgets (string, MAXLIN, f1) !=NULL) 

puts (string);

Pirmas fgets ( ) funkcijos argumentas yra skaitomos eilutës 

padëtis. Èia ávedama ið bylos perskaityta informacija (ji 

bus áraðoma á simboliná masyvà). 

Antrasis argumentas – nurodo skaitomos eilutës ilgá. Treèiasis 

argumentas nurodo bylà, ið kurios skaitoma informacija. 

Skirtumas tarp gets ( ) ir fgets ( ) – gets ( ) keièia naujos 

eilutës simbolá á „\0”, o fgets ( ) iðlaiko ðá simbolá. Abi funkcijos 

bylos pabaigoje EOF gràþina reikðmæ „NULL”. 

Funkcija fputs ( ) atlieka panaðius veiksmus kaip ir funkcija 

puts ( ): 

fputs (”Tu teisus”, fileptr); 

perduoda eilutæ „Tu teisus” á bylà, kurià parodo nuoroda 

fileptr. 

SIMBOLINIØ EILUÈIØ PAKEITIMAS 

Daþnai perskaitytà simbolinæ eilutæ reikia pakeisti á atitinkamà 

skaitinæ vertæ. Tam yra naudojamos funkcijos atoi ( ) ir 

atof ( ). Pirmoji funkcija eilutæ paverèia sveikuoju skaièiumi, 

antroji – slankiojo kablelio skaièiumi. Ðiø funkcijø argumentas 

yra simbolinio tipo. Atvirkðtinës paskirties funkcijos: itoa 

() – sveiko tipo skaièiø paverèia eilute, ftoa ( ) – double 

tipo skaièiø paverèia eilute. 

Uþduotys 

1. Paraðykite programà gautoms knygoms inventorizuoti. 

Ávedami duomenys turi bûti áraðomi á atskirà bylà. 

2. Paraðykite programà, kuri nuskaitytø bylos duomenis. 

Ið pradþiø turi bûti sukurta byla, kurioje bûtø nurodyti kokie 

nors skaièiai, o nuskaièiusi bylos turiná pavaizduotø ekrane, 

53

patikrintø, ar nëra nuliø, o jei jie yra, juos iðtrintø, naujus 

skaièius áraðytø á naujà bylà. 

LITERATÛRA 

1. Blanskis J. ir kt. C++ praktikumas. – Kaunas : KTU, 

2001. 

2. Lipeikienë J. Programavimas C++ kalba. – Vilnius : 

VPU l-kla, 2002. 

3. Matulis A. C, C++ ir OOP. http://www.itpa.lt/baryon/ 

CPP/LCpp.pdf 

4. Vidþiûnas A. C++ duomenø tipai ir struktûros. – 

Kaunas : Smaltija, 2000. 

5. Vidþiûnas A. C++ ir C++ Builder pradmenys. – 

Kaunas : Smaltija, 2002. 

6. Óýéò Ì., Ïðàòà Ñ., Ìàðòèí Ä., ßçûê Ñè. – Ìîñêâà : 

Ìèð, 1988. 

PRIEDAS 

54 

C kalbos raktaþodþiai 

Programos vykdymo raktaþodþiai: 

Ciklai: 

for while do 

Pasirinkimas ir sàlygos: 

if else switch case default 

Perëjimas: 

break continue goto 

Duomenø tipai: 

char int short long unsigned float double struct union

typedef 

Atminties klasës: 

auto extern register static 

Uþraðymo forma: 

while (sàlyga) 

operatorius; 

Programos vykdymo valdymas 

Operatorius while 

Operatorius kartojamas tol, kol sàlyga teisinga. 

Pavyzdþiai: 

while (n++ < 100) 

printf (”%d %d\n”, n, 2*n+1); 

while (fargo < 1000) 

{ 

fargo = fargo + step; 

step = 2*step; 

} 

Operatorius for 


for (priskyrimas; sàlyga; þingsnis) 

operatorius; 

Operatorius vykdomas tol, kol tenkinama sàlyga. 

Pavyzdþiai: 

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

printf (”%d %d\n”, n, n*2+1); 

55

56 


do 

operatorius 

while (sàlyga); 

Operatorius do while 

Operatorius vykdomas, kol tenkinama sàlyga. 

Pavyzdþiai: 

do 

scanf (”%d”, &num) 

while (num! = 20); 


1 bûdas 

if (sàlyga) 

operatorius 

Operatoriai if ir else 

Operatorius vykdomas, jei tenkinama sàlyga. 

2 bûdas 

if (sàlyga) 

operatorius 1 

else 

operatorius 2 

Jei sàlyga teisinga, vykdomas operatorius 1, jei klaidinga

– operatorius 2. 

3 bûdas 

if (sàlyga 1) 

operatorius 1 

else if (sàlyga 2) 

operatorius 2 

else 

operatorius 3 

Jei sàlyga 1 teisinga, tai vykdomas operatorius 1. Jei sàlyga 

1 klaidinga, o sàlyga 2 teisinga, vykdomas operatorius 2. 

Jei abi sàlygos klaidingos, vykdomas operatorius 3. 

Pavyzdþiai: 

if (a= = 4) 

printf (”tai arklys”); 

else if (a > 4) 

printf (”tai ne arklys”); 

else 

{ 

a++; 

printf (”klaida”); 

} 

Operatorius switch 


switch (iðraiðka) 

{ 

case 1 poþymis: operatorius 1 

case 2 poþymis: operatorius 2 

57

58 

} 

default : operatorius 3 

default nëra bûtinas. 

Pavyzdþiai: 

switch (raidë) 

{ 

case ”a”: printf (”as”); 

case ”b”: ... 

case ”c”:printf (”taip”); 

default: printf (”nesiseka”); 

} 

Jei paimtas simbolis nëra nei a, nei b, nei c – tai vykdomas 

default operatorius.

Aušra Kynienė 

C kalbų ABC 

Redagavo Reda Asakavičiūtė 

Maketavo D. Petrauskas 

SL 605. Tir. 150 egz. 3,75 sp. l. Uþsak. Nr. 04-091 

Iðleido Vilniaus pedagoginis universitetas, Studentø g. 39, LT–08106, Vilnius 

Maketavo ir spausdino VPU leidykla, T. Ðevèenkos g. 31, LT–03111, Vilnius 

Kaina sutartinë 

60

C KALBŲ ABC - VPU biblioteka - Vilniaus pedagoginis universitetas

Transform your PDFs into Flipbooks and boost your revenue!

Delete template?

Save as template ?