Lekt. Tomas G. Lipnevičius

Pateikčių temos: "Lekt. Tomas G. Lipnevičius"— Pateikties kopija:

1 Lekt. Tomas G. Lipnevičius
Programavimo ir IT pagrindai 5 paskaita Lekt. Tomas G. Lipnevičius

2 Programavimo pagrindai
Programavimas

3 Operatorius break Naudojamas norint nutraukti ciklo (while, for, do-while) ar sąlyginio operatoriaus (if, else- if, switch) darbą, t.y. kitokiu būdu nei nurodyta ciklo ar sąlyginio operatoriaus sąlygoje.

4 Operatorius break #include <stdio.h> void main() { int i, ch;
printf("\n Iveskite iki 20 skaiciu, 0 - pabaiga.\n Ivesta: "); for ( i = 1; i<=20; i++) scanf("%d", &ch); if ( ch == 0 ) break; printf("%d ", ch); } printf("\n");

5 Operatorius continue Šis operatorius yra naudojamas cikle norint praleisti žingsnį nenutraukiant ciklo darbo. Šis operatorius gali būti naudojamas visuose ciklo sakiniuose, bet negalima jo naudoti switch operatoriaus konstrukcijoje.

6 Operatorius continue #include <stdio.h> void main() { int i;
printf("Skaiciai nuo 0 iki 10 be skaiciaus 6\n"); for (i=0; i<=10; i++) if (i == 6) continue; else printf("%d ", i); } printf("\n");

7 Operatorius goto ir žymės
Operatorius goto naudojamas norint perduoti programos vykdymą norimai programos eilutei. Sintaksė: goto žymė; ... žymė: ... Šio operatoriaus pageidautina vengti – jį galima realizuoti kitomis konstrukcijomis. Yra viena situacija kai prasminga naudoti šį operatorių: kai reikia išeiti iš kelių įdėtinių ciklų ir nenorima naudotis break operatoriumi.

8 Operatorius goto ir žymės
#include <stdio.h> void main() { int i, j, k, l, suma=0; for (i=0; i<=10; i++) suma += i; printf ("i=%d\n", i); for (j=0; j<=10; j++) suma += j; printf ("\tj=%d\n", j); for (k=0; k<=10; k++) suma += k; printf ("\t\tk=%d\n", k); for (l=0; l<=10; l++) printf ("\t\t\tl=%d\n", l); if (suma > 30) goto pabaiga; } pabaiga: printf("Isvestu skaiciu suma pasieke 30\n");

9 Duomenų tipai ir sizeof funkcija
#include <stdio.h> int main() { printf("\nDuomenu tipas\tBaitu kiekis\n"); printf("\nSveikieji skaiciai:\n"); printf("unsigned char\t%d\n", sizeof(unsigned char)); printf("short\t\t%d\n", sizeof(short)); printf("unsigned short\t%d\n", sizeof(unsigned short)); printf("int\t\t%d\n", sizeof(int)); printf("unsigned\t%d\n", sizeof(unsigned)); printf("signed\t\t%d\n", sizeof(signed)); printf("long\t\t%d\n", sizeof(long)); printf("unsigned long\t%d\n", sizeof(unsigned long)); printf("\nRealus skaiciai:\n"); printf("float\t\t%d\n", sizeof(float)); printf("double\t\t%d\n", sizeof(double)); printf("\nSimboliai:\n"); printf("char\t\t%d\n", sizeof(char)); }

10 DuomenųTipas MasyvoPavad[Dydis];
Masyvai Masyvas tai duomenų struktūra leidžianti saugoti grupę to paties tipo objektų ištisinėje atmintyje. Visi masyvo elementai privalo būti to paties tipo, pvz.: float, char, int, rodyklė į int, struktūra, funkcija. Vienmatis masyvas apibrėžiamas taip: DuomenųTipas MasyvoPavad[Dydis];

11 Masyvai Pavyzdžiui: int Skaiciai[30]; // 30 elementų vienmatis masyvas kurio elementais yra int tipo skaičiai int lentele[10][20]; // 200 elementų dvimatis masyvas kurio elementais yra int tipo skaičiai float Temp[10]; // 10 elementų vienmatis masyvas kurio elementais yra float tipo skaičiai char Vardas[50]; // 50 elementų vienmatis masyvas kurio elementais yra char tipo simboliai (pvz. raidės) int *ptr[10]; // 10 elementų vienmatis masyvas kurio elementais yra rodyklės į int tipą

