A.

Kynien













, C++ kalb ABC








Metodin priemon










Vilnius
2004
TURINYS



C KALBOS PRIVALUMAI .........................................................................................................................4
PROGRAMAVIMO PROCESAS................................................................................................................5
OPERACIJOS ...............................................................................................................................................6
PAPRASTOS PROGRAMOS STRUKTRA............................................................................................8
DUOMEN IR KINTAMJ TIPAI .........................................................................................................9
SIMBOLINS EILUTS, FUNKCIJOS PRINTF( ) IR SCANF( ) ........................................................10
OPERACIJOS, IRAIKOS IR OPERATORIAI...................................................................................13
PAGRINDINS OPERACIJOS ................................................................................................................14
LOGINS OPERACIJOS..........................................................................................................................18
OPERATORIUS IF.....................................................................................................................................18
SLYGINS OPERACIJOS .....................................................................................................................20
LOGINS OPERACIJOS..........................................................................................................................20
SLYGIN OPERACIJA: ?: ....................................................................................................................21
OPERATORIAI SWITCH IR BREAK.....................................................................................................22
CIKLAI IR KITI PROGRAMOS VALDYMO BDAI ..........................................................................23
MASYVAI....................................................................................................................................................25
KAIP TEISINGAI NAUDOTIS FUNKCIJOMIS....................................................................................26
PAPRASTOS FUNKCIJOS KRIMAS IR JOS PANAUDOJIMAS ....................................................27
GLOBALIEJI (IORINIAI) IR LOKALIEJI (VIETINIAI) KINTAMIEJI.........................................29
REKURSINS FUNKCIJOS.....................................................................................................................30
MASYVAI IR RODYKLS .......................................................................................................................31
VESTIES IR IVESTIES BYLOS C KALBOJE...................................................................................33
SIMBOLINI EILUI PAKEITIMAS..................................................................................................36
LITERATRA ............................................................................................................................................36
PRIEDAS .....................................................................................................................................................36
2
Pratarm




, C++ kalbos ABC metodinio leidinio paskirtis supaindinti su C kalbos
programavimo pagrindais. Ji skirta visiems, kurie nori imokti programuoti iuolaikine
programuotoj kalba.
Programavime, kaip ir bet kuriame moksle, patirtis gyjama dirbant, todl ioje
metodinje priemonje pateikiama daug savarankik uduoi. i metodin priemon
iek tiek praplsta pradiamoksliui: pateikiamos ir sudtingesns temos, kuri gali
prireikti kuriant sudtingesnes programas. ia visikai negalbama apie grafikos krimo
elementus.
Leidinyje gausu pateikt program pavyzdi, taiau dalis program yra nepilnos
ir norint, kad ios programos veikt, paiam skaitytojui reiks jas papildyti. Gale
pateiktame priede sudta C kalboje naudojam funkcij santrauka.
Manau, is leidinys pads studentui perprasti C kalb ir paiam pramokti rayti
programas ia kalba.
3
C programavimo kalba, tai galinga programavimo kalba, vis labiau naudojama visame
pasaulyje. Dabar i kalba tai pagrindin profesional programavimo kalba, kuri
skmingai vartojama tiek sistemins, tiek taikomosios rangos krimui. Pirm kart C
kalb apra jos autoriai B.W.Karnighan ir D.M.Ritchie 1978 metais ileistoje knygoje
C programavimo kalba. C kalbos variantas su klasmis pavadintas C++ kalba. i kalba
buvo kaip instrumentas programuotojams praktikams. Be ios kalbos, yra ir kit
programavimo kalb: Paskalis grietas programavimas, Beisikas jo sintaks artima
angl kalbai. I esms C++ yra nauja programavimo kalba, pritaikyta sudting program
sistem ir instrumentini programavimo priemoni krimui, panaudojant objektinio
programavimo technologij. Taiau ioje kalboje isaugotas glaudus ryys ir su klasikine
C kalba.
C kalbos privalumai

C iuolaikin programavimo kalba.
C efektinga programavimo kalba. Ji leidia geriausiai inaudoti kompiuterinius
resursus. C kalba paraytos programos yra kompaktikos ir greitai vykdomos.
C mobilioji programavimo kalba. Tai reikia, jei programa parayta ia kalba, ji gali
bti lengvai, su nedideliais pataisymais arba visai be j, perkeliama kitas skaiiavimo
sistemas, pvz.: i IBM kompiuterio perkelti programos veikim UNIX.
C galinga ir lanksti programavimo kalba. Didel dalis galingos UNIX ir Windows
operacins sistemos parayta C kalba. C kalba paraytos programos naudojamos
fizikiniams ir techniniams udaviniams sprsti, taip pat naudojamos ir animacijai kurti.
C turi galimyb panaudoti eil valdanij konstrukcij, kurios paprastai asocijuojasi
su asembleriu. Asemblerio programavimo kalba labai sudtinga (1pav.), tai skaiiai ir
kodai, kuriuos suprasti ne specialistui sunku, kadangi ji raoma procesoriaus kalba (2
pav.).

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 prayta 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
4
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 parayta programa yra labai didels apimties, nes kompiuteriui reikia aikinti
kiekvien norim atlikti veiksm detaliai. inoma, programuojant asembleriu galima
pasinaudoti visais kompiuterio resursais. Asembleris tai sistemini programuotoj
kalba, kuri pilnai leidia panaudoti visus kompiuterio resursus. Fortranas puikiai
suskaiiuoja sinus, taiau sunkiai pavaizduoja tak ekrane. C kalba tai aukto lygio
programavimo kalba, kuri leidia panaudoti visus kompiuterio resursus kaip ir
asembleris. iuo metu C kalba yra sistemini programuotoj kalba.
C patogi kalba. Tai struktrin kalba, taiau ji nra labai grieta ir per daug nevaro
programuotojo.

Programavimo procesas

Programos raymas yra gana ilgas procesas, kuris schematikai yra pavaizduotas 3 pav.
Pirma, pasinaudojus turimu redaktoriumi, raomas programos tekstas. ia svarbu
neapsirikti renkant programos tekst ir parinkti bylos vard, kurioje bus programa.
Programos teksto byla *.cpp arba *.c (pirmasis C++ kalba, antrasis C).
Toliau parayt program kompiliuojame, t.y. ms parayt program
perraome kompiuterio kalba ir gauname objektin (*.obj) byl. Tai gali bti tik
gabaliukas programos.
Galiausiai, visus program gabaliukus sujungia vien *.exe byl kita programa,
vadinama komponuotoju (linker). i programos dalis kartu traukia ir bibliotekines
funkcijas. Taiau gautoji programa yra su klaidomis, todl j reikia derinti ir taisyti. Tai
atliekama derintojo (Debugger) programos pagalba.

















5
Programa
.for
.bas
.pas
.c
.cpp
Derintojas
Debugger
Komponuotojas
Linker
Kompiliatorius
Compiler
Redaktorius
Editor
.exe
.com
.obj
.obj
.lib
.asm
Rezultatas
3 paveikslas. Borlando kompiliatorius
Operacijos

=

Pradioje pabandysime pasiaikinti visikai paprast program. Pabandykite suprasti, k
daro i programa?

#include <stdio.h>

