You are on page 1of 26

1

Funkcij e
Potprogrami:
• dekompozicija složenih problema
na jednostavnije
• procesna apstrakcija
• samo funkcije (nema procedura)
• funkcija - n-arni operator
najvišeg prioriteta
• vraa rezultat (preko imena) +
bo#ni efekti, oboje opciono
Definisanj e funkcij a
[tip] ime(argumenti) telo
ime funkcije
• identifikator
tip funkcije
• mogu svi standardni skalarni tipovi,
kao i korisni#ki definisani tipovi
• void – funkcija ne vraa vrednost
• podrazumevani tip - int
Definisanj e funkcij a
tip funkcije
• ako * ispred imena – vrednost
funkcije je pokaziva# na objekat
navedenog tipa
• može i generi#ki pokaziva# (void *),
pokaziva# na pokaziva#, ...
• vrednost mora da bude
samo jedan objekat
(zato tip ne može biti niz)
ali može pokaziva#
Definisanj e funkcij a
argumenti funkcije
• formalni (u definiciji)
• stvarni (u pozivu)
• unošenje vrednosti i
iznošenje rezultata
• proizvoljan broj argumenata
razdvojenih sa ,
• definišu kao i promenljive,
ali tip i kvalifikator za svaki posebno
(npr. double x, double y)
2
Definisanj e funkcij a
argumenti funkcije
• argument može da bude niz
zadatog tipa ili
pokaziva# na dati tip (int *a)
• za 1-D niz ne mora dužina, samo []
(int a[])
• za n-D moraju se navesti dužine za
sve dimenzije osim za prvu
(int b[][5])
Definisanj e funkcij a
kvalifikatori ispred oznake argumenta
tipa pokaziva#a ili niza
• const – funkcija nee da promeni
vrednost objekta na koji pokazuje
argument
• volatile – pokazivani objekt
može da promeni vrednost
mimo kontrole programa
nema efekta za druge tipove
Definisanj e funkcij a
telo funkcije
• blok: deklaracije + naredbe
(oboje opciono)
• promenljive lokalne za funkciju
• oblast važenja -
od mesta definicije do kraja funkcije
• inicijalizacija –
izrazi koji, osim konstanti,
mogu da sadrže i formalne argumente
Prenos argumenata
• formalni argumenti se smatraju
lokalnim promenljivima
• inicijalizuju se vrednostima
stvarnih argumenata
• vrednosti stvarnih argumenata
se ne mogu promeniti u funkciji
(prenos po vrednosti – by value)
3
Prenos argumenata
• iznošenje rezultata preko
argumenata pokaziva#kog tipa
• pokaziva# se ne menja
• menja se vrednost pokazanog
objekta (bo#ni efekat)
• indirektan pristup
Prenos argumenata
• skalarni - po vrednosti
• nizova - po referenci (adresi)
(ne prenose se vrednosti niza!)
• kako je indeksiranje prakti#no
indirektno adresiranje
nije potrebna posebna notacija
za pristup komponentama
Definisanj e funkcij a
povratak iz funkcije
• naredba return
• argument – izraz
koji predstavlja vrednost funkcije
• ako je potrebno, konverzija tipa
Definisanj e funkcij a
povratak iz funkcije
• ako je funkcija tipa void,
return ne sme da ima izraz
• return može da se izostavi,
ako je poslednja naredba
• u funkciji može više naredbi return
4
Definisanj e funkcij a
mesto definisanja funkcije:
• ista ili druga datoteka
• ispred ili iza poziva
• ne može u okviru funkcije
Pozivanj e funkcij a
• ime funkcije (stvarni argumenti)
• može i adresni izraz
#ija je vrednost adresa funkcije
(preko pokaziva#a)
• operator najvišeg prioriteta (15)
Pozivanj e funkcij a
poziv se vrši
• u okviru izraza
• ako funkcija ne vraa vrednost ili
ona nije potrebna =>
poziv može i kao naredba
Pozivanj e funkcij a
stvarni argumenti pri pozivu
• izrazi proizvoljne složenosti i tipa
#ija vrednost inicijalizuje
formalne argumente
• izra#unavaju se proizvoljnim
redosledom pre pozivanja funkcije
5
Pozivanj e funkcij a
stvarni argumenti pri pozivu
• treba da se slažu po broju,
tipu i poretku sa formalnim
• po potrebi se konvertuju
u tip fomalnih
• mogu biti i adresni izrazi
(npr. ime niza i adresa)
Pozivanj e funkcij a
stvarni argumenti pri pozivu
• ako je stvarni argument niz izraza,
mora se staviti u zagrade
(zbog zareza)
ü na primer f(a,b,c) i f(a,(b,c))
Primer definisanj a
/* izra#unavanje skalarnog proizvoda */
#include <stdio.h>
double skal_pro(double a[], double b[], int n) {
double zbir = 0;
int i;
for (i=0; i<n; i++)
zbir += a[i] * b[i];
return zbir;
}

Primer pozivanj a
/* izraunavanje skalarnog proizvoda */
main () {
double x[100], y[100];
int i, k;
printf ("Duzina vektora:");
scanf ("%d", &k);

6
Pozivanj e funkcij a
/* izraunavanje skalarnog proizvoda */
printf ("Komponente vektora X:");
for (i=0; i<k; i++)
scanf ("%lf", x+i);
printf ("Komponente vektora y:");
for (i=0; i<k; i++)
scanf ("%lf", y+i);
printf ("skalarni proizvod X*Y:%g\n",
skal_pro(x,y,k));
}
Primer definisanj a
/* izraunavanje polarnih koordinata */
#include <stdio.h>
#include <math.h>
void polar (double x, double y, double *pr, double *pfi)
{
*pr = sqrt(x*x + y*y);
*pfi = (x==0 && y==0)? 0 : atan2(y,x);
}
...
Primer pozivanj a
/* izraunavanje polarnih koordinata */
main () {
double x, y, r, fi;
while (printf("x, y :"),
scanf("%lf%lf",&x,&y)!=EOF) {
polar(x,y,&r,&fi);
printf ("r, fi: %g,%g\n",r,fi);
}
}
Obrada programskog sistema
• #itav programski sistem
se sastoji od proizvoljnog broja
funkcija
• glavni program –
funkcija main() koju poziva OS
7
Obrada programskog sistema
• može u više datoteka,
ali jedna funkcija mora
u celini unutar datoteke
• poredak smeštanja funkcije
proizvoljan
Obrada programskog sistema
prevoenje
• svaka datoteka odvojeno i
nezavisno
• svaki objekt mora biti
unapred deklarisan
po poretku linija izvornog teksta
Obrada programskog sistema
prevoenje
• ako je funkcija kasnije definisana
(ili izvan datoteke), pre poziva
se mora navesti prototip
Obrada programskog sistema
prototip
• prakti#no zaglavlje funkcije
(bez bloka)
• navodi spolja vidljive osobine
funkcije (tip kao i argumente),
ali ne i sadržaj
8
Obrada programskog sistema
prototip
• ne rezerviše prostor
• jednom naredbom može
više funkcija
sa istim osnovnim tipom
Obrada programskog sistema
prototip
• argumenti mogu da se navode i
bez imena
(služe samo da sugerišu namenu)
• provera broja i tipova argumenata
nije obavezna po standardu
Obrada programskog sistema
prototip
• prototip može biti nepotpun
(bez argumenata)
• može i da izostane
(predpostavlja se int)
Obrada programskog sistema
prototip
• ako se piše u deklarativnom delu
funkcije, onda vidljiv samo u njoj
• može izvan tela drugih funkcija
(tada vidljiv za sve u nastavku)
9
Lokalne i globalne
promenlj ive
lokalne
• promenljive definisane
na po#etku tela funkcije
• važe samo unutar funkcije,
nevidljive za druge funkcije
• mogu ista imena u razli#itim
funkcijama - razli#ite promenljive
Lokalne i globalne
promenlj ive
globalne
• definišu se izvan funkcija
• oblast važenja –
od mesta definicije
do kraja datoteke
Lokalne i globalne
promenlj ive
globalne
• zajedni#ke za sve funkcije
samo izmeu mesta definicije
i kraja datoteke
• mogu služiti za prenos podataka
izmeu funkcija
Lokalne i globalne
promenlj ive
korišenje globalne promenljive
u funkciji gde nije automatski vidljiva
• obavezna deklaracija
(samo osobine)
• nema dodele prostora
i inicijalizacije
• koristi se službena re# extern ispred
10
Lokalne i globalne
promenlj ive
korišenje globalne promenljive
u funkciji gde nije automatski vidljiva
• kod nizova dovoljne samo zagrade,
ne moraju dimenzije
• ako je deklaracija u nekoj funkciji,
važi samo unutar funkcije
Lokalne i globalne
promenlj ive
korišenje globalne promenljive
u funkciji gde nije automatski vidljiva
• ako je izvan funkcije
važi do kraja datoteke
• redundantne deklaracije dozvoljene
(na po#etku datoteke i u funkciji)
Lokalne i globalne
promenlj ive
globalni identifikatori – spoljašnji
(po standardu bar 6 zna#ajnih slova)
kad lokalna i globalna imaju isto ime
važi lokalna u funkciji
Lokalne i globalne
promenlj ive
prenos podataka
preko globalnih promenljivih
• efikasniji nego preko argumenata
• manje fleksibilan
(svaki poziv obrauje iste
promenljive)
11
Lokalne i globalne
promenlj ive
/* primer prenosa podataka preko globalnih promenljivih */
/* jedna datoteka, 1 deo */
#include <stdio.h>
#include <math.h>
double x, y, r, fi;
void polar (void) {
extern double x, y, r, fi; /* redudantno */
r = sqrt(x*x+y*y);
fi = (x==0 && y==0)? 0 : atan2(y,x);
}
...
Lokalne i globalne
promenlj ive
/* primer prenosa podataka preko globalnih promenljivih */
/* jedna datoteka, 2 deo */
main () {
extern double x, y, r, fi; /* redudantno */
while (printf("x, y :"),
scanf("%1f%1f",&x,&y), x!=1e38) {
polar();
printf ("r, fi: %g,%g\n",r,fi);
}
}
Lokalne i globalne
promenlj ive
/* primer prenosa podataka preko globalnih promenljivih */
/* dve datoteka; prva datoteka */
#include <math.h>
extern double x, y, r, fi;
void polar (void) {
extern double x, y, r, fi; /* redudantno */
r = sqrt(x*x+y*y);
fi = (x==0 && y==0) ? 0 : atan2(y,x);
}
...
Lokalne i globalne
promenlj ive
/* primer prenosa podataka preko globalnih promenljivih */
/* dve datoteka; druga datoteka */
#include <stdio.h>
double x, y, r, fi;
void polar (void);
main () {
extern double x,y,r,fi;
while (printf("x, y :"),scanf("%1f%1f",&x,&y),x!=1e38) {
polar();
printf ("r, fi: %g,%g\n", r, fi);
}
}
12
Blokovska struktura
programa
svaka sekvenca se smatra blokom
može i da definiše promenljive
ü lokalne za blok i nevidljive izvan njega
ü važe od mesta definicije do kraja bloka
Blokovska struktura
programa
može i da definiše promenljive
ü ako je ime isto sa globalnom
promenljivom ova je nedostupna za blok
ü globalna za sve blokove unutar tog bloka
ü promenljive u obuhvatajuim blokovima
globalne za njega
Blokovska struktura
programa
#include <...>
int i, j, k; // int i, j, k;
char pp1 (...) {
float a, b, i; // int j, k; float a, b, i;
if (...) {
int j, a, x; // int j, k, a, x; float b, i;
for (..;..;..){
double a, j; // int k, x; float b, i; double a, j;
...
}
} else {
char j; // int k; float a, b, i; char j;
...
}
}
int e, h; // int i, j, k, e, h; char pp1;
...
Blokovska struktura
programa
...
int e, h; // int i, j, k, e, h; char pp1;
double pp2 (char k, ...) { // int i, j, e, h; char pp1, k;
char a, x, i; // int j, e, h; char pp1, i, k, a, x;
{
int h; // int j, e, h; char pp1, i, k, a, x;
...
}
{
long h; // int j, e; char pp1, i, k, a, x; long h;
...
}
}
// int i, j, k, e, h; char pp1; double pp2;
main () {
float x, y, z, i; // int j, k, e, h; char pp1; double pp2; float x, y, z, i;
...
}
13
Kategorij e promenlj ivih
prema na#inu korišenja
ü globalne
ü stati#ke
ü automatske
ü registri
odreuju se prefiksom u naredbi
za definiciju promenljive
Kategorij e promenlj ivih
globalne promenljive
• definišu se izvan funkcija
• njihova imena postaju jedinstvena
za #itavi programski sistem
• ako je izvorni program u više datoteka,
globalna promenljiva se:
ü definiše samo u jednoj datoteci
ü definiše sa extern u ostalim
Kategorij e promenlj ivih
globalne promenljive
• postoje za #itavo vreme izvršavanja
• mogu se inicijalizovati po#etnjim
vrednostima kao konstantnim izrazima
• ako se ne inicijalizuju, podrazumeva se 0
Kategorij e promenlj ivih
stati#ke promenljive:
• definišu se ili deklarišu sa static na
po#etku
• postoje do kraja programa
(vrednostise #uvaju izmeu poziva)
14
Kategorij e promenlj ivih
stati#ke promenljive:
• stati#ke definisane izvan funkcija su
lokalne za datoteku (vide se samo u njoj)
• stati#ke definisane unutar funkcije su
lokalne za funkciju
ü formiraju se na po#etku izvršavanja
ü inicijalizuju se eksplicitno ili se smatra 0
Kategorij e promenlj ivih
automatske promenljive
• definišu se samo unutar funkcija ili
blokova
• default za promenljive koje ne navode
prefiks (extern, static ili register)
• eksplicitno sa auto
Kategorij e promenlj ivih
automatske promenljive
• pri svakom pozivu se ponovo formiraju
• inicijalizacija
ü izrazima koji mogu da sadrže promenljive,
ali sa definisanim vrednostima
ü ako nema eksplicitne po#etnje vrednsoti,
onda slu#ajno
Kategorij e promenlj ivih
registri
• automatske promenljive za koje se želi
alokacija u registirma
• ne garantuje se
• prefiks register
• nedozvoljena primena adresnog
operatora
15
Pretprocesor j ezika C
• vrši pripremnu obradu izvornog
teksta programa
• posebne naredbe u posebnim
redovima i po#inju sa #
Pretprocesor j ezika C
vrši transformacije izvornog programa
• umetanje sadržaja tekstualne datoteke
na odreeno mesto
• zamena leksi#kih simbola
novim nizovima simbola
• uslovno uklju#ivanje ili izostavljanje
delova teksta
Pretprocesor j ezika C
umetanje sadržaja datoteke
• naredba #include sa zadatim imenom
datoteke
• ako je ime izmeu "" datoteka se trazi u
istom katalogu kao i izvorni program
• ako se ne nae ili je izmeu <>, traži se u
sistemskim katalozima
Pretprocesor j ezika C
umetanje sadržaja datoteke
• koristi se za duže sekvence
deklarativnih naredbi
• npr. deklaracije bibliote#kih
funkcija (zaglavlja - prototipovi) iz
sistemskog kataloga
16
Pretprocesor j ezika C
zamena leksi#kih simbola
• naredba #define zamenjuje
svako pojavljivanje identifikatora
zadatim nizom simbola
• naredba #undef identifikator poništava
efekt odgovarajue #define naredbe
Pretprocesor j ezika C
za definiciju makroa
• iza identifikatora u zagradama može da
bude niz argumenata odvojenih zarezima
• kao formalni argumenti koji se javljaju u
nizu iza zagrada
• stvarni argumenti u daljem tekstu -
proizvoljni nizovi simbola
Pretprocesor j ezika C
#define se može produžiti
u naredni red ako se na kraj stavi \
#define MAX_DUZ 1000
#define ZAUVEK for(;;)
#define MAX(A,B) ((a)>(b)?(a):(b))
Pretprocesor j ezika C
preporu#uje se stavljanje zagrada
oko svakog formiranog argumenta
u makrou, jer stvarni argument
može da sadrži operatore viših prioriteta
npr. zamena pri pojavi:
x=MAX(p+q, r+s);
17
Pretprocesor j ezika C
uslovno prevoenje:
#if izraz
prevodi do #else ili #endif ako je izraz taan
#ifdef ime
prevodi ako je ime prethodno def. sa #define
#ifndef ime
prevodi ako ime nije prethodno def. sa #define
#else
poetak alternativnog bloka
#endif
kraj uslovnog bloka
Rekurzivne funkcij e
Funkcije koje indirektno ili direktno
pozivaju same sebe
• svode se na rešavanje istog problema
sa promenljivim parametrima
• da bi konvergirao, postoje neke
specijalne nerekurzivne vrednosti
funkcije
Rekurzivne funkcij e
• pogodno za inherentno rekurzivne
algoritme (npr. faktorijel,
Fibonaccijevi brojevi, ...)
• manje efikasna od iterativnih
(po utrošku vremena ili memorije)
• otkrivanje grešaka
teže nego kod iterativnih
Rekurzivne funkcij e
Rekurzivno izra#unavanje faktorijela
• int fakt(int n) {
return (n>0) ? (n*fakt(n-1)):1;}
• N+1 puta se
ü poziva funkcija
ü inicijalizuje formalni argument
ü ispituje vrednost argumenta,
ü oduzima i množi, uklju#ui #uvanje i
obnavljanje steka
18
Rekurzivne funkcij e
Iterativno izra#unavanje faktorijela
• int fakt (int n) {
int i, f;
for (i=f=1; i<=n; f*=i++);
return f;
}
• mnogo efikasnije (nema poziva)
Pokazivai na funkcij e
• funkcije su objekti
na koje se može pokazivati
• sve uobi#ajene operacije su
dozvoljene nad takvim pokaziva#ima
Pokazivai na funkcij e
standardne naredbe za
definiciju promenljivih, npr.
• double (*pf)(float, int);
pokaziva# pf na funkciju tipa double
sa argumentima tipa float i int
• double *f(float, int);
prototip funkcije #ija je vrednost
pokaziva# na objekte tipa double
Pokazivai na funkcij e
pri pozivu
• *f(x, n)
prvo se poziva funkcija
(zbog višeg prioriteta),
a zatim indirektno adresiranje
• (*pf)(x, n)
prvo indirektno adresiranje na pokaziva# pf,
a zatim poziv funkcije
19
Pokazivai na funkcij e
identifikator funkcije sam za sebe (sli#no nizu)
predstavlja pokaziva# na tu funkciju
• npr. :
ü ako je double fct(float, int);
ü nakon pf = fct, pf pokazuje na funkciju fct
ü pa (*pf)(x,n) poziva funkciju fct()
Pokazivai na funkcij e
Primer:
/* program za tabeliranje realne funkcije realnog arg. */
#include <stdio.h>
void tabela (double (*pf)(double),
double x1, double x2, double dx) {
double x;
printf ("\n x f(x) \n");
for (x=x1; x<=x2; x+=dx)
printf("%20.10lf%20.10lf\n", x, (*pf)(x));
}
...
Pokazivai na funkcij e
/* glavni program za prikaz rada potrpograma */
main() {
double x1, x2, dx, oscilac(double);
printf("x1, x2, dx:");
scanf("%lf%lf%lf", &x1, &x2, &dx);
tabela (oscilac, x1, x2, dx);
}
...
Pokazivai na funkcij e
/* primer funkcije za tabeliranje */
#include <math.h>
double oscilac (double x)
{
return exp(-0.1*x)*sin(x);
}
Prvi argument potrpograma tabela –
pokaziva pf na funkciju koja se tabelira
njen poziv sa (*pf)(x)
20
Argumenti glavnog programa
• pri startovanju C programa,
u istoj komandi OS
mogu se predati parametri
glavnom programu
• glavni program se iz OS-a
poziva kao funkcija
sa dva argumenta
Argumenti glavnog programa
void main (const int argc, char * argv[])
• argc - broj parametara u komandi
uklju#ujui i samu komandu
• argv - niz pokaziva#a dužine argc+1
na znakovne nizove (re#i iz komande)
poslednji pokaziva# argv[argc] = NULL
Argumenti glavnog programa
Npr. komanda echo
/* program ia ispisivanje poruke na ekranu */
#include <stdio.h>
main (int argc, char * argv[]) {
int i;
for (i=1; i<argc; i++)
printf ("%s%c",argv[i],
(i<argc-1)?(' '):('\n'));
}
Argumenti glavnog programa
Pisanje funkcija po staroj notaciji
ü unutar zagrada samo imena argumenata
ü tipovi argumenata ispred tela
u posebnim naredbama
ü za funkcije bez argumenata se ne piše void
ü prototip samo tip (ne i argumente)
i piše se izvan funkcija
21
Funkcij e sa promenlj ivim broj em
argumenata
• Pozvana funkcija sama mora otkriti
broj i tipove prosleenih
argumenata
• Primer: scanf, printf mogu na
osnovu formata prebrojati
konverzije koje po#inju sa %
• Dakle, obavezni argument mora
sadržati informaciju koliko ima
neobaveznih
Funkcij e sa promenlj ivim broj em
argumenata
• Postoji alat za bezbedno
dohvatanje neobaveznih
argumenata
• Da bi se koristio, mora:
#include <stdarg.h>
• Sadrži makroe:
va_list, va_start, va_arg i va_end
Funkcij e sa promenlj ivim broj em
argumenata
• Prvo se definiše pokaziva# na prvi
neobavezni argument:
va_list pok_arg;
• Zatim se postavi po#etna vrednost
pokaziva#a navoenjem imena
pokaziva#a i imena poslednjeg
obaveznog argumenta:
va_start (pok_arg, posl_arg);
Funkcij e sa promenlj ivim broj em
argumenata
• Uzastopni neobavezni argumenti se
dohvataju pozivajui:
va_arg (pok_arg, tip);
gde se za svaki navodi tip argumenta
• Završetak dohvatanja argumenta se
ozna#ava naredbom:
va_end (pok_arg);
22
Primer: zbir promenlj ivog broj a
argumenata
#include <stdarg.h>
int zbir (int n, ...) {
int s,i; va_list pa; va_start (pa,n);
for (s=i=0; i<n; i++)
s+=va_arg(pa, int);
va_end(pa);
return s;
}
Primer: zbir promenlj ivog broj a
argumenata
#include <stdio.h>
void main() {
printf (“1+2= %d\n”, zbir(2,1,2));
printf (“1+2+3= %d\n”,
zbir(3,1,2,3));
}
Biblioteke funkcij e
• najviši prioritet operatora
• poredak izra#unavanja argumenata
proizvoljan
• standardne biblioteke
(za #esto korišene obrade)
• #include <ime_biblioteke>
Funkcij e za itanj e
i pisanj e znakova
#include <stdio.h>
za nizove znakova:
ü printf()
ü scanf()
ü gets(s)
ü puts(s)
23
Funkcij e za itanj e
i pisanj e znakova
za pojedina#ne znakove:
• int getchar()
vraa kod unesenog znaka
ili konstantu EOF
(za kraj datoteke ili grešku)
• int putchar(c)
ispisuje znak na ekranu
vrednost funkcije je kod ispisanog znaka
ili EOF za grešku
Funkcij e za
ispitivanj e znakova
#include <ctype.h>
ispituju vrstu znaka
ü tip argumenta c – char
ü vrednost funkcije – logi#ka vrednost
Funkcij e za
ispitivanj e znakova
isalnum (c)
slovo ili cifra
isalpha (c)
slovo
iscntrl (c)
upravlja#ki znak
isdigit (c)
decimalna cifra
isgraph (c)
štampajui znak (osim razmaka)
Funkcij e za
ispitivanj e znakova
islower (c)
malo slovo
isprint (c)
štampajui znak uklju#ujui razmak
ispunct (c)
specijalan znak
isspace (c)
beli znak
isupper (c)
veliko slovo
isxdigit (c)
hexa cifra
24
Funkcij e za rad sa
znakovnim nizovima
#include <string.h>
umesto operatora
za rad sa znakovnim nizovima
=> standardne funkcije
argumenti:
ü t, s – znakovni nizovi
ü n - int
Funkcij e za rad sa
znakovni nizovima
• strcpy (t, s)
prepisuje niz s u niz t
uklju#ujui i završni znak
vrednost funkcije: niz T
• strncpy (t, s, n)
prepisuje najviše n znakova iz s u t
ako ih je manje, dopunjava \0
do dužine n
vrednost funkcije: niz t
Funkcij e za rad sa
znakovni nizovima
• strcat (t, s)
dopisuje s na kraj t
vrednost funkcije: niz t
• strncat (t, s, n)
dopisuje najviše n znakova is s na kraj t
vrednost funkcije: niz t
Funkcij e za rad sa
znakovnim nizovima
• strcmp (t, s)
uporeuje nizove t i s
(po vrednosti koda znakova)
rezultat int:
•negativno => t ispred s
•pozitivno => s ispred t
•nula => t==s
• strlen (s)
vraa dužinu niza (ne ubraja završni znak)
rezultat int
25
Matematike funkcij e
#include <math.h>
vrednosti funkcija – double
argumenti:
ü x, y – double
ü n - int
Matematike funkcij e
• sin (x)
• cos (x)
• tan (x)
• asin (x) – x iz [-1, 1]
• acos (x) – x iz [-1, 1]
• atan (x) – x iz [-/2, /2]
• atan2 (x, y) – atan (x/y); x iz [-, ]
Matematike funkcij e
• sinh (x)
• cosh (x)
• tanh (x)
• exp (x) - e
x
• log (x) – logaritam (osnova e)
• log10 (x) – logaritam (osnova 10)
Matematike funkcij e
• pow (x, y) - x
y
• sqrt (x) – kvadratni koren
• ceil (x) – najmanji ceo broj vei od x
• floor (x) – najvei ceo broj manji od x
• fabs (x) – apsolutna vrednost
26
Matematike funkcij e
• ldexp (x, n) – x*2
n
• frexp (x, &n)
ü vraa normalizovanu mantisu od x
u opsegu [0.5, 1)
ü n vraa binarni eksponet
• modf (x, &y)
ü vraa razlomljeni deo x
(sa predznakom)
ü y je celobrojni deo sa predznakom
• fmod (x, y)
ü ostatak realnog deljenja x/y sa predznakom x
Uslužne funkcij e
#include <stdlib.h>
funkcije razli#ite namene
• rand ()
vraa pseudoslu#ajni int
iz opsega [0, RAND_MAX]
• srand()
postavlja po#etnju vrednost
sekvence slu#ajnih brojeva (def. 1)
Uslužne funkcij e
• atof (s) – konverzija realnog broja iz
znakovnog niza u double
• atoi (s) – konverzija celog broja iz
znakovnog niza u int
• atol (s) – konverzija celog broja iz
znakovnog niza u long int
s – znakovni niz
preska#u se eventualni “beli” znaci
sa po#etka niza
zaustavlja se na prvom znaku
koji nie deo broja
Uslužne funkcij e
• abs (n)
apsolutna vrednost
tip rezultata i argumenta int
• labs (n)
apsolutna vrednost
tip rezultata i argumenta long int
• ...