12 Masyvai #include <stdio.h> void main() { const ILGIS = 5; int MAS[ILGIS]; int i; for (i = 0; i < ILGIS; i++) MAS[i] = i; }

13 Masyvai C kalboje elementų indeksavimas (numeravimas) masyve prasideda nuo nulio. Tarkime, kad turime masyvą MAS[N], kur N=5. Šiuo atveju elementų indeksavimas prasideda nuo 0 ir baigiasi N-1, t.y. nuo 0 iki 4: MAS[0]; // pirmas masyvo elementas MAS[1]; // antras masyvo elementas ... MAS[4]; // paskutinis (penktas) elementas

14 Masyvai C kalboje be vienmačių masyvų galime apibrėžti ir daugiamatį. Pavyzdžiui: float masyvas [10][50]; // dvimatis float tipo elementų masyvas int koordinates [10][10][10]; // trimatis int tipo elementų masyvas

15 Masyvai Ciklo konstrukcijos dažnai naudojamos iteruojant masyvo elementus. #define MAX_I 10; #define MAX_J 20; int i, j; float masyvas [MAX_I][MAX_J]; for (i = 0; i < MAX_I; i++) { for (j = 0; j < MAX_J; j++) masyvas [i][j] = i * j; }

16 Masyvai C kalboje masyvo rėžių tikrinimas nėra daromas.
Jei apibrėžiame masyvą kurį sudaro tarkime 30 elementų ir bandysime pasiekti 30 elementą (C kalboje numeravimas prasideda nuo 0) ar bet kurį kitą elementą už rėžio ribų – kompiliuodami kodą negausime jokių klaidų!

17 Funkcijоs C kalboje nėra skirstymo į procedūras, paprogrames ir funkcijas. C kalboje turime tik funkcijas. Funkcijų privalumai: Išvengiame tam tikro kodo dalies kartojimo; Funkcijos gali būti panaudojamos įvairiose programos vietose; Funkcijos leidžia realizuoti programą moduliniame pavidale, kas leidžia lengviau: Rašyti programą – leidžia dirbti su tam tikromis programos dalimis nepriklausomai nuo kitų. Skaityti programą – leidžia suprasti ką daro tam tikrą grupė funkcionalumo, kas leidžia suprasti ką daro didesnis gabalas programos nesigilinant į kiekvieną operaciją, t.y. galima slėpti tam tikrą funkcionalumą Modifikuoti programą – tam tikros funkcijos modifikavimas dažniausiai neturi ar turi nedidelį poveikį visai programai. Ieškoti klaidų – galima testuoti atskirai kiekvieną iš funkcijų, kas leidžia greičiau aptikti klaidą. Kiekvieną kartą kviečiant funkciją lokaliai apibrėžti kintamieji yra saugomi vis kitoje atminties vietoje, t.y. kiekvieną kartą yra iš naujo išskiriama atmintis. Leidžia realizuoti rekursinius procesus.

18 Funkcijos Funkcija tai nepriklausoma visuma apibrėžimų ir operatorių – skirta konkrečiai užduočiai atlikti. Kiekviena funkcija privalo turėti unikalų vardą, kuris yra naudojamas norint ją iškviesti. Vienos iš funkcijų pavadinimas yra main() – ji privalo būti kiekvienoje C programoje, nes nuo jos prasideda visos programos darbas. Programoje funkcijų gali būti daugiau nei tik main(), ir funkcija main() nebūtinai turi būti pirma. Kviečiant funkciją jai gali būti perduoti duomenys per funkcijos argumentus. Funkcija taipogi gali grąžinti rezultatą. Šis rezultatas ir yra pagrindinis funkcijos veiklos rezultatas, kuris ją įvykdžius, yra įstatomas į tą programos vietą iš kurios buvo kviečiama funkcija. Gali būti ir funkcijos kurios neturi jokių parametrų ir negrąžina jokio rezultato.