main ( ) /* paprasiausia programa*/
{
int num;

num = 1;
printf ( A paprasta);
printf (skaiiavimo maina. \n);
printf (Mano mgstamiausias skaiius %d, todl, kad tai pirmas skaiius. \n,
num);
return 0;
}

Na jei manote, kad programa kak atspausdins ekrane, tai Js esate visikai teiss.

Programos rezultatas:

A paprasta skaiiavimo maina.
Mano mgstamiausias skaiius 1, todl, kad tai pirmas skaiius.

Paraytos programos apvalga

#include <stdio.h> - program traukiama papildoma byla. i byla paprastai jau yra bet
kuriame C kompiliatoriaus pakete. Programuotojai tai vadina programos antrate. i
eilut net nra C kalbos operatorius. # - nurodo, kad programos vykdymui bus reikalinga
pasinaudoti C kompiliatoriaus biblioteka.

main ( ) funkcijos vardas. Programa, kuri yra parayta C kalboje, pradedama vykdyti
nuo funkcijos main ( ). Todl C kalboje, visos paprograms gali turti vairius vardus,
iskyrus valdanij. Paprogram tai atskira nepriklausoma programos dalis, kuri
kreipiasi pagrindin funkcija. Skliausteliai po main ( ) nurodo, kad tai ne kintamasis, o
funkcija. iuose skliaustuose gali bti nurodoma ios funkcijos grinama informacija.
Kadangi nurodytoje programoje ms funkcija nieko neturi grinti, tai jie yra tuti.


/* paprasiausia programa*/ - komentaras.

6
Komentarai tai pastabos, kurios padeda suprasti programos esm. Komentarai skirti tik
programuotojui, kompiliatorius juos ignoruoja. Komentarus galima rayti toje pat eilutje
kur ir nurodomos operacijos.

{ - funkcijos pradia.

int num; - operatorius kintamojo tipui aprayti arba kitaip, tai paprasiausias raktinis
odis. Nurodome, kad bus naudojamas kintamasis num, kuris bus sveikas skaiius (int).
Programuojant yra btina nurodyti naudojam kintamj tip. Programa rayti
pradedama nuo kintamj, kurie bus naudojami programoje, nurodant j tip.
Kintamaisiais gali bti ne tik sveiki skaiiai, bet ir simboliai bei slankaus kablelio
skaiiai. Kabliatakiu baigiamas rayti bet koks operatorius C kalboje. Kintamj tipai
gali bti vairs.
Pasirenkant kintamj vardus taip pat laikomasi tam tikr taisykli: kintamojo
pavadinimas gali bti nuo vieno simbolio iki septyni. Kintamojo vardo pirmasis
simbolis btinai turi bti raid, o sekantys skaiiai, didiosios ir maosios raids ir _
simbolis, kuris suprantamas kaip raid.

Teisingi vardai Klaidingi vardai
Wiggly $Z^**
cat1 1cat
Hot_Tub Hot-Tub
_kcaB dont



num = 1; - priskyrimo operatorius. = kintamajam num priskiria vienet. Apibrus
kintamojo tip, kompiuterio atmintyje buvo iskirta kintamajam atminties vieta, o su
priskyrimo operatoriumi, mes t viet upildme. is operatorius irgi baigiamas
kabliatakiu.

printf ( A paprasta); - ivedimo ekran operatorius.

io operatoriaus pagalba ekrane atspausdinama fraz: A paprasta.
printf( ) ivedimo ekran funkcija. Kad tai funkcija, rodo skliaustai. Simboli
eilut esanti skliaustuose, perduodama funkcijai printf( ). i funkcija periri visus
simbolius tarp kabui ir juos atspausdina. Tarp kabui raomi simboliai, tai funkcijai
perduodami argumentai.
\n nurodo kompiliatoriui kitos eiluts pradi. Tai simbolis, kuris atitinka vedimo
klavio paspaudim. Simbolis \t atitinka tabuliacijos klavio paspaudim ir pan.

%d nurodo kur ir kokiu formatu atspausdinti kintamojo num vert. % - nurodo, kad
ioje vietoje turi bti spausdinamas skaiius, o d nurodo, kad spausdinamas skaiius turi
bti deimtainje sistemoje.

} pagrindins main( ) funkcijos pabaiga.
7

Paprastos programos struktra

Susipainsime su pagrindinmis taisyklmis raant program C kalba. Paprastai,
program gali sudaryti viena ar keletas funkcij, kuri viena btinai turi vadintis main( ).
Funkcij pradedame aprayti nuo antrats, po to seka paios funkcijos apraymas.
Funkcijos struktros paprasiausia schema pateikta 4 pav.
































4 paveikslas. Funkcijos struktra C kalboje.
int num;

num = 1;

printf(%d tai
skaiius.\n, num);
Funkcijos ikvietimo
operatorius
Priskyrimo operatorius
Kintamojo apraymas
#include<stdio.h>
main( )
Funkcijos
apraymas
Pagalbins bibliotekos
Funkcijos vardas ir
argumentai
Antrat

Programuojant nereikt rayti visko vien eilut. Kompiliatorius, paraytoje
programoje, tuias eilutes ignoruoja. Todl galima detaliai atskirti kiekvien funkcijos
dal.



8

Pateiksime iek tiek sudtingesn program:
#include <stdio.h>

main( ) /* skaii 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 padauginus i dviej gausime 12. Kaip matome, jei ekran
reikia ivesti kelis kintamuosius, tai po kabui nurodomi i eils kintamieji, kuri vertes
norime ivesti ekran.

Uduotys

1. Paraykite program, kuri ivest ekran Js vard ir pavard.
2. Paraykite program, kuri ivest ekran Js ami, kai nurodyti Js gimimo
metai.

Duomen ir kintamj tipai

Duomen ir kintamj tipai ir j raktini odi paaikinimas yra pateiktas 1 lentelje.


1 Lentel. Duomen Tipai ir j raktiniai odiai.
Raktiniai odiai: int, long, short, unsigned,
char, float, double.


int - jei kintamasis bus sveikas skaiius su
enklu.
long arba long int dideli sveiki skaiiai
short arba short int nedideli sveikieji
skaiiai

Skaiiai nuo 32768 iki 32767
unsigned int, unsigned long, insigned short
gali bti nulis arba teigiamas sveikas skaiius


char simbolinis kintamasis
9

float teigiamas ir neigiamas slankaus
kablelio skaiius.

Skaiiai, didesni nei sveikieji
double arba long float dvigubo tikslumo
arba ilgas dvigubas skaiius


mogui skirtumas tarp sveiko skaiiaus ir slankaus kablelio skaiiaus, tai tik skirtingas
uraymo bdas. Kompiuteriui tai i skaii uraymas kompiuterio atmint. Sveik
skaii pavyzdiai: 2, -23, 2456. Tuo tarpu 3,14 arba 2/3 jau nra sveikieji skaiiai.
Pagrindiniai i skaii skirtumai:
1. Sveiki skaiiai neturi trupmenins dalies, tuo tarpu slankaus kablelio skaiiai
gali bti sveiki arba trupmeniniai.
2. Naudojant slankaus kablelio skaiius, galima apimti didesn skaii diapazon.
3. Veiksmai su trupmeniniais skaiiais atliekami ilgiau.

Norint, kad ekrane bt atspausdintas sveikas skaiius, reikia rayti %d, simbolis - %c,
slankaus kablelio skaiius - %f.

Uduotys

Studentas para program, kurioje gausu klaid. Suraskite jas.

#include <stdio.h>

main ( )
(
float g; h;
float tax, rate;

g = e21;
tax = rate * g;
)

Simbolins eiluts, funkcijos printf( ) ir scanf( )

iame skyriuje pabandysime isiaikinti, kaip reikia apibrti simbolines
konstantas ir kaip dirbti su simbolinmis eilutmis. Pradioje pateiksime programos
pavyzd ir pabandysime suprasti, k ji daro:

/* dialogas*/
#define DENSITY 1200 /*mogaus kno tankis*/
#include<stdio.h>
#include<conio.h>
#include<string.h>
10

main ( )
{
float weight, volume;
int size, letters;
char name[40];

clrscr();
printf(Labas! Koks Js vardas? \n);
scanf( %s, name);
printf(%s, kokia Js mas?\n, name);
scanf(%f, &weight);
size = sizeof( name);
letters = strlen(name);
volume = weight/DENSITY;
printf(Nuostabu, %s, Js tris %2.2f kubiniai metrai.\n, name, volume);
printf(Be to, Js vardas sudarytas i %d raidi, \n, letters);
printf(ir jis kompiuterio atmintyje uima %d bait.\n, size);
getch( );

return 0;
}

Programos veikimo rezultatas:

Labas! Koks Js vardas?
Viktorija
Viktorija, kokia Js mas?
64
Nuostabu, Viktorija, Js tris 0.053 kbiniai metrai.
Be to, Js vardas sudarytas i 9 raidi,
Ir jo patalpinimas kompiuterio atmintyje uima 40 bait.

Perirsime, kas gi naujo atsirado ioje programoje:

1. ia buvo apibrtas masyvas, kuriame saugomas vartotojo vestas vardas.
2. Vedant ir ivedant simbolin eilut buvo naudota ivedimo specifikacija %s.
3. Buvo apibrta konstanta DENSITY.
4. vesta vesties funkcija scanf( ), kuri nuskaito vedamus duomenis.
5. vestos eiluts ilgiui nustatyti naudota funkcija strlen( ).
6. Masyvo dydiui nustatyti panaudota nauja funkcija sizeof().

scanf( ) ir printf( ) funkcij viduje vesta ir norima ivesti informacija raoma tarp
kabui, kurios nurodo eiluts pradi ir pabaig. Simbolins eiluts vedimui panaudotas
masyvas tai kompiuterio atmintyje iskirta vieta, kurioje greta vienas kito patalpinama
tarpusavyje logikai susijusi vienodo tipo informacija (5 pav.).
11

V I K T O R I J A \0

5 paveikslas. Eiluts idstymas masyve. Kiekvienas masyvo elementas uima 1 bait. \0
C kalboje ymi eiluts pabaig.

Pateiktame pavyzdyje yra apibrtas 40 element masyvas, kiekviename masyvo
elemente galima patalpinti vien simbol. Lautiniai skliaustai rodo, kad name
kintamasis yra masyvas, kuris turi 40 element, o char nurodo, kad element tipas yra
simbolinis:

char name[40];

Simbolis %s nurodo funkcijai printf( ) spausdinti simbolin eilut. Funkcija scanf( )
skaito simbolius i klaviatros, kol sutinka tarpo, tabuliacijos klavio ir vedimo klavio
simbol. Duomen vedimui arba nuskaitymui C kalboje yra ir daugiau funkcij, pvz.:
gets( ), getchar( ).
Raant programas, danai tenka susidurti su konstantomis, kuri nuolat prireikia
skaiiavimuose. Todl konstantos yra apibriamos pradioje #define, po to nurodomas
konstantos vardas ir po tarpo nurodoma konstantos reikm. Jei tai simbolin konstanta,
tai jos reikm nurodoma kabutse:

#define DENSITY 1200 - skaitin konstanta.

#define PHRAISE tai ir a simbolin konstanta.

Programoje kiekvienoje vietoje, kur bus sutiktos nurodytos konstantos, j viet i karto
bus raytos konstant verts.
Funkcijos scanf( ) ir printf( ) vedimo ir ivedimo funkcijos. Norint, kad ios
funkcijos ivest arba vest kintamj, reikia nurodyt kintamj format. emiau
pateikti ivedimo/vedimo formatai ir ivedamos/vedamos informacijos tipas:

Formatas Ivedamos/vedamos informacijos tipas
%d deimtainis sveikas skaiius
%c vienas simbolis
%s simboli eilut
%e slankaus kablelio skaiius, ivedimas eksponentiniu formatu
%f slankaus kablelio skaiius, deimtaininis ivedimas
%g naudojama vietoj f ir e, jeigu jis yra trumpesnis
%u deimtainis sveikas skaiius be enklo
%o atuntains sistemos skaiius be enklo
%x eioliktains sistemos skaiius be enklo

Galima tarp % ir simbolio nurodyti skaiius:

%4d spausdinamam skaiiui skirti 4 simboliai, pildoma i deins kair
12
_ _ _ 5

%4.5f - skaiius po taku nurodo ivedimo tikslum, t.y. kiek skaii po kableliu ivesti
ekran
%ld atitinka long duomen tip.
%-10d ivedimui skirta 10 simboli, spausdinama bus i kairs dein.
raant duomenis i klaviatros, kaip matme scanf( ) funkcijoje nurodant kintamj,
kuriam bus priskirta nuskaityta vert naudojamas simbolis &. is simbolis reikia rodykl
kintamj arba kitaip, kintamojo adres. Jei kintamasis apibrtas *p, tai rodykl j bus
p; jei kintamasis apibrtas p, tai rodykl j bus &p.

Uduotys

1. Paraykite programa, kuri paklaust Js vardo, pavards, gimimo met. Po to
ivest Js ami, suskaiiuot raides ir pasakyt kiek vietos uima Js
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);
}
Operacijos, iraikos ir operatoriai

ia aptarsime duomen apdorojimo operacijas: sudtis, atimtis, daugyba ir dalyba. Pirm
kart susidursime su ciklu. Ciklas tai eil veiksm, kurie nuolatos yra kartojami. Dabar
pasiaikinsime vien i ciklo operatori: while. Pairkime programos pavyzd:

/*bat dydis*/
#define OFFSET 7.64
#define SCALE 0.325

main ( )
{
13
/* perskaiiuoja bat dyd pdos dyd ciliais*/

float shoe, foot;

printf(Bat dydis pdos dydis\n);
shoe = 3.0;
while (shoe<18.5)
{
foot = SCALE*shoe + OFFSET;
printf(%13.2f %16.2f coliai\n, shoe, foot);
shoe = shoe + 1.0;
}
printf(jei Jums i avalyn tinka, neiokite j. \n);
return 0;
}

Programos veikimo rezultatas:

Bat dydis pdos 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, neiokite j.