19 Funkcijos //funkcija negrazina ir negauna jokiu reiksmiu void print_message(void) { printf("hello\n"); } void main() print_message();

20 Funkcijos //funkcija gauna viena parametra void print_integer(int i) { printf("i = %d\n", i); } void main() int n=5; print_integer(n); }

21 Funkcijos //funkcija grazina rezultatą int input_integer(void); //prototipas void main() { int x, y, z; x = input_integer(); y = input_integer(); printf(“Dvieju skaiciu suma: %d\n", z=x+y); } int input_integer(void) int a; do printf(“Iveskite sveika skaiciu: "); scanf("%d", &a); } while (a <= 0); return a; }

22 Funkcijos //funkcija gauna parametra ir grazina rezultata void main() { int x, y, z=100; int funkcija(int n); //prototipas x = funkcija(z); y = funkcija(z); printf(“Skaiciu suma: %d\n", x+y); } int funkcija(int n) int a; do printf(“Iveskite sveika teigiama skaiciu mazesni nei %d: ", n); scanf("%d", &a); } while (a<=0 || a>n); return a; }

23 Funkcijos Norint naudoti funkcijas C kalboje reikia suvokti tris sąvokas: funkcijos apibrėžimas, funkcijos aprašas ir funkcijos kvietimas. Funkcijos apibrėžimas nurodo funkcijos pavadinimą, formaliųjų parametrų skaičių bei tipus, apibrėžimus ir operatorius, kurie nusako funkcijos veikimą. Tam tikra apibrėžimų ir operatorių seka yra vadinama funkcijos kūnu. Funkcijos apibrėžimui dar gali priklausyti rezultato, kurį įgauna funkcija, tipas ir atminties klasė. C kalboje nėra reikalavimo, kad funkcijos apibrėžimas eitų būtinai prieš funkcijos kvietimą, t.y. funkciją galima apibrėžti prieš ar po funkcijos main(), galima ją apibrėžti ir kitame faile. Norint, kad kompiliatorius galėtų atlikti tipų atitikimo patikrinimą perduodamų funkcijai parametrų (faktinių argumentų) su formaliais parametrais esančiai funkcijos apibrėžime, prieš funkcijos kvietimą turėtų būti bent funkcijos prototipas dar vadinamu aprašymu. Funkcijos prototipas turi tokį pat formatą kaip ir funkcijos apibrėžimas. Skirtumas tik tame, kad funkcijos prototipas arba aprašymas neturi kūno ir baigiasi kabliataškiu.

24 Funkcijos Funkcijos prototipas nusako funkcijos pavadinimą, formaliųjų parametrų skaičių ir jų tipus, gražinamo rezultato tipą ir atminties klasę. Formalieji parametrai gali turėti pavadinimus, bet jie kompiliatoriui nėra reikalingi, kadangi jis tikrintina tik tipų atitikimą. C kalbos standartinių bibliotekų funkcijų prototipai randasi atitinkamose antraščių (header) failuose.

25 Funkcijos apibrėžimas
Funkcijos apibrėžimas: [atminties klasė] [tipas] funkcijos_pavadinimas ([formaliųjų parametrų sąrašas]) { Funkcijos kūnas } Atminties klase gali būti: extern arba static Tipas: Čia nurodomas funkcijos rezultato tipas. Šiuo tipu gali būti bet kuris iš bazinių tipų, struktūros ar išvardijimas (enum). Jei tipas nenurodomas pagal nutylėjimą yra manoma, kad tai bus int tipas.

26 Funkcijos apibrėžimas
Funkcijos pavadinimas gali būti su simboliu *. Tai reiškia, kad funkcija grąžina rodyklę. Funkcijos negali grąžinti masyvų ar funkcijų, bet gali grąžinti rodyklę į bet kokį tipą įskaitant masyvus ir funkcijas. Funkcijos rezultato tipas būtinai turi atitikti tipą funkcijos apraše (prototipe). Funkcija grąžina rezultatą, jei jos įvykdymas pasibaigia operatoriumi return: return išraiška;