while ciklo darbas: slyg, kuri turi bti tenkinama nurodoma skliaustuose. Kol i slyga
shoe<18,5 bus tenkinama, tol ciklas bus vykdomas. Pradinis rezultatas shoe=3.0
tenkinamas, tai tuomet apskaiiuojamas pdos dydis, jis atspausdinamas ir shoe
kintamojo vert padidinama vienetu: shoe = shoe +1.0;. Ciklo pradi ir pabaig ymi
riestiniai skliaustai: {}. Tarp j esantys operatoriai kartojami tol, kol ciklo slygos yra
tenkinamos. Kai slyga netenkinama, tai ieinama i ciklo ir vykdoma sekanti komanda:
printf( ). i program galima pakeisti, jei vietoj SCALE verts paraysime 1.8, o vietoj
OFFSET 32.0, gausime program kuri temperatr i celcijaus skals perveda
farenheitus.

Pagrindins operacijos

Pagrindins operacijos yra skirtos aritmetiniams veiksmams.
1. Priskyrimo operacija: =
C kalboje is enklas nereikia lygu, jis reikia, kad kakokiam kintamajam turi bti
priskirta vert:

Bmw = 2003;

14
Toks uraas reikia, kad kintamajam bmw priskirta vert 2003., t.y. kintamojo
vardas bmw, kintamojo vert 2003.
Pairkime pavyzd:
i=i+1;.
Matematiniu poiriu tai yra visika nesmon, o C kalboje tai reikia, kad reikia
paimti kintmj vardu i ir jo vert padidinti vienetu. Trumpai tai galima urayti: i++
, tai tas pats kaip ir i=i+1.

2. Sumavimo operacija: +

+ - sudedami du dydiai, esantys i kairs ir deins operatoriaus puss. Pvz.:
printf(%d, 4+20);
ekran bus ivesta - 24.
Sumuojami dydiai gali bti ir kintamieji ir konstantos.

3. Atimties operacija: -

Atima kintamj vertes arba konstant vertes: i kairs enklo puss stovinio
kintamojo verts atimama deinje enklo pusje stovinio kintamojo vert.

4. enklo pakeitimo operacija: -

Pakeiia kintamojo enkl prieingu.

5. Daugybos operatorius:*

Sudaugina kintamuosius ar konstantas. Specialaus operatoriaus kvadratui C kalboje
nra.

6. Dalybos operatorius: /

Kairje pusje esanio kintamojo vert prie operatori yra dalinama i kintamojo
verts, esanios u operatoriaus deinje pusje.

emiau pateiktos programos pavyzdys pademonstruos kaip atliekama dalybos
operacija ir kuo skiriasi sveik skaii dalyba nuo dalybos su slankaus kablelio
skaiiumi.

/*dalybos pavyzdiai*/
...

main( )
{
printf(sveik skaii dalyba: 5/4 tai %d \n, 5/4);
printf(sveik skaii dalyba: 6/3 tai %d \n, 6/3);
printf(slankiuoju kableliu: 7.0/4.0 tai %2.2f \n, 7.0/4.0);
15
return 0;
}

Programos veikimo rezultatas:

sveik skaii dalyba: 5/4 tai 1
sveik skaii dalyba: 6/3 tai 2
slankiuoju kableliu: 7.0/4.0 tai 1.75

7. Dalybos pagal modul operatorius: %

Jei turime ura 13 % 5 tai rezultatas bus 3: 13 galima urayti 2*5 +3, ir liekana yra 3,
kuris ir yra operatoriaus veikimo rezultatas.

8. Didinimo ir mainimo operatoriai: ++ ir - -

++ - padidina kintamojo vert 1, o - - sumaina vert 1. i operatori vykdymo yra
galimi keli variantai. Tai priklauso nuo to, kur ie operatoriai raomi: prie funkcij
ar po jos. Veikimo rezultatas tas pats, tik verts pakeitimo laikas skirtingas.
Paanalizuokime emiau pateikt program:

/* sumavimas*/

main( ) /*operatoriaus raymas i kairs ir i deins*/
{
int a=1, b=1;
int aplus, plusb;

aplus=a++; /*
plusb=++b;
printf(a aplus b plusb);
printf(%3d %5d %5d %5d \n);
return 0;
}
Programos veikimo rezultatas:
A aplus b plusb
2 1 2 2
Abiej kintamj verts padidjo vienetu, taiau kintamajam aplus a vert buvo
priskirta prie padidinim: kintamajam priskirta sena vert a ir tik po to a vert
padidinama; o plusb po padidinimo: kintamojo vert padidinama, o tik po to ta vert
priskiriama naujam kintamajam.
Analogikai veiksmai atliekami ir su mainimo operatoriumi: --. emiau pateiktoje
lentelje pateikiamos C kalbos operacijos ir j atlikimo tvarka.

2 Lentel. Aritmetiniai veiksmai ir j atlikimo vyresnikumas.

16
Aritmetiniai veiksmai
+ Prie kairje pusje stovinio kintamojo
pridedama deinje stovinio kintamojo
vert
- I kairje stovinio kintamojo atimama
deinje stovinio kintamojo vert
- Pakeiia deinje pusje io enklo
stovinio kintamojo enkl
* Sudaugina kintamuosius
/ Kairje pusje esant kintamj padalina i
deinje pusje esanio kintamojo
% Iveda liekan skaiiaus, kai dalinama
kairje io operatoriaus stovinio
kintamojo vert i deinje io operatoriaus
pusje esanio kintamojo verts
++ Kintamojo vert padidina vienetu
-- Kintamojo vert sumaina vienetu
Veiksmai (idstyti veiksm atlikimo
tvarka)
Kaip vykdoma operacija
() {} -> . I kairs dein
! ~ ++ -- - * & sizeof( ) I deins kair
* / % I kairs dein
+ - I kairs dein
<< >> I kairs dein
< <= > >= I kairs dein
= = != I kairs dein
& I kairs dein
^ I kairs dein
| I kairs dein
&& I kairs dein
|| I kairs dein
?: I kairs dein
= += -= *= / * %= I deins kair
, I kairs dein

Dabar pabandysime pasiaikinti nemintas anksiau operacijas.
+= - prideda deinje esant kintamj prie kairje esanio kintamojo: a+=2, tai atitinka
a=a+2.
Analogikai atliekami ir sekantys veiksmai: -=, *=.

<= - maiau arba lygu.
== - lygu
!= - nelygu
&& - loginis veiksmas reikiantis ir.
|| - loginis veiksmas reikiantis arba.
! loginis veiksmas ne.
17

Uduotys

1. Paraykite program, kuri atspausdint skaiiaus 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) atspausdina ekrane tokius simbolius: 97 a. Mat,
pirmasis 97 skaiius spausdinamas, kaip sveikasis, o antrasis - kaip simbolis, paymtas
numeriu 97. Atspausdinkite visus 256 simbolius.
3. Paraykite program, kuri atspausdint skaiius nuo 1 iki 16 deimtainje,
atuntainje, eioliktainje sistemose.
4. Paraykite program, kuri paprayt kokio skaiiaus norite suinoti kvadrat sum.
Pvz.:4 1*1+2*2+3*3+4*4=30. ekran bus ivesta 30.

Logins operacijos

Raktiniai odiai

if , else, switch, break, case, default

Operacijos

> >= <= < == != && || / :?

Operatorius if

Pasiaikinsime paprasiausi program:

/*eilui skaiiavimas*/

#include <stdio.h>


void main( )
{
int ch;
int lin=0;
18

while((ch = getchar( )) !=EOF)
if (ch = = \n)
lin++;

printf(suskaiiavau %d eilutes\n, lin);
}

Pagrindin darb ioje programoje atlieka operatorius:

if (ch = = \n)
lin++;

is operatorius nurodo kompiuteriui didinti kintamojo lin vert vienetu, jei i
klaviatros paimtas simbolis yra nauja eilut \n. Jei i klaviatros paimtas simbolis
neatitinka simbolio nauja eilut, tai toliau vykdant operatori while imamas sekantis
simbolis. Operatorius getchar( ) yra skirtas vieno simbolio vedimui i klaviatros. Vieno
simbolio ivedimui naudojamas operatorius putchar( ).
EOF, tai -1, kas atitinka bylos pabaig. Paprastai automatikai tokiu simboliu
yra pabaigiama byla.
iame pavyzdyje, operatoriui if priklauso tik vienas veiksmas lin++, todl is
veiksmas baigiamas kabliatakiu. Jei operatoriui priklausyt daugiau veiksm, juos reikt
atskirti {} skliaustais. Galima patobulinti program, kad ji skaiiuot simbolius ir eilutes:

#include <stdio.h>


void main( )
{
int ch;
int lin=0, sim=0;

while((ch = getchar( )) !=EOF)
{
sim++;
if (ch = = \n)
lin++;
}

printf(suskaiiavau %d eilutes ir %d simbolius \n, lin, sim);
}

Operatoriaus if galimybes galima iplsti panaudojus operatori else. Naudojant
konstrukcij if else, tikrinama operatoriaus if slyga ir jei ji netenkinama, tuomet
vykdomi else operatoriaus veiksmai:

19














n=2*n;
if
(n>10)
Tiesa
printf(%d\n,n)
else
n=10*n;

Jei nebt operatoriaus else, tai i karto bt vykdomas spausdinimas. Po operatoriumi
else galima vl kartoti operatori if. Tokiu bdu galima patikrinti didesn slyg skaii.

Slygins operacijos

Kai kurias slygines komandas mes jau naudojome anksiau, dabar susipainsime su
visomis galimomis slyginmis operacijomis C kalboje.

Operacija Reikm
< maiau
<= maiau arba lygu
= = lygu
>= daugiau arba lygu
> daugiau
!= nelygu

Slygins komandos naudojamos su if ir while operatoriais. Atkreipiame dmes - jokiu
bdu lyginimui negalima naudoti operatoriaus =, nes tai yra priskyrimo operatorius. Deja,
slygines komandas negalima naudoti eilui lyginimui. Jei dirbama su trupmeniniais
skaiiais, patartina naudoti tik < ir > lyginimo komandas.

Logins operacijos

Danai tenka panaudoti ne tik slygines operacijas, bet ir logines. Pavyzdiui, mums
reikia paskaiiuoti, kiek byloje yra tui simboli, t.y. tarpo simboli, naujos eiluts ir
tabuliacijos klavio.

/*simboli skaiius*/
#include<stdio.h>
20

main( )
{
int sim;
int t=0;

while ((sim=getchar( ))!=EOF)
if(sim= = || sim = =\n || sim = = \t)
t++;
printf(I viso yra %d tui simboli, t);
return 0;
}

Taigi, || tai login komanda arba. C kalboje yra trys logins komandos:

Operacija Reikm
&& ir
|| arba
! ne
Pairkime kaip jos vykdomos. Tarkime turime du slyginius operatorius a ir b.
1. a&& b, slyga bus teisinga ir vykdoma, kada bus teisingos a ir b slygos.
2. a||b teisinga, jei yra teisinga a arba b slyga, arba bus teisingos abi slygos.
3. !a teisinga, jei a slyga yra neteisinga.

Paimsime kelet konkrei pavyzdi:
5>2 && 4>7 neteisinga, nes viena slyga nra patenkinta.
5>2 || 4>7, teisinga, nes viena slyga yra patenkinta.
!(4>7), teisinga, nes 4 ne didesnis u 7.

Slygin operacija: ?:

i operacija, tai trumpas if else operatoriaus uraymas. Pateiksime operatoriaus
iraik skaiiaus absoliutins verts radimui:

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

tai atitikt uraym:

if(y<0)
x=-y;
else
x=y;

21
Operatoriai switch ir break.

Jei reikia pasirinkti vien galim variant i eils duomen, tuomet nepatogu naudoti if-
else konstrukcij. Daugeliu toki atveju pravartus yra operatoriaus switch panaudojimas.
Pateiksime programos pavyzd, kuri nuskaito raid ir iveda i tos raids prasidedanio
gyvno pavadinim.

/*gyvnas*/

void main( )
{
char ch;

printf(veskite bet koki raid, o a ivesiu gyvno pavadinim i Js nurodytos raids.
\n);
printf(Jei norite darb nutraukti, veskite # simbol.\n);

while((ch = getchar( ))!=#)
{
if( ch!= ) /*nelygu tarpo simboliui*/

switch(ch)
{
case a: printf(avis, naminis gyvnas.\n);
break;
case b: printf( barsukas, laukinis gyvnas.\n);
break;

default: printf(tokio gyvno neinau.\n);
break;
}

else
printf(Js vedte tarpo klavi. veskite raid arba norint nutraukti darb
simbol #);
}
}

Tikriausiai aiku, kad paraytoji programa nuskaito i klaviatros vest simbol.
Patikrina, ar tai ne tarpo simbolis arba pabaigos simbolis #. Jei slygos tenkinamos,
tuomet ieko swicht operatoriuje nurodytos raids ir veiksm, k toliau daryti su
duomenimis. default bus naudojama visiems anksiau nenurodytams atvejams. break,
skirtas ijimui i swicht operatoriaus.

Uduotys

22
1. Paraykite program, kuri tikrint ar i klaviatros vestas skaiius yra teigiamas
ar neigiamas. Neigiamas skaiius turi bti paverstas teigiamu ir ivestas ekran,
praneant tai, o teigiamas tik praneant, kad tai teigiamas skaiius.
2. Paraykite program, kuri skaiiuot nurodyto skaiiaus faktorial.
3. Paraykite program, kuri pateiktu meniu. Meniu bt galima pasirinkti: ar ivesti
nurodyto skaiiaus kub, ar kvadratin akn, ar faktorial.

Ciklai ir kiti programos valdymo bdai

Raktiniai odiai

While, do, for, break, continue, goto

Operacijos

+= -= *= /= %=

Priminsime, kad ciklo while bendroji uraymo forma yra:

while( slyga)
Operatorius (veiksmai, kurie bus atliekami)

io ciklo viduje turime nurodyti kaip turi keistis slygoje einantis kintamasis. Kitaip,
ciklas bus begalinis ir i jo niekada neieisime.

Ciklas for: jame i karto nurodomos ciklo pradins ir galins slygos, ciklo atlikimo
ingsnis.

.
for(a=1; a<=10; a++)
printf( man puikiai sekasi!);
.

ios programos fragmento vykdymas ekrane deimt kart pasirodys fraz man puikiai
sekasi!.

Pateiksime su iuo ciklo operatoriumi parayt program, kuri skaiiuoja skaii nuo 1
iki 6 kubus.

/*kubai*/

#include<stdio.h>
#include <conio.h>

void main( )
23
{
int a;

for(a=1; a<=6; a++)
printf(%5d %5d \n, a, a*a*a);
}

Jei cikl eina ne vienas, o keletas operatori, tuomet jie turi bti atskirti {} skliaustais.
To nereikia, jei ciklui priklauso tik vienas operatorius.

for ciklo privalumai:
1. Slygos ir ingsniai uraomi i karto.
2. Galima ingsn ne tik didinti (a++), bet ir mainti (a--).
3. Galima ciklo ingsn keisti bet kokiu nurodytu dydiu: a+=13 (a=a+13).
4. Galima dirbti ne tik su skaiiais, bet ir su simboliais. Dirbant su simboliais, jie
nurodomi tarp kabui:

...
for( a = a; a<= z; a++)
printf(simbolis %c atitinka %d skaii.\n, a, a);
...

5. for ciklo viduje galima naudoti aritmetinius veiksmus:

...
for(a=1; a*a*a<=216; a++)
printf(%5d %5d \n, a, a*a*a);


6. ingsniui keisti galima panaudoti koki norime algebrin iraik.
7. Galima palikti ciklo apraymo vietas tuias, svarbu, kad negalima praleisti
kabliatakio.


for(; ; )
printf(pakibau\n);


is ciklas bus vykdomas be galo ilgai, kadangi tuia slyga yra visada teisinga.

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


bus vykdoma iki a bus maiau arba lygu 25.
24
8. Galima nurodyti ne vien, o kelias pradines slygas. Jos tarpusavyje turi bti
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
cikle while, i kurio ieinama tik io operatoriaus dka. is operatorius tikrai netinka
su if operatoriumi. Jei taip atsitinka, kad jis reikalingas, tuomet btina perirti
paraytos programos algoritm, kad nereikt naudoti io operatoriaus.
Operatorius continue gali bti naudojamas visuose cikluose iskyrus switch. ie
operatoriai geriausiai praveria, kai reikia sutrumpinti if-else slygos veikim.
Operatorius goto pats prasiausias. Jo nedera naudoti C++ kalboje. io
operatoriaus naudojimas prasto programavimo poymis.

Masyvai

Jau anksiau minjome kas yra masyvas ir kaip j reikia apibrti. Dar kart grime
prie j, kadangi jie yra svarbs programavimo procese. Pvz.:

float a[20];

kintamojo apraymas reikia, kad turime masyv a, kur sudaro dvideimt 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 bti bet kokio anksiau nurodyto tipo. Masyvo upildymas ir jo
element skaitymas atliekamas ciklo pagalba. Svarbu neumirti, kad masyvo pirmas
elementas yra a[0].


for(i=0; i<=19; i++) /*masyvo upildymas*/
scanf(%lf, &a[i]);
for(i=0; i<=19; i++)
printf(%f, a[i]); /*masyvo element atspausdinimas*/


Masyv elementus galima lyginti, atlikti aritmetinius veiksmus:


25

if(a[i]> b)
b = a[i];


Jei masyvo i-tasis elementas didesnis u b, tuomet b kintamajam priskirti i-tj
masyvo element.
Svarbu: upildymui nurodomas masyvo adresas: &a[i].
Masyvo dyd galima apibrti pasinaudojus konstantomis:


#define MAX 45

main( )
{
int a[MAX];

}

Uduotys

1. Paraykite program, kuri ivest daugybos lentel.
2. Paraykite program, kuri leist vartotojui upildyti masyv i 6 element.
Upildyto masyvo elementus iriuokite didjania tvarka ir iveskite ekran.
3. Paraykite program, kuri sudt dviej masyv elementus (masyvai sudaryti i
10 element ir sudtis turi bti: pirmo masyvo pradia sudedama su antro masyvo
pabaiga) ir rezultat surayt trei masyv, o padalintus masyvo elementus
sudt ketvirt masyv. ekran turi bti ivesti pradiniai masyvai bei j sumos,
bei dalybos masyvai.




Kaip teisingai naudotis funkcijomis

Raktinis odis

return
Programavimas C++ kalba paremtas funkcij naudojimu. Mes jau naudojome funkcijas
printf( ), scanf( ), getch( ), putchar( ), strlen( ). ios funkcijos yra sistemins, bet mes
esame sukr ir sav funkcij main( ). Programos vykdymas visada prasideda
komandomis, kurios yra main( ) funkcijoje, kuri gali kreiptis ir kitas funkcijas. Dabar
isiaikinsime kaip patiems sukurti funkcijas, kurias galt kreiptis main( ) funkcija ir
kitos sukurtos funkcijos.
26
Funkcija tai savarankika programos dalis, skirta konkreiam veiksmui atlikti.
Pvz.: funkcija printf( ) - iveda informacij ekran. Naudojant funkcijas, nereikia dar
kart programuoti besikartojanius veiksmus. Jei programoje kok nors veiksm reikia
kartoti kelet kart, tai utenka t veiksm aprayti funkcija ir reikalui esant kreiptis t
funkcij. Be to, i funkcij bus galima naudoti ne tik vienoje programoje, bet ir kitose
programose.
Tarkime, norime parayti program, kuri: vest skaii rinkin, j iriuot ir
rast vidutin vert. Mint program galima urayti sekaniai:

...
main ( )
{
float list[50];

readlist(list);
sort(list);
average(list);

return 0;
}

Aiku, kad pagrindin funkcija kreipiasi funkcijas readlist( ), sort( ) ir average( ),
kurios atlieka joms nurodytus veiksmus ir pagrindinei funkcijai grina rezultat.
Naudojant pagalbines funkcijas, galima pagrindin dmes skirti programos struktrai
negaitant laiko j detalms.
K reikia inoti apie funkcijas? Aiku, kaip jas reikia aprayti, kaip jas kreiptis ir
kaip nurodyti ry tarp programos ir paraytos funkcijos.

Paprastos funkcijos krimas ir jos panaudojimas

Paraysime program, kuri spausdint firmin blank ir sukursime nauj funkcij, kuri
brt 65 simbolius*.

/*firminio blanko virus*/
#define Name Vilniaus pedagoginis universitetas
#define Address Student 39
#define Vieta Vilnius
#include <stdio.h>

void starbar( );

void main ( )
{
starbar( );
printf(%s\n, Name);
27
printf(%s\n, Address);
printf(%s\n, Vieta);
starbar( );
}

/*funkcija starbar( )*/
#include <stdio.h>
# define Riba 65

void starbar( )
{
int count;
for(count=1; count<=Riba; count++)
putchar(*);
putchar(\n);
}

Programos veikimo rezultatas:
*******************************************
Vilniaus pedagoginis universitetas
Student 39
Vilnius
*******************************************

funkcij starbar( ) mes kreipms i funkcijos main( ), nurodydami tik
reikalingos funkcijos vard. Kaip veikia programa: pirma, ji ikarto kreipiasi starbar( )
funkcij, kuri atspausdina simbolius, toliau main( ) funkcija kreipiasi sistemines
funkcijas, kurios atspausdina tekst ir galiausiai vl starbar( ), kuri atspausdina
simbolius. Kuriant pagalbin funkcij, ji raoma pagal tokias paias taisykles kaip ir
main ( ) funkcija. ia abi funkcijos buvo uraytos vien *.cpp byl. Paprastai, geriau
rayti atskiras funkcijas atskiras bylas, kurias bt galima panaudoti kitose programose.
Ms paraytoji programa neturi nieko grinti main ( ) funkcij, todl priekyje
buvo nurodomas jos tipas void. Jei programa turt grinti vert, reikt nurodyti kokio
tipo vert funkcija grins ir grinamo argumento vert: int starbar(int a); tai reikt,
kad funkcija starbar( ) grins sveik skaii ir gaus apdorojimui taip pat sveik skaii
a. Tuomet sukurtos funkcijos viduje reikia pasinaudoti operatoriumi return, kuris nurodo
sukurtai funkcijai k ji turi grinti.
Pasiaikinsime emiau pateikt program:

/*absoliutins verts*/
#include<stdio.h>

int abs (int x);
void main( )
{
int a=10, b=0, c=-22;
28
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;
}

Programos veikimo rezultatas:

10 0 22

Pagrindin funkcija kreipiasi kit funkcij, kuri skaiiuoja skaiiaus modul.
Suskaiiavusi modul return komanda graina rezultat pagrindinei funkcijai, kuri
gautj rezultat iveda ekran.

Globalieji (ioriniai) ir lokalieji (vietiniai) kintamieji

Paprastai, kintamuosius mes aprame funkcijos viduje, todl tai buvo tos funkcijos
lokalieji (vidiniai) kintamieji, kurie nebuvo inomi kitoms funkcijoms. Todl vienai
funkcijai perduoti kintamojo vert buvo naudojama komanda return.
C++ kalboje danai tenka naudoti globaliuosius kintamuosius, kuriuos naudos
keletas funkcij. Jei kintamasis yra apibrtas ir vienoje ir kitoje funkcijoje tuo paiu
vardu, j kompiliatorius vis tiek supranta kaip atskir kintamj. Pairkime program,
kuri sukeiia kintamj vertes:

/*kintamuju sukeitimas*/
#include <stdio.h>
#include <conio.h>

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

void main( )
{
int x=5, y=10;
printf("esamos x= %d ir y= %d verts\n", x, y);
interchange(&x, &y);
29
printf("sukeistos x= %d ir y= %d verts \n", x, y);
}

int interchange(int *u, int *v)
{
int a;
a= *u;
*u= *v;
*v= a;

return *u, *v;

}

ioje programoje main( ) funkcija siunia ne kintamj, o kintamojo adres &x, &y. Tuo
tarpu funkcijos interchange( ) kintamieji apibriami kaip rodykls *u, *v. Rodykl tai
nurodytu adresu kintamojo vert, t.y a= *u tai reikia kintamajam a priskirti x vert, nes
i funkcija gavo ne vert, bet adres. Tokiu bdu, naudojant lokaliuosius kintamuosius,
galima perduoti vienai funkcijai kitos vertes.

Globalieji kintamieji apibriami prie main( ) funkcij naudojant extern komand
(extern nurodo, kad tai bus iorinis, visoms funkcijoms bendras kintamasis).

Uduotys

1. Perraykite meniu program pasinaudodami savo sukurtomis funkcijomis
skaiiaus kubui, kvadratinei akniai, faktorialui skaiiuoti.
2. Paraykite funkcij, kuri gavusi kintamj x ir y vertes, jas pakeiia j suma ir
skirtumu bei atspausdina jas.
3. Paraykite atskiras funkcijas, kurias naudoja pagrindin funkcija skaii sumai,
sandaugai ir faktorialui skaiiuoti.


Rekursins funkcijos

Rekursin funkcija tai funkcija, kuri kreipiasi pati save. Vaizdumo dlei,
pasiaikinsime kaip parayti funkcij faktorialui skaiiuoti. Faktorial galima
apskaiiuoti dviem bdais:
n!=1 2 ( n- 1) n
arba
n!=n ( n- 1) ! , 0! =1.

30
Antrasis faktorialo uraymo bdas, tai yra faktorialo lygtis. Pagal pirmj apibrim
faktorialo skaiiavimo program Js jau rate. Dabar paraysime faktorialo
skaiiavimo funkcij pagal antj apibrim:


int fact(int n)
{
if (n = 0) return 1;
else return n*fact(n-1);
}


Kaip matome, funkcijos uraymas sutrumpja ir ia nra jokio ciklo. i funkcija
kreipsis pati save tol, kol n bus lygus 0. Rekursins funkcijos naudingos, kai reikia
programuoti veiksmus su neinomu operacij skaiiumi.

Uduotis

1. Paraykite program, kuri urao ekrane deimt pirmj Fibonai skaii.
Fibonai skaiiai tenkina toki diskretin lygt:
f
n
= f
n-1
+f
n-2
, f
0
=0, f
1
=1. Pagal i lygt reikia parayti rekursin funkcij.

Masyvai ir rodykls

Jau inome, kas yra masyvai ir kaip apibrti statin (apibrto dydio) masyv.
Apibrto masyvo elementams galima i karto priskirti vertes:

#include <stdio.h>
#include <conio.h>

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 mnuo turi %d dien. \n", i+1, days[i]);
}

iuo atveju masyvas apibrtas kaip iorinis, todl paioje funkcijoje jo apibrti
nereikia.

Galima ir nenurodyti masyvo element skaiiaus. Tuomet pats kompiliatorius
suskaiiuos lautiniuose skliaustuose pateiktas vertes:

31
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 mnuo turi %d dien. \n", i+1, days[i]);
}

iuo atveju pats kompiliatorius apibr masyvo dyd. Cikle for norint nurodyti
masyvo dyd mes sizeof( ) funkcijos pagalba suskaiiuojame masyvo dyd baitais.
Kadangi masyvo elementai yra sveiko tipo kintamieji, kurie uima du baitus
kompiurio atmintyje, tai norint gauti masyvo skaii, mes padalinome masyvo
uimam viet i 2 ir gauname masyvo element skaii.
Siuniant masyv funkcijai, elgiamasi taip pat kaip ir su kintamaisiais naudojant
rodykles ir adresus.
Iki iol buvo naudotas tik vienmatis masyvas. Danai prireikia dvimai arba
trimai masyv. Pvz.:
float rain[5][12];
ia apibrtas penki element masyvas, kurio kiekvieno element sudaro 12
element. Vaizdiai tokio tipo masyv galima pavaizduoti taip:


















rain[0][0] rain[0][1]
rain[1][0] rain[1][2] rain[1][1]
rain[0][2]
rain[2][0]
rain[0][3]
5
12
Keiiant masyvo elementus elgiamasi taip pat kaip ir dirbant su vienmaiu masyvu.
Norisi pabrti, kad C kalboje masyvai yra labai paprasti. Jie yra tokie prasti, kad yra
ymiai geriau galvoti, kad j nra i viso.

Jei masyvo dydis bus suskaiiuotas tik programos eigoje, tai masyv reikia apibrti
kaip rodykl:

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

Aukiau pateiktame pavyzdyje, pradioje masyvas apibrtas kaip rodykl,
programos eigoje apskaiiuota, kiek reiks masyvo element zz. Tuomet, malloc( )
funkcijos pagalba yra sukuriamas reikiamo dydio masyvas. Primename, kad zz
masyvo element skaiius, o sizeof(float) nurodo float tipo kintamj uimam
viet kompiuterio atmintyje baitais.


vesties ir ivesties bylos C kalboje

Danai teks rayti programas, kurios duomenis ims i bylos ir skaiiavimo
rezultatus irgi ives byl. Pasiaikinsime pradioje paprastas bylos skaitymo
funkcijas fopen( ), fclose( ), getc( ), putc( ).
Pairsime program, kuri skaito bylos test turin ir j iveda ekran.

#include<stdio.h>

void main( )
{
FILE *in; /* aprao rodykl byl*/
int ch;

if ((in=fopen("test","r"))!=NULL)
/*atidaro byl skaitymui ir tikrina ar yra tokia byla*/
{
while((ch= getc(in))!=EOF)
putc(ch, stdout);
/* iveda byl ekran*/
fclose(in); /*udaro byl*/
}
else
printf("bylos atidaryti negaljau");
}

Bylos atidarymas: fopen( )
Funkcijai fopen( ) reikia perduoti tris duomenis: 1) bylos pavadinim; 2) nurodyti
kaip naudosime byl:
r: byl skaitysime
w: byl raysime duomenis
a: papildysime byl
33
3) rodykl byl:

FILE *in;

in=fopen(test, r);
Dabar in yra rodykl byl test.
Jei fopen( ) negali atidaryti bylos, ji grina vert NULL.

Bylos udarymas: fclose( )

Ms pavyzdyje:
fclose(in);
Atkreipiame dmes, jos argumentas yra rodykl in, o ne byla test. i funkcija, jei
byl pavyko udaryti skmingai, grina 0, jei ne -1.

Bylos duomen vedimas ir ivedimas: getc( ) ir putc( )

ios funkcijos veikia analogikai funkcijoms getchar( ) ir putchar( ). Skirtumas tik tas,
kad reikia praneti koki byl reikia naudoti. Todl getchar( ):
ch =getchar( );
reikia pakeisti:
ch = getc(in);
Analogikai putc( ):
putc(ch, out);

skirta simbolio ch uraymui byl, kuri siunia rodykl out tipo FILE.
Ms atveju buvo naudota stdout tai rodykl standartin ivedim.

Bylos vedimas ivedimas: fprintf( ), fscanf( ), fgets( ), fputs( )

Kintamojo ir informacijos ivedimo skirtumas yra tik tas, kad ivedant informacij byl
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 dirba panaiai kaip ir funkcijos printf() ir scanf(), tik joms
reikalingas papildomas argumentas, rodantis siuntim byl. Tai nurodoma paioje
pradioje. Pvz.:
34