27 Funkcijos Išraiška gali būti skaičiuojama (pvz. return a + b;), konvertuojama (pvz. return (int) a;) jei būtina į funkcijos rezultato tipą aprašyto funkcijos prototipe ar apibrėžime, ir perduodama į funkcijos kvietimo vietą. Jei operatorius return nenurodomas ar neturi jokios išraiškos – funkcija negrąžina rezultato. Šiuo atveju būtina vietoje funkcijos rezultato tipo naudoti void.

28 Funkcijos parametrai Formaliųjų parametrų sąrašas: tai tam tikra tvarka surašyti formaliųjų parametrų aprašai. Iš tikrųjų tai yra kintamieji, kurie įgauna reikšmes, kurios yra perduodamos kviečiant funkciją. Formalieji parametrai yra atskiriami kableliais. Parametrų sąrašas gali baigtis ir daugtaškiu (,...). Tai reiškia, kad funkcijos parametrų sąrašas yra kintamas (pvz. funkcijos printf ir scanf). Bet manoma, kad funkcija gali turėti mažiausiai tiek parametrų, kiek jų yra aprašyta iki paskutinio kablelio. Funkcijai galime perduoti daugiau argumentų nei yra aprašyta parametrų iki paskutinio kablelio. Tokiems argumentams nebus daroma tipų patikrinimo kontrolė. Jei funkcijai parametrai nėra perduodami tada naudojame void. Formaliųjų parametrų tvarka ir tipai turi atitikti vienodi ir funkcijos apibrėžime ir aprašuose. Faktinių argumentų tipai kviečiant funkciją turi atitikti formaliųjų parametrų tipus. Formalusis parametras gali būti bet kokio bazinio tipo, struktūra, sąrašo, išvardinimo, rodykle ar masyvu.

29 Funkcijos kūnas Funkcijos kūnas tai sudėtinis funkcijos operatorius, kurį sudaro operatoriai, nusakantys funkcijos veikimą. Jį gali sudaryti ir reikalingų kintamųjų apibrėžimai, kurie naudojami funkcijos kūne. Visi kintamieji apibrėžti funkcijoje yra lokalieji. Tuo metu kai kviečiama funkcija, lokaliems kintamiesiems yra išskiriama atmintis ir įvykdoma jų inicializacija (jei ji nurodyta). Funkcijoje valdymas yra perduodamas pirmam operatoriui ir prasideda funkcijos vykdymas, kuris tęsiasi tol kol nebus pasiektas operatorius return ar funkcijos kūno pabaiga. Valdymas tada yra perduodamas į tą programos vietą kurioje funkcija buvo kviečiama. Jei funkcija turi grąžinti rezultatą – reikia įvykdyti operatorių return ir nurodyti jam grąžinamą reikšmę.

30 Funkcijos parametrai C kalboje funkcijos parametrai yra perduodami pagal reikšmę ir funkcijoje yra traktuojami kaip lokalieji kintamieji, kuriems yra išskiriama atmintis prieš pradedant vykdyti funkciją, jie yra inicializuojami funkcijai perduodamomis reikšmėmis ir yra prarandami išėjus iš funkcijos kūno. Todėl funkcijoje negalima pakeisti parametro, nes funkcija dirba su argumentų kopijomis. Bet jei vietoje reikšmių funkcijai perduosime rodyklę, funkcijoje pasinaudojus išadresavimo funkcija galima pakeisti parametro reikšmę.

31 Funkcijos Reikšmių keitimo funkcija: //blogas pavyzdys void mainai (int x, int y) { int temp = x; x = y; y = temp; } //geras pavyzdys void mainai (int *ptr_x, int *ptr_y) int temp = *ptr_x; *ptr_x = *ptr_y; *ptr_y = temp;

32 Funkcijos prototipas Jei reikia iškviesti funkciją iki jos panaudojimo viename faile arba funkcijos apibrėžimas yra kitame faile, prieš kviečiant tokią funkciją reikia ją aprašytį, t.y. sukurti jai prototipą. Prototipas leis kompiliatoriui atlikti argumentų ir rezultato patikrinimą. Prototipas aprašomas tokiu būdu: [atminties klasė] [tipas] funkcijos_pavadinimas ([formaliųjų parametrų sąrašas]); Skirtingai nei funkcijos apibrėžimas, prototipas yra užbaigiamas kabliataškiu.

33 Funkcijos_pavadinimas ([išraiškų sąrašas]);
Funkcijos kvietimas Funkcija kviečiama taip: Funkcijos_pavadinimas ([išraiškų sąrašas]); Išraiškų sąrašas tai faktiniai argumentai, kurie yra perduodami funkcijai. Funkcijos kvietimas atrodo sekančiu būdu: Pirmiausią yra atliekami skaičiavimai išraiškų sąraše. Pvz. kviečiame funkciją ir perduodame jai parametrus (a+b, c, d-e). Toliau, jei yra žinomas funkcijos prototipas, rezultato tipas yra lyginamas su formaliuoju rezultato tipu, t.y. žiūrima kokio tipo reikšmė yra return operatoriuje ir koks yra rezultato tipas prototipe. Jei jie neatitinka yra arba bandoma suvienodinti tipus arba yra gaunamas atitinkamas pranešimas (pvz. klaida). Toliau tikrinama ar faktinių parametrų skaičius sutampa su formaliųjų parametrų skaičiumi, išskyrus tą atvejį kai turime kintamą kiekį parametrų. Tokiu atveju kompiliatorius patikrina tiek argumentų kiek tipų yra formaliųjų parametrų sąraše ir esant reikalui bando juos suvienodinti. Jei funkcijos prototipe vietoje formaliųjų parametrų turime void, tai reiškia kad funkcijai nėra perduodami argumentai ir funkcijos prototipe neturi būti parametrų. Jei tai ne taip – duodamas atitinkamas pranešimas. Vykdomas formaliųjų parametrų keitimas faktiniais argumentai. Pirmas formalusis atitinka pirmąjį faktinį argumentą ir t.t. Valdymas perduodamas pirmam funkcijos operatoriui. Operatoriaus return vykdymas funkcijos kūne grąžina valdymą ir galimai rezultatą kviečiančiai funkcijai. Jei operatoriaus return nėra, valdymas bus gražintas įvykdžius paskutinį funkcijos operatorių.

34 Rekursiniai funkcijų kvietimai
Bet kuri funkcija C kalboje gali būti išviesta rekursyviai, t.y. gali kviesti pati save. Kompiliatorius leidžia bet kokį skaičių rekursinių kvietimų, bet tą kiekį gali riboti operacinė sistema. Kiekvieno funkcijos kvietimo metu yra išskiriama nauja atmintis, tokiu būdu reikšmės iš prieš tai neužbaigtų kvietimų nedingsta, bet parametrai iš prieš tai neužbaigtų kvietimų nėra pasiekiami. Rekursijos pavydžiu gali būti faktorialo skaičiavimas: n! = 1, kai n=0 ir n!= n* (n-1)!, kai n>1. long faktorialas (int n) { return (n<=1) ? 1 : n * faktorialas (n-1); }

35 Rekursiniai funkcijų kvietimai
//Faktorialo n!= 1* 2 *...* n skaiciavimas 0!=1, Vn>0, n!=n *(n -1)! #include<stdio.h> long Faktorialas(long); int main() { int n; printf("Iveskite sveika skaciu: "); scanf("%d", &n); printf ("%d! = %d\n", n, Faktorialas(n)); return 0; } long Faktorialas(long skaicius) if ( skaicius <=1 ) return 1; else return (skaicius * Faktorialas(skaicius - 1));

36 ctype.h <ctype.h> - simbolių tikrinimų funkcijos.
int isalnum(int c); grąžina 1 jei tai didžioji raidė, 2 – jei mažoji, 0 – jei skaičius. Analogais gali būti isalpha(c) ar isdigit(c); isalpha(c) or isdigit(c) grąžina 1 jei tai didžioji raidė, 2 – jei mažoji, 0 – jei skaičius. Analogais gali būti isupper(c) ar islower(c); int isalpha(int c); isupper(c) or islower(c) int iscntrl(int c); //is control character. In ASCII, control characters are 0x00 (NUL) to 0x1F (US), and 0x7F (DEL) int isdigit(int c); //is decimal digit