#include<stdio.h>

void main( )
{
FILE *fi; /* aprao rodykl 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);
}
}

Panaiai yra ir su funkcija fgets( ), kuri nuo gets( ) skiriasi papildomu kintamuoju:

/* nuskaito byl eilutmis*/
#include<stdio.h>
#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 eiluts padtis. ia bus vedama
perskaityta i bylos informacija (bus raoma simbolin masyv).
Antrasis argumentas nurodo skaitomos eiluts ilg. Treiasis argumentas nurodo
byl, i kurios bus skaitoma informacija.
Skirtumas tarp gets( ) ir fgets( ) gets( ) keiia naujos eiluts simbol \0, o
fgets( ) ilaiko simbol. Abi funkcijos sutik bylos pabaig EOF, grina vert
NULL.
fputs( ) daro panaius veiksmus puts( ) funkcij:

fputs(Tu teisus, fileptr);

perduoda eilut Tu teisus byl, kuri nurodo rodykl fileptr.
35

Simbolini eilui pakeitimas

Danai perskaityt simbolin eilut reikia pakeisti atitinkam skaitin vert. Tam yra
naudojamos funkcijos atoi( ) ir atof( ). Pirmoji funkcija eilut paveria sveiku
skaiiumi, antroji slankiojo kablelio skaiiumi. i funkcij argumentas yra
simbolinio tipo. Atvirktins paskirties funkcijos: itoa( ) sveiko tipo skaii
paveria eilute, ftoa( ) double tipo skaii paveria eilute.

Uduotys
1. Paraykite program, skirt gaut knyg inventorizacijai. vedami duomenys turi
bti raomi atskir byl.
2. Paraykite program, kuri nuskaityt i bylos duomenis: pradioje turi bti
sukurta byla, kurioje bt nurodyti kokie nors skaiiai. Nuskaiiusi, atspausdint
bylos turin ekran, patikrint ar nra nuli, jei yra, juos itrint ir naujus
skaiius rayt nauj byl.


Literatra

1. ., ., ., , , , 1988.
2. A. Matulis C, C++, ir OOP .
3. A. Vidinas, C++ duomen tipai ir struktros, Kaunas, Smaltija, 2000.
4. A.Vidinas, C++ ir C++ Builder pradmenys, Kaunas, Smaltija, 2002.
5. J.Blanskis ir kiti, C++ praktikumas. KTU, 2001.
6. J.Lipeikien, Programavimas C++ kalba, VPU leidykla, 2002.

PRIEDAS

Raktiniai C kalbos odiai

Programos vykdymo raktiniai odiai:
Ciklai:
for while do
Pasirinkimas ir slygos:
if else switch case default
Perjimas:
break continue goto
Duomen tipai:
char int short long unsigned float double struct union typedef
Atminties klass:
36
Auto extern register static

Programos vykdymo valdymas

Operatorius while
Uraymo forma:
while ( slyga)
operatorius;

Operatorius kartojamas tol, kol slyga teisinga.
Pavyzdiai:

while(n++<100)
printf(%d %d\n, n, 2*n+1);

while( fargo<1000)
{
fargo = fargo + step;
step = 2*step;
}

Operatorius for

Uraymo forma:
for(priskyrimas; slyga; ingsnis)
operatorius;

Operatorius vykdomas tol, kol tenkinama slyga.

Pavyzdiai:
for(n=0;n<10;n++)
printf(%d %d\n, n, n*2+1);

Operatorius do while

Uraymo forma:
do
operatorius
while(slyga);

Operatorius vykdomas, kol tenkinama slyga.

Pavyzdiai:
do
scanf(%d, &num)
while(num!=20);
37

Operatoriai if ir else

Uraymo forma:
1 BDAS

if(slyga)
operatorius

Operatorius vykdomas, jei tenkinama slyga.

2 bdas

if(slyga)
operatorius1
else
operatorius2

Jei slyga teisinga, vykdomas operatorius1, jei klaidinga operatorius2.

3 bdas

if(slyga1)
operatorius1
else if(slyga2)
operatorius2
else
operatorius3

Jei slyga1 teisinga, tai vykdomas operatorius1. Jei slyga1 klaidinga, o slyga2 teisinga,
vykdomas operatorius2. Jei abi slygos klaidingos, vykdomas operatorius3.

Pavyzdiai:

if(a= = 4)
printf(tai arklys);
else if(a>4)
printf(tai ne arklys);
else
{
a++;
printf(klaida);
}

Operatorius switch

38
Uraymo forma:
switch (iraika)
{
case 1poymis: operatorius1
case 2poymis: operatorius2
default : operatorius3
}

default nra btinas

Pavyzdiai:

switch(raid)
{
case a: printf(as);
case b:
case c:printf(taip);
default: printf(nesiseka);
}

Jei paimtas simbolis nra nei a, nei b, nei c tai vykdomas default operatorius.









39