37 ctype.h int isgraph(int c); //is printing character other than space
int islower(int c); //is lower-case letter int isprint(int c); //is printing character (including space). In ASCII, printing characters are 0x20 (' ') to 0x7E ('~') int ispunct(int c); //is printing character other than space, letter, digit int isspace(int c);/ /is space, formfeed, newline, carriage return, tab, vertical tab int isupper(int c); //is upper-case letter int isxdigit(int c); //is hexadecimal digit int tolower(int c); //return lower-case equivalent int toupper(int c);

38 math.h double exp(double x); exponential of x
double log(double x); natural logarithm of x double log10(double x); base-10 logarithm of x double pow(double x, double y); x raised to power y double sqrt(double x); square root of x double ceil(double x); smallest integer not less than x double floor(double x); largest integer not greater than x double fabs(double x); absolute value of x double modf(double x, double* ip); returns fractional part and assigns to *ip integral part of x, both with same sign as x double fmod(double x, double y); if y non-zero, floating-point remainder of x/y, with same sign as x; if y zero, result is implementation-defined

39 math.h double sin(double x); sine of x
double cos(double x); cosine of x double tan(double x); tangent of x double asin(double x); arc-sine of x double acos(double x);arc-cosine of x double atan(double x); arc-tangent of x double atan2(double y, double x); arc-tangent of y/x

40 stdio.h EOF Value used to indicate end-of-stream or to report an error. NULL Null pointer constant. SEEK_CUR Value for origin argument to fseek specifying current file position. SEEK_END Value for origin argument to fseek specifying end of file. SEEK_END Value for origin argument to fseek specifying beginning of file. stdin File pointer for standard input stream. Automatically opened when program execution begins. stdout File pointer for standard output stream. Automatically opened when program execution begins. stderr File pointer for standard error stream. Automatically opened when program execution begins.

41 stdio.h FILE Type of object holding information necessary to control a stream. FILE* fopen(const char* filename, const char* mode); Opens file named filename and returns a stream, or NULL on failure. mode may be one of the following for text files: "r“ text reading "w“ text writing "a“ text append "r+”text update (reading and writing) "w+”text update, discarding previous content (if any) "a+“ text append, reading, and writing at end or one of those strings with b included (after the first character), for binary files. FILE* freopen(const char* filename, const char* mode, FILE* stream); Closes file associated with stream, then opens file filename with specified mode and associates it with stream. Returns stream or NULL on error.

42 stdio.h int fflush(FILE* stream);
Flushes stream stream and returns zero on success or EOF on error. Effect undefined for input stream. fflush(NULL) flushes all output streams. int fclose(FILE* stream); Closes stream stream (after flushing, if output stream). Returns EOF on error, zero otherwise. int remove(const char* filename); Removes specified file. Returns non-zero on failure. int rename(const char* oldname, const char* newname); Changes name of file oldname to newname. Returns non-zero on failure. int fprintf(FILE* stream, const char* format, ...); Converts (according to format format) and writes output to stream stream. Number of characters written, or negative value on error, is returned. Conversion specifications consist int printf(const char* format, ...); printf(f, ...) is equivalent to fprintf(stdout, f, ...) int fscanf(FILE* stream, const char* format, ...); Performs formatted input conversion, reading from stream stream according to format format. The function returns when format is fully processed. Returns number of items converted and assigned, or EOF if end-of-file or error occurs before any conversion. Each of the arguments following format must be a pointer.

43 stdio.h int scanf(const char* format, ...);
scanf(f, ...) is equivalent to fscanf(stdin, f, ...) int fputc(int c, FILE* stream); Writes c, to stream stream. Returns c, or EOF on error. int getc(FILE* stream); Equivalent to fgetc except that it may be a macro. int getchar(void); Equivalent to getc(stdin). char* gets(char* s); Copies characters from stdin into s until newline encountered, end-of-file reached, or error occurs. Does not copy newline. NUL- terminates s. Returns s, or NULL on end-of-file or error. Should not be used because of the potential for buffer overflow. int putc(int c, FILE* stream); Equivalent to fputc except that it may be a macro. int putchar(int c); putchar(c) is equivalent to putc(c, stdout). int puts(const char* s); Writes s (excluding terminating NUL) and a newline to stdout. Returns non-negative on success, EOF on error. int feof(FILE* stream); Returns non-zero if end-of-file indicator is set for stream stream

44 stdlib.h RAND_MAX Maximum value returned by rand(). NULL
Null pointer constant. int abs(int n); long labs(long n); Returns absolute value of n. double atof(const char* s); ir double strtod(const char* s, char** endp); Converts initial characters (ignoring leading white space) of s to type double. If endp non-null, stores pointer to unconverted suffix in *endp. long atol(const char* s); ir long strtol(const char* s, char** endp, int base); Converts initial characters (ignoring leading white space) of s to type long. void* calloc(size_t nobj, size_t size); Returns pointer to zero-initialised newly-allocated space for an array of nobj objects each of size size, or NULL on error.

45 stdlib.h void* malloc(size_t size);
Returns pointer to uninitialised newly-allocated space for an object of size size, or NULL on error. void* realloc(void* p, size_t size); Returns pointer to newly-allocated space for an object of size size, initialised, to minimum of old and new sizes, to existing contents of p (if non-null), or NULL on error. On success, old object deallocated, otherwise unchanged. void free(void* p); If p non-null, deallocates space to which it points. void exit(int status); Terminates program normally. int rand(void); Returns pseudo-random number in range 0 to RAND_MAX

46 string.h NULL Null pointer constant.
char* strcpy(char* s, const char* ct); Copies ct to s including terminating NUL and returns s. char* strcat(char* s, const char* ct); Concatenate ct to s and return s. int strcmp(const char* cs, const char* ct); Compares cs with ct, returning negative value if cs<ct, zero if cs==ct, positive value if cs>ct.

47 time.h struct tm Represents the components of calendar time:
int tm_sec; seconds after the minute int tm_min; minutes after the hour int tm_hour; hours since midnight int tm_mday; day of the month int tm_mon; months since January int tm_year; years since 1900 int tm_wday; days since Sunday int tm_yday; days since January 1 int tm_isdst;

48 limits.h CHAR_BIT number of bits in a char CHAR_MAX
maximum value of type char CHAR_MIN minimum value of type char SCHAR_MAX maximum value of type signed char SCHAR_MIN minimum value of type signed char UCHAR_MAX maximum value of type unsigned char SHRT_MAX maximum value of type short

49 limits.h SHRT_MIN minimum value of type short USHRT_MAX
maximum value of type unsigned short INT_MAX maximum value of type int INT_MIN minimum value of type int UINT_MAX maximum value of type unsigned int LONG_MAX maximum value of type long LONG_MIN minimum value of type long ULONG_MAX maximum value of type unsigned long

50 Masyvai C kalboje perduodant masyvus funkcijoms yra perduodama ne pati duomenų struktūra, o tik rodyklė į ją, t.y. nurodant masyvo pavadinimą iš tikrųjų turime omeny rodyklę į pirmą masyvo elementą. Dėl šios priežasties visi pakeitimai daromi kitose funkcijose su reikalingo masyvo elementais yra “matomi” funkcijose kurioje masyvas buvo apibrėžtas ar kuriai masyvas yra perduodamas. Išvada – masyvo grąžinti iš funkcijos nereikia.

51 Masyvai Perduodant masyvą funkcijai kartu prasminga perduoti ir jo elementų kiekį: int suma (int masyvas[], int kiekis) { int i, suma; for (i=0; i<kiekis; i++) suma+=masyvas[i]; return suma; } int main() int mas[10], kiekis=10; … printf (“Masyvo elementų suma lygi %d”, suma(mas, 10));

52 duomenu_tipas *vardas;
Rodyklės – kas tai? Kintamasis tai objektas turintis vardą ir kintančią reikšmę. Kintamajam išskiriama atmintis, kurios dydis priklauso nuo tipo. Kintamojo reikšme gali būti adresas. Rodyklės tipo kintamasis apinrėžiamas taip: duomenu_tipas *vardas; pvz.: int *ptr; char *eilute; Teoriškai rodyklė galėtų “rodyti” į bet kokią atminties vietą, bet praktiškai rodyklė “rodo” į adresą kuriuo saugomas nurodyto tipo objektas.