Singidunum Uvod U Programski Jezik C PDF

C
(C programming Language)
C ........................................................................................................................ 2
........................................................................................................................ 2
(debuging) ................................................................................................. 4
C ..................................................................................................................... 5
C....................................................................................................................... 6
...................................................................................................................... 6
........................................................................................................................ 8
, ................................................................................. 8
...................................................................................................................... 9
C
C 1970- (Bell Labs),
UNIX. UNIX
.
(assembly language).
(COBOL, FORTRAN, PL/I, ALGOLl...)
, .
C , , : ALGOL
BCPL.

ao ,
(text editor). ext editor
o . ext editor
(notepad, wordpad )
(urbo C, Borland C, Microsoft Visual Studio ...).
(instructions, statements)
(Code Source code). Source file.
C (function).
(.
, , ...).
. . , ...

? ! ,
,
. imeprog.c (main.c,
povrsina.c, tx_modem.c, ...). ,
,
.

(project file). , , ( )
.
, ( .exe),
.
(Compiler).
:
1. : (Preprocessing)
preprocessor.
( RAM-) a (preprocessor directives)
. .
.
, .
(comments) (white space) .
, , !
2. : (Compilation)
(compiler)
, ,
(object code). (machine code).
(errors)
(warnings), .
,
( .obj).
, .
(warnings).
.
:
(Syntax error): ,

/ .
(Logic error): ,
. .
. !

3. : (Linking)

. ( ),
(executable file, .xe).
. (Libraries, RunTime Library) .
. MS-DOS Windows
EXE.
,
RAM-
filename1.c
filename2.c
...
filenameN.c

project_filename.prj
filename1.obj
filename2.obj
filename1.obj
filename1.obj
...
filenameN.obj
...

.exe
filenameN.obj
1.
! .
(debuging)
deBUGing je (bug). ,
, .
, Grace Hopper .
. ,
( ). Grace Hopper
COBOL, ( )
(computer bugs).
(debug),
(bug) .
C
C (free-form language)
(.
FORTRAN COBOL). (white
space). .
:
)
#include <stdio.h>
/* Moj prvi C program koji ispisuje: "Zdravo!" */
int main(int argc, char *argv[]){
printf("Zdravo!\n");
}
return 0;
)
#include <stdio.h>/* Moj prvi C program koji ispisuje: "Zdravo!" */
int main (int argc, char *argv[]){printf("Zdravo!\n");return 0;}
)
#include <stdio.h>
/* Moj prvi
C koji ispisuje:
"Zdravo!" */
int
main
(int
argc
,
char
*argv[]
){
printf(
"Zdravo!\n"
)
;
return
0
;
}
, ) . C
. ,
, , ).
, ?
(
) .
,
. .
, .
) .
() .
M C ( )
( . , : ; ).
() , ,
.
#include ( )
< stdio.h, stdio.h >.
,
\ (backslash).
:
printf("Ovo je veoma, veoma, \
veoma, veoma,duga linija.");
. , C
(case sensitive). C ,

.
C
, .
() .
C

Aa Bb Cc Dd Ee Ff Gg Hh Ii Jj Kk Ll Mm Nn Oo Pp Qq Rr Ss Tt Uu Vv Ww Xx Yy Zz

0123456789
: : _ ! ? . , : ; = + - / * # % & \ | ( ) [ ] { } < >
,
. .
C :

() (, ,
, ...).
:
1.
:
( )

( _ )
2.
() .
! ( ).
3.
( , , _ ) !
, 31
, .
.
:
JednaPromenljivaKojaImaKarakteraJakoPuno = 1
JednaPromenljivaKojaImaKarakteraSamoJedanVise = 3

JednaPromenljivaKojaImaKarakte.
.
4.
C (Rezultat rezultat )
5.
31 31
( ).
:
a)
suma
c5_4
JEDAN_BROJ
dugoimesamnogokaraktera
TRUE
_split_name
NovoIme
novo_ime
Broj_studenata
Broj_Studenata
TX_protocol
UporediRezultat_sabiranja
)
70fd
x-name
ime sa razmakom
int
axx&
Povrina*kruga
jedan,dva

-

&
*
,

,
.
( 32):
auto
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
int
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while
:
(6) if, else, return, switch, case, default
(5) for, do, while, break, continue
(5 + 7) int, float, double, char, void
extern, signed, unsigned, long, short, static, const
(3) struct, typedef, union
(2) enum, sizeof
( !) (1) goto
(3) auto, register, volatile
,
.
, .
:

.
:

.
()
.
, ,
,
. (variable).

.
. () .
:
#define PI=3.14;
#define MIN_RASTOJANJE=2;
#define Broj_Semestara=8;
/*ne preporuuje se upotreba malih slova za simbolicke

konstante*/
:
1. #define
2. ,
() .
,
( ).
?
. (),
() (. x=a+b).
,
C- ,
.

, .
: racun bill xyz, r .

, . ,
PocetnaCena pocetna_cena,
(Pocetna_Cena) ,
PocetnaCena pocetna_cena.
, . broj_kola broj_koka.
.
.
() .
,
. , (
) .
.
( ) .
( ) ,
.

()
.
C ,
.
:
int
int , (signed),
. signed signed int
int. int + () () .
(: 2, -30211, 0, +28). + .
int
. int (word size)
16- (2 ), 32 (4 ). 16
int -32 767 32 768
( ) 65 536 . 16
(2 ) int 2 .
int
32 (4 ): 2 147 483 648 2 147 483 647.
int (.
6 632 343 000) : (overflow error).
signed, unsigned, short
long. : (signed) short int, unsigned short int, (signed) long
int, unsigned long int,
short int
( ) int.
long int
( ) int.
: short int, int long int
. (short long), int
.
( )
unsigned . unsigned short int
unsigned int unsigned long int.
char
char ( character,
) 8 (1 ). ,
128 128.
unsigned unsigned char 0 255.
(: ASCII 256 ).
, char, , , A?
65 ( 1000 0001) ASCII .

C : float, double long double
T float , double
, long double . int, double
float long double double.
10

.

C , (
16) ( 8) .

:
0123
83
0x 0X
0x123
291
, , int
. long int. l L
long int.
:
974
int
0x2fc
int
974l
long int
01234L
long int
+ ().
(
). .
u U unsigned int.
0xffff
0xffffu
0723
0723u

.
mEe m e
:
2.54-34 2.54 10-34
double, float f
F.
11

1.23
125.
.456
35
2.1-45
22.3F
12
C
2
.................................................................................................................................. 2
................................................................................................. 3
.......................................................................................................................... 3
printf().............................................................................................................................. 4
scanf() ................................................................................................................................. 6
..................................................................................................................................................... 8
.......................................................................................................................... 8
.................................................................................................................... 9
( ) ..................................................................................... 10
................................................................................................................................ 10
......................................................................................................................... 11
................................................................................................................................... 11
......................................................................................................................................... 12
.......................................................................................................................................... 12
.......................................................................................................... 13

() !
:
tip_podatka ime_podatka;
tip_podatka ime_podatka = poetna_vrednost;

:
tip_podatka: (int, long int, float, char,...).
- .
ime_podatka: .
( 1: )
poetna_vrednost .
.
,
.
: , .
:
tip_podatka ime_podatka [ = poetna_vrednost] ;
:
short int broj1;
short int broj2=34;
char slovo;
float a=5.43,
float b=12.65;
int visina=34/2;
float povrsina=a*b;
int visina=34/2; ( ).
povrsina (
), (a b),
.
,
:
tip_podatka ime_podatka[=poetna_vrednost],...,ime_podatka [= poetna_vrednost];
:
int broj=2, prisutni=0, godiste=2004, br_casova;
.

.
:
const

const tip_podatka ime_podatka = poetna_vrednost;
:
const double e=2.71828182845905;
const int br_radnih_dana=26;
const float radijus=14;
const float cena=14.2, porez=0.22;
/* i porez je konstanta*/
const float obim=2*radijus*3.14;

. ,
, .
. a () a
() a. (
) .
, , (character).
,
.

() scanf()
, .
.
printf().
C
( ) scanf() printf() stdio.h.
stdio standard input output a .h header (),
. scanf() / printf()
stdio.h .
#include <stdio.h>.
: stdio.h < >
.
,
#include c:\nekoime.h.
< > ,
.
printf()
printf() :
printf("Ovo je jednostavna poruka")

Ovo je jednostavna poruka
!
( f formated).
:
printf(format,izraz,...,izraz)
izraz ,
format :
%[Sirina][.Prec]Tip_kon
Tip_kon :
Tip_kon

----------------------------------------------------------------------------------------------------i
int
o
d
int
o
u
int

o
int

x
int
abcdef
X
int
, ABCDEF
c
int
(ASCII)
e
float
,
f
float

g
float
f e

Tip_kon.
:
printf(%c, A);
:
printf(%c %d, A, 35);

:
35
c %d.
printf(%c%d A, 35);
:
35
ov .
printf(%c %d %f, A, 35, 4.5);
:
35 4.50000
printf(%c %d %, A, 35, 42.123);
:
35 4.212300+001
.Prec ( : e, f g)
f .
6.
g . .
:
printf(% 42.126);
: 4.212600+001
printf(4 42.126);
: 4.2126+001
printf(3 42.126);
: 4.213+001
printf(%f, 42.126);
: 42.126000
printf(7f 42.12345678);
: 42.1234568
printf(%.2f, 42.126);
: 42.13
printf(%g, 42.126);
: 42.126
printf(%.7g, 42.12345678);
: 42.12345
.
printf(%.2g, 42.126);
: 42
printf(%.2g, 142.126);
: 1.4+002
Sirina .
. Sirina
() .
Sirina 0 , , .
:
("%2c %3d %10f\n", 'A', 35, 42.126);
printf("%02c %03d %010.3f\n", 'A', 35, 42.126);
printf("%c %d %2f\n", 'A', 35, 242.127456789);
:
35 42.126000
35
42.1260000
, 35,
10 : , ,

0 035 00042.126
35 242.127456
, , escape :
\a
\\
\?
\
\
\b
\f
\n
\r
\t
\v

\
?

(backspace)
(formfeed)

(carriage return)
(tab)
(tab)
:
printf("%c\n\t%d\n%f\n", 'A', 35, 42.126);
:
35
42.126000
/* \n je znak za novi red*/

/* \t je znak tab, 35 je pomeren u desno*/
scanf()
:
scanf(format,&podatak,...,&podatak)
podatak , ,
.
O & scanf()
() .
format printf().
:
#include
main()
{
char
int
float
<stdio.h>
cVar;
dVar;
fVar;
scanf("%c %d %f", &cVar,&dVar, &fVar);

printf("\n%c \n%d \n%f\n",cVar, dVar, fVar);
:
(. F) ,
(. 32)
(. -67.5092).
ENTER !
A .
.
.

.

. .
#include <stdio.h>
main()
{
int x;
char c;
float y;
scanf("%d %c %f", &x, &c, &y);
printf("\n%d \n%c \n%f\n",x, c, y);
scanf("%d", &x);
printf("Da li sam cekao za drugi unos?\n");
printf("\n%d\n",x);
}

.
:
+
%

!
:
#include <stdio.h>
main()
{
int x=5;
int y=2;
float z;
z=x/y;
}
z 2.
:
10%2 0 10/2=5 0
15%7 1 15/7=2 1
: +, ( , ...)
. + .
: ++,
++ 1 (increment).
1 (decrement).

=+1;
=-1;
:
++;
/* odgovara naredbi =+1; */
++;
/* odgovara naredbi =+1; */
--;
/* odgovara naredbi =-1; */
--;
/* odgovara naredbi =-1; */
e
.
. , (++ )
( )
.
,
.
:
int broj_a, broj_b, broj_c, broj_d;
broj_a=3;
broj_b=6;
broj_c= broj_b++;
broj_c= ++broj_a;
broj_d= broj_b;
/* broj_c je jednak 6 a nakon toga

se poveava b na 7*/
/* prvo se broj_a povea na 4 a potom
je broj_c jednak 4*/
/* broj_d je jednak 7*/

C- .
= , : +=, - =, *=, /= %=
:
ime_promenljive [op]= izraz; /* gde je op jedan od +, - , *, /
ili
*/
(
) .
broj_a=3;
broj_b=6;
broj_c= broj_b + broj_b
a=+1;
a+=b;
/* isto je sto i a=a+b
a-=b;
/* isto je sto i a=a-b
*/
*/
a*=b;
/* isto je sto i a=a*b
a/=b;
/* isto je sto i a=a/b
a%=b;
/* isto je sto i a=a%b
a=b=c=27;
*/
*/
*/
27. c
27, b c
a b.
( )
.
/ (True/False) .
:
>

a
<

a
>=

a
<=

a
==
a
!=

a
> b
< b
>= b
<= b
== b
!= b
(int) 1 0
.
3.1 != -3.1
5.2 >= 6
7<= 7
0.5 == 4.2
a != 5
/*
/*
/*
/*
/*
rezultat
rezultat
rezultat
rezultat
rezultat
1 */
0 */
1 */
0 */
zavisi od vrednosti promenljive a */

C :
!
&&
||
.
:
izraz1
!(izraz1)
izraz1
izraz2
izraz2 && izraz2
razliit od 0
razliit od 0
razliit od 0
razliit od 0
razliit od 0
10
izraz1
izraz2
izraz2 && izraz2
razliit od 0
razliit od 0
razliit od 0
razliit od 0
:
10 100
(10<) && (<100) /* Ako je a>10 i a<100 vrednost izraza je 1,
u suprotnom 0*/
15
( <-15) || (>15) /* ako je a<-15 ili a>15 vrednost izraza je 1,
u suprotnom 0 */
<<
>>
&
(exor)
:
0x1234 & 0x5678
/* 0001 0010 0011 0100 & 0101 00110 0111 1000 = 0x1230 */
0x1234 | 0x5678
/* 0001 0010 0011 0100 | 0101 00110 0111 1000 = 0x567c */
0x1234 ^ 0x5678
/* 0001 0010 0011 0100 ^ 0101 00110 0111 1000 = 0x444c */
~0x1234
/* ~ 0001 0010 0011 0100
0x0001<<5
= 0xedcb
*/
/* 0000 0000 0010 0000*/

,
sizeof.
:
sizeof(
sizeof(
sizeof(
sizeof(
short int);
long int);
broj_a);
broj_a*broj_b-3);
11

uslov ? izraz1 : izraz2
uslov.
uslov izraz1
( izraz2
) .
uslov 0 izraz2
.
:
c a b,
c b
c= (a>b) ? a : b;
c y
x z, c
(x+z)/2
c=(x<=y && y>=z) ? y : (x+z)/2

C .
,
.
.
5+6.0
/* isto sto i 5.0+6.0*/
5/4+3
/* 5/4 zbog celobrojnog deljenja je 1 pa je rezultat 4*/
3.0*5/4
/* (3.0*5)/4, zbog automatske konverzije (3.0*5) postaje (3.0*5.0)

pa sledi 15.0/4 sto zbog automatske konverzije
postaje 15.0/4.0. Rezultat je 3.75 */
,
. cast-. :
(novi_tip) izraz
novi_tip C izraz
.
:
int a;
...
(char)a; /* pretvara int promenljivu a u tip char*/
float x;
double y;
y=sin((double)x);
/* parametar funkcije sinus mora biti tipa double */
12

.

.
13
C
3
........................................................................................................................................................................2
O .................................................................................................................................2
...................................................................................................................................3
(scope).............................................................................................3
().................................................................................................................................7
if else ...............................................................................................................................................7
switch ...............................................................................................................................................12
( ).........................................................................................................15
while ....................................................................................................................................................15
for-..........................................................................................................................................................16
do while ...............................................................................................................................................18
...................................................................................................................................................................19
break..................................................................................................................................................19
continue ...........................................................................................................................................20

.
a , (),
.
:
() if-else switch .
, .
e (, ) for d .
.
C :
1.
2.
3. ()
if else
switch
4. () :
while
for
do while
4.
break
continue
5. goto
6. return
O
; ( )
C. :
izraz;
:
Visina=5;
printf("%d \n", Visina);
broj b--;
.
- ; .

.
, ,
.

. .
{ } :
{ izraz1; izraz2; ... izrazN;}
izraz1;
izraz2;
...
izrazN;
(. )

, , !
, , , ,
.
(scope)

, . .
, . ,
(
). .
.

main()
{
int prom1=1;
double prom2=3.22;
double prom3= prom2 + 5.92;
prom1+=32;
prom3= (double)prom1*54.76;
}
printf("%d\n %f\n", prom1, prom3);
:
33
1807.080000
main(), ,
. : prom1, prom2
prom3. ( })
main().
,
:
main()
{
int prom1=1;
/* GRESKA */
/* error C2065: 'prom2': undeclared identifier */
double prom2=3.22;
...
}
prom2 prom3
prom2 .
,
(nested blocks).
:
main()
{
int prom1=1;
double prom2=3.22;
prom1+=32;
...
{
prom1 *=4;
prom2= prom2*prom2;
...
}
}
/* pocetak unutrasnjeg bloka*/
/* kraj unutrasnjeg bloka*/
printf("%d %f\n", prom1, prom3);
() .
.
,
. !
.
:
main()
{
int prom1=1;
double prom2=3.22;
prom1+=32;
{
int prom4;
/* pocetak unutrasnjeg bloka*/

/* Lokalna promenljiva*/
prom4=76;
prom1 *=4;
prom2= prom2*prom2;
}
/* kraj unutrasnjeg bloka*/
printf("%d \n", prom4); /* Greska */

/*error C2065: 'prom4' : undeclared identifier */
,
( printf()
).

o ( )!
.
:
/* Prikaz lokalnih promeljivih unutar bloka */
#include <stdio.h>
main()
{
/* Definisanje promenljive lokalne za funkciju main(). */
int count = 5;
printf("\nVrednost promenljive u spoljasnjem bloku, count = %d", count);
/* Pocetak unutrasnjeg bloka */
{
/* Definisanje promenljive lokalne za unutranji blok */
int count = 999;
printf("\nVrednost promenljive u unutrasnjem \
bloku, count = %d",count);
}
}
:
printf("\nVrednost promenljive u spoljasnjem bloku, ponovo, \

count = %d\n", count);
Vrednost promenljive u spoljasnjem bloku, count = 5
Vrednost promenljive u unutrasnjem bloku, count = 999
Vrednost promenljive u spoljasnjem bloku, ponovo, count = 5
count
count .
count int 5. count

main(), main().
printf 5.
count int 999. printf
999. , printf count
main().
#include <stdio.h>
main()
{
/* Definisanje promenljive lokalne za funkciju main(). */
int count = 5;
printf("\nVrednost promenljive u spoljasnjem bloku, count = %d", count);
/* Pocetak unutrasnjeg bloka */
{
/* Definisanje promenljive lokalne za unutranji blok */
double count = 99.888;
printf("\nVrednost promenljive u unutrasnjem bloku, \
count = %f", count);
}
printf("\nVrednost promenljive u spoljasnjem bloku, ponovo, \
count = %d\n", count);
}
:
Vrednost promenljive u spoljasnjem bloku, count = 5

Vrednost promenljive u unutrasnjem bloku, count = 99.888000
Vrednost promenljive u spoljasnjem bloku, ponovo, count = 5
,
.
, ,
C .
.
.
,
.
()
.
. ,
, .
if
: .
if else
:
if(izraz1)
{
naredbe
}
else if(izraz2)
{
naredbe
}
else if(izraz3)
{
naredbe
}
...
else
{
naredbe
}
a)
if(izraz1){naredb1; naredb2; ... naredbN; }

if(izraz1)
{
naredb1;
naredb2;
...
naredbN;
}
if izraz1 .
( ")
naredb1, naredb2,..., naredbN.
naredb1, naredb2,..., naredbN.
izraz1, if ,
:
==
x == y
x j y
!=
x != y
x j y
>
>
x>y
x j y
<
<
x<y
x j y
>=
x >= y
x j y
<=
x <= y
x j y
:
(==, !=, >= <=) ,
.
(x = 5, o x
5) (x == 5, o x
5).
:
if(b>=3)
{
b=1;
count = 45.32;
slovo = 'A';
}
:
if(izraz1)naredb1;

if(izraz1)
naredb1;
:
b=1;
if(>5)b=3;
: br :
if(br != 0) if(br)
if(br == 0) if(!br)
if
. if printf
if
:
int main()/* pocetak programa pocinje funkcijom main */
{
int num1; /* prvi broj koji korisnik treba da unese */
int num2; /* drugi broj koji korisnik treba da unese */
printf( "Unesite dva cela broja i ja cu Vam reci\n" );
printf( "u kom su oni odnosu: " );
scanf( "%d%d", &num1, &num2 ); /* citaju se dva cela broja */
if(num1 == num2)
{
printf( "%d je jednak sa %d\n", num1, num2);
}/* kraj if naredbe */
if(num1 != num2)
{
printf("%d nije jednak sa %d\n", num1, num2);
} /* kraj if naredbe */
if(num1 < num2)
{
printf("%d je manji od %d\n", num1, num2);
if(num1 > num2)
{
printf("%d je veci od %d\n", num1, num2 );
if(num1 <= num2)
{
printf("%d je manji ili jednak sa
%d\n", num1, num2);
if(num1 >= num2)

{
printf("%d je veci ili jednak sa %d\n", num1, num2);
}/* kraj if naredbe */
} /* kraj funkcije
main */
:
if .
if - (;).
) if if-else a:
if(izraz1)
{
naredbe
}
else
{
naredbe
}
if (if else a)
.
:
if(br_ == 0)
printf(" broj a je jednak nuli\n");
else
printf(" broj a je razlicit od nule\n");
:
if else .

. ,
.
.
,
.
if(br_ == 0)
{
br_b=7;
printf(" broj a je jednak nuli\n");
}
else
printf(" broj a je razlicit od nule\n");
Me,
. , :
if(x < 0)
if(y < 0)
broj_a=5;
else
broj_a=8;
, x > 0 x = 0 broj_a=8; ?
else if ,
if .
else if () ,
else.

if(x < 0)
if(y < 0)
broj_a=5;
else
broj_a=8;

if(x < 0)
{
if(y < 0)
broj_a=5;
else
broj_a=8;
}
10
x > 0 x = 0 .
(
).
x > 0 x = 0 broj_a=8;

if(x < 0)
if(y < 0)
broj_a=5;
else
; /* prazna naredba */
else
broj_a=8;
if(x < 0)
{
if(y < 0)
broj_a=5;
}
else
broj_a=8;
) , .
if(izraz1)
{
naredbe
}
else if(izraz2)
{
naredbe
}
...
else
{
naredbe
}
:
if(>90)
ocena = 10;
else if(a>80)
ocena = 9;
else if(a>70)
ocena =8;
else if(a>60)
ocena =7;
else if(a>50)
ocena =6;
else
ocena = 5;
(if(>90)).
(ocena = 10) .
11
(if(a>80))... , ,
( )
.
:
#include <stdio.h>
main()
{
int a = 85;
int ocena;
if(a>90)
ocena = 10;
else if(a>80)
ocena = 9;
else if( (a%5)==0) /* Da li je a deljivo sa 5?*/
printf("\n a je deljivo sa 5\n");
else
ocena = 5;
}
printf("\nVrednost ocene je %d\n", ocena);
: Vrednost ocene je 9
5 (if((a%5)==0), ),
a>80.
switch
switch if .
, if.
:
switch(izraz)
{
case vrednost_1: niz_naredbi_1
...
case vrednost_N: niz_naredbi_N
default:
niz_naredbi
}
switch izraz.
vrednost_1, vrednost_2,... vrednost_N,
case .
case
switch . , case
(izraz), .
12
:
#include <stdio.h>
main()
{
int a = 1;
int b=2;
}
:
switch(a+b)
{
case 1:
printf("Zbir
case 2:
printf("Zbir
case 3:
printf("Zbir
case 4:
printf("Zbir
default:
printf("Zbir
}
je 1\n");
je 2\n");
je 3\n");
je 4\n");
je veci od 4\n");
Zbir je 3
Zbir je 4
Zbir je veci od 4
(niz_naredbi) case ,
switch , break. case default
break. , izraz
case (vrednost_i) case
switch .
:
#include <stdio.h>
main()
{
int a = 1;
int b=2;
switch(a+b)
{
case 1:
printf("Zbir
case 2:
printf("Zbir
case 3:
printf("Zbir
case 4:
printf("Zbir
default:
printf("Zbir
}
}
:
Zbir je 3
je 1\n"); break;
je 2\n"); break;
je 3\n"); break;
je 4\n"); break;
je veci od 4\n"); break;
case ,
default . default (
. ) switch
switch .
13
default switch ,
. , .
:
#include <stdio.h>
main()
{
int a = 4;
int b=2;
}
:
switch(a+b)
{
case 1:
printf("Zbir
case 2:
printf("Zbir
case 3:
printf("Zbir
default:
printf("Zbir
case 4:
printf("Zbir
}
je 1\n");
je 2\n");
je 3\n");
je veci od 4\n");
je 4\n");
Zbir je veci od 4
Zbir je 4
break,
case case .
switch case (NSI C 257),
ce case . :
switch(izraz)
{
/* Greska! dve pojave vrednost_1*/
case vrednost_2: niz_naredbi_N
default:
niz_naredbi
}
14
( )
, .
while
:
while(izraz) naredba;
while(izraz) {naredba_1; naredba_2;...;
naredba_N;}
while(izraz)
{
naredba_1;
naredba_2;
...
naredba_N;
}
while izraz . , .
, .
izraz- .
izraz while
.
:
#include <stdio.h>
main()
{
float farenhajt, celzijus;
int min, maks, korak;
min = 0;
maks = 120;
korak = 20;
farenhajt = min;
}
:
while(farenhajt <= maks)

{
celzijus= (5.0/9.0) * (farenhajt-32.0);
printf("%3.0f,%6.1f\n", farenhajt,celzijus);
farenhajt += korak;
}
0, -17.8
20, -6.7
40,
4.4
60, 15.6
80, 26.7
100, 37.8
120, 48.9
farenhajt
maks .
15
:
while (izraz, while(izraz))
( ) while .
.
for-
for :
for(izraz_1; izraz_2; izraz_3)
{
naredbe
}
izraz_1
() , (i=0, broj=2;)
izraz_2
(i<100;)
izraz_3
,
izraz_2. (i++;)
(izraz_1, izraz_2 izraz_3) ;

.
for :
1. izraz_1,
.
2. izraz_2. izraz_2 , .

izraz_3.
3. izraz_2. izraz_2 ,
izraz_3.
.
:
#include <stdio.h>
main()
{
int num;
}
: 1
for(num = 1; num <= 10 ; num ++)

{
printf(" %d ", num);
}
printf("\n");
10
16
:
#include <stdio.h>
void main()
{
int num;
for(num = 10; num >= 0 ;

{
}
printf("\n");
: 10
num--)
:
#include <stdio.h>
void main()
{
int num;
for (num = 2; num <= 10 ;
{
}
}
num += 2)
printf("\n");
: 2
10
17
do while
for while , do while .
do while ,
.

do
{
naredbe
}
while( izraz );
do while , .
.
:
#include <stdio.h>
main()
{
float num, total;
total=0;
do
{
printf("Please enter a number ");
scanf("%f",&num);
total += num;
printf("The total is %f\n\n", total);
}while(num!=0);
:
Please enter a number 1
The total is 1.000000
18

, ,
.
, ,
. :
break
continue
break
break (while, for do-while),
switch. break switch
.
, (), break
.
:
...
for(i=0; ; ++i)
/* nema uslova za prekid petlje! */
{
...
x=i-3+12*i;
if(x>=500) break;
...
}
y=33;
...
for ()
. ( for(i=0; ; ++i) ).
, for .
x 501, for
y=33;
:
/* Prekid beskonacne petlje */
#include <stdio.h>
main()
{
char ch;
printf("Unesite karkter:\n(unesite x za izlaz)\n");

while (1)
{
scanf("%c",&ch);
if(ch == 'x')
break;
}
printf("Prekid beskonacne petlje. Cao!\n");
19
continue
continue, break
(while, for do-while) () .
:
#include <stdio.h>
main()
{
int x;
printf("Ispisujem samo parne brojeve od 1 do 10\n");
for( x = 1; x <= 10; x++ )
{
if( x % 2 != 0 )
/* Ako broj nije paran ... */
continue;
/* Idi na poetak for petlje */
printf( "\n%d", x );
}
}
: Ispisujem samo parne brojeve od 1 do 10
2
4
6
8
10
20
C
4
........................................................................................................................................................... 2
................................................................................................................................. 2
.......................................................................................................................... 3
................................................................................................................. 4

.
, , , (array).

.
.
. ,
( ...).
.
.

. !
tip ime_niza [duzina] [duzina]... [duzina]
tip ( int float double....)

ime_niza ( ...)
duina ,
:
float Plate[10];/* jednodimenzionalni niz*/
int [10][5];
/* dvodimenzionalni niz, 10x5 elemenata*/*/

Plate[0]
223.44
Plate[1]
435.11
Plate[2]
322.76
Plate[3]
218.44
Plate[4]
481.65
Plate[5]
712.34
Plate[6]
490.09
Plate[7]
395.27
Plate[8]
318.66
Plate[9]
348.33
4.1 10
Plate 10 .
( ), ,

.
[ ], . .
0, 1, .
9 ( 10).
.
0 0.
. .
00
10
20
...
90
01
11
21
02
12
22
03
13
23
04
14
24
91
92
93
94

.
:
Tip Ime[Duzina] = { vrednst0, vrednost1,
, vrednostDuzina-1 };
, .
vrednost0 Ime[0], vrednost1 Ime[1], .
()
.
:
int tablica[4]={3, 5, 7, 9};
long a1[6]={3, 5, 7, 9, 0, 0};
int NumDays1[12] = { 31, 28, 31, 30,31, 30, 31, 31, 30, 31, 30, 31 };
/* Jan je 0, Feb je 1, ... */
int NumDays2[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31 };
/* Jan je 1, Feb je 2, */
tablica 4 ,
. ( 0) 3, ( 1) 5 .

. , 0 31 (
), 1 28 ( )...
, . , 4,
13 , ( ) ,
( 1) , ( 2)
...
, Duzina .

int tablica[ ]={3, 5, 7, 9};

int tablica[4]={3, 5, 7, 9};
(duzina) ,
!
int tablica [3]={3, 5, 7, 9};

/*Greska! rrr too many initializers....*/
o 3 (tablica [3]) 4 .
, .
,
.
int tablica [5]={3, 5, 7, 0, 0};

int tablica [5]={3, 5, 7};
-
int mat2[3][2]={
{1,2},
{3,4},
{5,6}
};

int mat2[3][2]={{1,2},{3,4},{5,6}};
int NumDays2[2][13] = {
{0,31,28,31,30,31,30,31,31,30,31, 30,31},
{0,31,29,31,30,31,30,31,31,30,31, 30,31}
};
short kvadratA[4][4]={ {0,1,2,0},{3,4,0,0},{5,6,7,8},{9,0,0,0} };

short kvadratB[4][4]={ {0,1,2},{3,4},{5,6,7,8},{9} };
.
, . , (
) ,
int kvA[4][4]={0,1,2,3,4,5,6,7,8,9};
int kvB[4][4]={ {0,1,2,3},{4,5,6,7},{8,9,0,0},{0,0,0,0} };

.
n-1, n .
[ ].
:
i tablica
int tablica [3]={3, 5, 7, 9};
int i;
...
i = tablica [1]; /* i dobija vrednost 5*/
tablica [0]=i+1; /* tablica [0]= 6/
...
:

float Sales[10];
:
Sales = 17.50;
/* nedostaje indeks */
Sales[-1] = 17.50;
/* indeks izvan opsega */
Sales[10] = 17.50;
Sales[7.0] = 17.50;
Sales[a] = 17.50;
Sales[7] = A;
/*
/*
/*
/*
indeks izvan opsega */

tip indeksa nije odgovarajuci */
:
Sales[7] = 17;
/* 17 ce se konvertovati u float tip*/
:
for
#include<stdio.h>
main()
{
int mat[10]; /* mat je niz od 10 elemenata*/
int i;
/* brojac*/
/* inicijalizacija elemenata niza mat na 0*/
for(i = 0;i < 10;i++)
{
mat[i]=5; /* postavi element na lokaciji i na 0 */
}/* kraj for petlje*/
printf("\nElement\t Vrednost\n");
/* ispisi vrednost elemenata polja u obliku tabele*/
for(i = 0;i < 10;i++)
{
printf("\n%7d%10d\n",i,mat[i]);
}/* kraj funkcije main*/
:
Element
0
1
2
3
4
5
6
7
8
9
Vrednost
5
5
5
5
5
5
5
5
5
5
Press any key to continue
N .
5.
0, 2, 4,6, 8, ...18
#include<stdio.h>
main()
{
int mat[10]; /* mat je niz od 10 elemenata*/
int i;
/* brojac*/
/* inicijalizacija elemenata niza mat na 0*/
for(i = 0;i < 10;i++)
{
mat[i]=2*i; /* postavi element na lokaciji i na 2 puta i */
for(i = 0;i < 10;i++)
{
printf("\n%7d%10d\n",i,mat[i]);
:
Element Vrednost
0
0
1
2
2
4
3
6
4
8
5
10
6
12
7
14
8
16
9
18
Press any key to continue
for
main()
{
int mat[4][3];
int i,j;
for( i = 0; i < 4; i++ )
{
for( j = 0; j < 3; j++ )
{
mat[i][j]=5 ;
}
}
}
,

#include<stdio.h>
main()
{
#define
MAXELEM
float plate[MAXELEM] =
float ukupno;
int i;
10
/* Nema ; iza pretprocesorske naredbe!*/
{117.0f, 129.95f, 276.22f, 201.10f,106.31f,

358.11f, 31.85f, 256.45f, 269.09f,197.81f};
for(i = 0;i < MAXELEM;i++)
{
printf("\n%7d%10.2f\n",i,plate[i]);
/* Izracunaj zbir vrednosti elemenata niza */
ukupno = 0.0;
for (i = 0; i < MAXELEM; i++) /* jedna naredba, moze i bez {} */
ukupno += plate[i]; /* moze i ukupno = ukupno + plate[i] */
printf("\n\nZbir svih elemenata niza: %.2f\n\n", ukupno);
}/* kraj funkcije main */
:
Element Vrednost
0
117.00
1
129.95
2
276.22
3
201.10
4
106.31
5
358.11
6
31.85
7
256.45
8
269.09
9
197.81
Zbir svih elemenata niza: 1943.89
f (float
plate[MAXELEM] = {117.0f, 129.95f,...}).
double .
:
. :

1 10 (1 , 10 ).
(o).
. (. 1
5 , 2 3 , .). odgovor 40 ,
. frekvOcena 11 ,
. . frekvOcena[0] : frekvOcena[1]
1, frekvOcena[2] 2, ...
frekvOcena[10] 10.
#include <stdio.h>
#define BROJ_STUDENATA 40 /* definisi velicinu nizova */
#define FREKV_VELICINA 11
/* function main pocetak izvrsavanja programa */
int main()
{
int i; /* brojac koji kruzi od 1. do 40. odgovora */
/* inicijaliacija niza sa brojem dobijenih ocena na 0 */
int frekvOcena[ FREKV_VELICINA ] = { 0 };
/* inicijalizacija niza odgovor studenata */
int odgovor[ BROJ_STUDENATA ] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10,
1, 6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, 6, 6,
5, 6, 7, 5, 6, 4, 8, 6, 8, 10 };
/* za svaki odgovor, odredite vrednost elementa niza odgovor
i uzmite tu vrednost and kao indeks niza frekvOcena i da bi se
pozicionirali na taj element niza frekvOcena i povecajte ga za 1 */
for ( i = 0; i < BROJ_STUDENATA; i++ ) {
++frekvOcena[ odgovor [ i ] ];
} /* kraj for petlje */
/* prikazi rezultate */
printf( "Ocena Broj glasova\n" );
/* Prikaz u tabelarnom formatu */
for ( i = 1; i < FREKV_VELICINA; i++ ) {
printf( "%5d%14d\n", i, frekvOcena[i ] );
} /* end for */
}
:
Ocena
1
2
3
4
5
6
7
8
9
10
Broj glasova
2
2
2
2
5
11
5
7
1
3
for (for ( i = 0; i < BROJ_STUDENATA; i++ ){++frekvOcena[odgovor[i]];})

odgovor i = 0
odgovor[0], i = 1 odgovor[1] ... :
odgovor[0] 1, odgovor[1] 2, odgovor[3] 6...
odgovor frekvOcena
frekvOcena 1 (++frekvOcena[odgovor[i]];)
:
for . i = 0. odgovor[0] 1 (
).
frekvOcena[odgovor[i]]= frekvOcena[odgovor[0]]= frekvOcena[1]
( 1) frekvOcena 0
(frekvOcena[1]=0) ++frekvOcena[1]
. frekvOcena[1]=1.
for , 1, (i = 1).
odgovor[1] 2 ( ).
( 2) frekvOcena 0
. frekvOcena[2]=1.
for , 1, (i = 2).
odgovor[2] 6 ( ).
( 6) frekvOcena 0
. frekvOcena[6]=1.
...
:
:
#include <stdio.h>
#define VELICINA 10 /* definisi velicinu niza */
/* function main pocetak izvrsavanja programa */
int main()
{
/* inicializacija niza n */
int n[ VELICINA ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };
int i; /* brojac za elemente polja */
int j; /* brojac zvezdica */
printf( "Element
Vrednost
Histogram\n" );
/* za svaki element polja ispisi index, vrednost i nacrtaj histogram */

for ( i = 0; i < VELICINA; i++ )
{
/* ispis indeksa i vrednosti*/
printf( "%7d%10d
", i, n[ i ]) ;
for ( j = 1; j <= n[ i ]; j++ )
{
/* ispisi jednu zvezdicu */
printf( "%c", '*' );
} /* kraj unutrasnje petlje */
printf( "\n" ); /* kraj histigrama za jedan element niza */
} /* kraj spoljasnje petlje */

} /* kraj funkcijemain */
:
Element
0
1
2
3
4
5
6
7
8
9
Vrednost
19
3
15
7
11
9
13
5
17
1
Histogram
*******************
***
***************
*******
***********
*********
*************
*****
*****************
*

#include<stdio.h>
main()
{
#define
MAXEMPS
double Sales[MAXEMPS] =
double maxS;
int i;
10
{117.0, 129.95, 276.22, 201.10,106.31,
358.11, 31.85, 256.45, 269.09, 197.81};
maxS = Sales[0];
for (i = 1; i < MAXEMPS; i++)
{
if (Sales[i] > maxS) maxS = Sales[i];
/* Primetite da i pocinje od 1 */
}
printf("maksimalna vrednost niza je %f\n", maxS);
}
:
maksimalna vrednost niza je 358.110000
10
C
5
.......................................................................................................................... 2
................................................................................................. 3
&............................................................................................................................ 4
*.............................................................................................................................5
............................................................................ 11
....................................................................................................... 11
......................................................................... 12
( ) ......................... 12
: ................................................................. 13
:.......................................... 13
: ....................................................................... 14
: .............................................................. 14
....................................................................................................... 14
........................................................................................ 16

(pointer) C .
.
:
: . (main memory)
(secundary memory).
(hard disk, CD-rom...).
RAM (random access memory).
.
,
. .

.
1 (8
). , .
. ,
,
( )
.

(. 921) .
( ) .
. ,
.
()
.
, (variable) .
.
(") .
, 1220, 1222 1230.
, . , ,
(compiler) . ,
, !
int main()
{
short int brojA;
double tezina, zapremina;
....
}
(. short int
-32768 32767)
(, ...). (int,
float, double...) .
.
.
2 4 , (
) . , PC 64
, 1 ,
16 (2 ) 216= 65536, 2 .
.
.

. ,
. , ?
. ,
.
:
tip_podatka *ime_pokazivaa;
tip_podatka ( ) ,
, .
* , .
ime_pokazivaa .
:
int *p;
float *ptr;
p ptr . () p
( ) int, ptr
float. p int ptr
float.
, :
int *p;

int* p;

int * p;
* .
:
int* p, q;
p , q . q int.
* .
,
int *p, q;

int *p, *q;
, ()
. , p int, p
int.
C :
&
*
&
&
.
:
main()
{
int x=25;
int *p;
...
p=&x;
*p=48;
...
}
p=&x; x p .
: int x=25; int *p; 1.
: 1200 1800 (
). x 25,
.
.
.
.
.
adresa:1200
??
ime: p
.
.
.
adresa:1800
25
ime: x
.
.
.
1
p=&x; ,
x. 2.

.
.
.
adresa:1200
1800
ime: p
.
.
.
adresa:1800
25
ime: x
.
.
.
*
, , *.
, , , *
.
*p=48; : p,
48. ( p=&x; p x).
3.

.
.
.
adresa:1200
1800
ime: p
.
.
.
adresa:1800
48
ime: x
.
.
.
:
1. &p, p *p .
2. &p ( ), 3 1200.
3. p ( ), 3 1800
4. *p (48, 3) (1800, 3)
( 1200, 3).
:

int x;
int *p;
x p 4
.
.
.
ime: p
adresa:1400
.
.
.
ime: x
adresa:1750
.
.
.
4.
&p, p, *p &x x
&p
1400 ( p)
?? ( p)
*p
&x
1750 ( x)
?? ( x)
,
x=50;
:

&p
1400 ( p)
?? ( p)
*p
&x
1750 ( x)
50

p=&x;
&p
1400 ( p)
1750
*p
50
&x
1750 ( x)
50

*p=38;
&p
1400 ( p)
1750
*p
38
&x
1750 ( x)
38
:
main()
{
int *ptr1, *ptr2;
int x, y;
ptr1=&x;
*ptr1=42;
ptr2=ptr1;
*ptr2=53;
ptr1=&y;
*ptr1=88;
}
int *ptr1, *ptr2; int x, y;
( ):

&ptr1
2350
ptr1
??
*ptr1
??
&ptr2
2600
ptr2
??
*ptr2
??
&x
1320
??
&y
1950
??
ptr1=&x;
&ptr1
2350
ptr1
1320
*ptr1
??
&ptr2
2600
ptr2
??
*ptr2
??
&x
1320
??
&y
1950
??
*ptr1=42;
&ptr1
2350
ptr1
1320
*ptr1
42
&ptr2
2600
ptr2
??
*ptr2
??
&x
1320
42
&y
1950
??
ptr2=ptr1;
&ptr1
2350
ptr1
1320
*ptr1
42
&ptr2
2600
ptr2
1320
*ptr2
42
&x
1320
42
&y
1950
??
ptr2 ptr1,
x. ptr2 (2600 )
x (1320 ).
*ptr2=53;
&ptr1
2350
ptr1
1320
*ptr1
53
&ptr2
2600
ptr2
1320
*ptr2
53
&x
1320
53
&y
1950
??
ptr1=&y;
&ptr1
2350
ptr1
1950
*ptr1
??
&ptr2
2600
ptr2
1320
*ptr2
53
&x
1320
53
&y
1950
??
10
, *ptr1=88;
&ptr1
2350
ptr1
1950
*ptr1
88
&ptr2
2600
ptr2
1320
*ptr2
53
&x
1320
53
&y
1950
88
:
ptr1 ptr2
ptr2=ptr1;
ptr2 ptr1.
( ) ;
0 ().

!
:
main( )
{
int x;
int *pokazivac= &x;
int *p2=NULL
/* moze se napisati i int *p2=0 */
}

.
float , float .
, ,
(int, float, double...) void
:
vid *point;
.
!
11
:
main()
{
int x;
void *p=&x;
void *p2;
...
p2=&x;
...
}
/* Greska! Tip pokazivaca nije odgovarajuci*/

/* Greska! Tip pokazivaca nije odgovarajuci */
, ( void)
.
:
main()
{
int x;
void *p2;
...
(int *)p2=&x; /* p2 ukazuje na adresu promenljive x */
*(int *)p2=3;
/* na adresu promenljive x upisati 3
isto sto i x=3 */
...
}

() . ()
.
printf %p
( int %d; float %f ...).
#include<stdio.h>
main()
{
int x;
int *px;
px=&x;
printf(Pokazivac ukazuje na adresu: %p\n ,px);
}
:
Pokazivac ukazuje na adresu: 0012FF7C
( )
( )
:
12
:
= ,
.
(cast), a
!
:
main()
{
double x=1.23;
double *px=&x;
double *p1;
int *p2;
....
p1=px;
p2=px;
p2=(double *)px;
}
/* px ukazuje na adresu promenljive x */
/* p1 ukazuje na adresu promenljive x */

/* Greska! pokazivaci su razlicitih tipova */
/* Ovako moze, ali na odgovornost programera */
p1=px; px p1. p1 px
, x.
:
: +, ++ += ,
: , = .
a
.
:
main()
{
int *p;
double *q;
char *chPtr;
...
p++;
q++;
chPtr++;
p=p+2;
...
}
: int 4 ,
double 8 char 1 .
p++; ( p= p + 1;) p 4 , .
.
q++; ( q= q + 1;) q 8 .
chPtr++; ( chPtr= chPtr + 1;) chPtr 1 .
(++)
, , ( )
.
, p= p + 2; p 8 .
13
, , :
( ) ( ).
2 4 sizeof(int)=4.

() ,
. .
:
== !=
.
:
. ( NULL)
. NULL
<stdio.h>.

:
int my_array[6]={1, 23, 17, 4, -5, 100};
6 . my_array[0]
my_array[5]. , :
int *ptr;
ptr=&my_array[0]; /* pokazivac ukazuje na prvi element niza*/
:
#include <stdio.h>
main()
{
int my_array[6] = {1, 23, 17, 4, -5, 100};
int *ptr;
int i;
ptr = &my_array[0]; /* ptr ukazuje na prvi element niza */
printf("\n\n");
for (i = 0; i < 6; i++)
{
printf("my_array[%d] = %3d\t ",i,my_array[i]);
/*<-- A */
printf("*(ptr + %d) = %3d\n",i, *(ptr + i));
/*<-- B */
}
}
B.
B.
:
my_array[0]
my_array[1]
my_array[2]
my_array[3]
my_array[4]
my_array[5]
=
1
= 23
= 17
=
4
= -5
= 100
*(ptr
*(ptr
*(ptr
*(ptr
*(ptr
*(ptr
+
+
+
+
+
+
0)
1)
2)
3)
4)
5)
=
1
= 23
= 17
=
4
= -5
= 100
14
C
ptr = &my_array[0];

ptr = my_array;
, ptr .
. (
) . , :
ptr = my_array;

my_array = ptr;
: ptr my_array ( )
.
3. ( 2) :
ptr = &my_array[2];

ptr = &my_array[0] + 2;
ptr = my_array + 2;
my_array &my_array[0]

my_array[i] = *(my_array + i)
:
#include <stdio.h>
main()
{
int a[8] = {1,23,17,4,-5,100,55,44};
int *pa, *pb;
int x, y;
pa=&a[4]; /* pa ukazuje na a[4] tj na vrednost -5 */
printf("Vrednost *pa nakon naredbe pa=&a[4] je: %d\n", *pa);
x=*(pa+3); /* x=a[7]=44 */
printf("Vrednost x nakon naredbe x=*(pa+3) je: %d\n", x);
y=*pa+3;
/* y=a[4]+3=-2*/
printf("Vrednost y nakon naredbe y=*pa+3; je: %d\n", y);
*pa++;
/* povecava se sadrzaj pokazivaca, isto sto i *(pa++)
ili pa=&a[5] */
printf("Vrednost *pa nakon naredbe *pa++ je: %d\n", *pa);
(*pa)++;
/* povecava se pokazani podatak a[5]=a[5]+1=101 */
printf("Vrednost *pa nakon naredbe (*pa++) je: %d\n", *pa);
pb=&a[2];
}
15
:
Vrednost
Vrednost
Vrednost
Vrednost
Vrednost
*pa nakon naredbe pa=&a[4] je: -5

x nakon naredbe x=*(pa+3) je: 44
y nakon naredbe y=*pa+3; je: -2
*pa nakon naredbe *pa++ je: 100
*pa nakon naredbe (*pa++) je: 101

,
. ,
. ,
.
? (, )
.
:
.
(dynamic variables) .

,
(deallocate).
, ,
( )
. (
) .
,
.
, () ,
.
.
C ,
.
.
() ,
.

.
( )
<stdlib.h>.

malloc(velicina)
velicina .
( void *) NULL
.
.
calloc(n,velicina)
n e
velicina . (
void *) NULL
16
.
.
realloc(p,velicina)
p
velicina .
. , ,
.
,
. (
void *) NULL
.
free(p)
p. p

malloc, calloc realloc.
malloc
#include <stdio.h>
#include <stdlib.h> /* potrebno zbog malloc i free funkcije */
main()
{
int number;
int *ptr;
int i;
printf("Koliko int vrednosti zelite da sacuvate? ");
scanf("%d", &number);
ptr = malloc(number*sizeof(int)); /* zahtev za dodelu memorije */
/* ptr = (int *)malloc(number*sizeof(int)); */ /* moze i ovako */
if(ptr!=NULL)
{
for(i=0 ; i<number ; i++)
{
*(ptr+i) = i;
}
for(i=number ; i>0 ; i--)
{
printf("%d\n", *(ptr+(i-1))); /* prikazi u suprotnom redosledu */
}
free(ptr); /* oslobodi dodeljenu memoriju */

}
else
printf("\nDodela memorije nije izvrsena - nema dovoljno memorije.\n");
:
Koliko int vrednosti zelite da sacuvate? 3
2
1
0
17
calloc
/* Program koji koristi calloc da dodeli memoriju za 40
long int promenljivih. Inicijalizuje svaku promeljivu na 0
#include <stdio.h>
#include <stdlib.h>
*/
int main( void )

{
long *buffer;
buffer = (long *)calloc( 40, sizeof( long ) );
if( buffer != NULL )
printf( "Dodeljena memorija za 40 long int promenljivih\n" );
else
printf( "Dodela memorije neuspesna\n" );
free( buffer );
}
_____________________________________________________________________
#include <stdio.h>
main()
{
float *ptr_c1, *ptr_c2, *ptr_m1, *ptr_m2;
int i;
ptr_c1
ptr_c2
ptr_m1
ptr_m2
=
=
=
=
calloc(3, sizeof(float)); /* moze se zahtevati konverzija */

calloc(3, sizeof(float));
malloc(3 * sizeof(float));
if(ptr_c1!=NULL
{
printf("adresa
printf("adresa
printf("adresa
printf("adresa
&& ptr_c2!=NULL && ptr_m1!=NULL && ptr_m2!=NULL)

ptr_c1
ptr_c2
ptr_m1
ptr_m2
for(i=0 ; i<3 ; i++)

{
printf("*ptr_c1[%d]
printf("*ptr_c2[%d]
printf("*ptr_m1[%d]
printf("*ptr_m2[%d]
}
je
je
je
je
ima
ima
ima
ima
%05.5p,\n", ptr_c1);
%05.5p,\n", ptr_c2);
%05.5p,\n", ptr_m1);
%05.5p,\n\n", ptr_m2);
vrednost
vrednost
vrednost
vrednost
%05.5f,\n", i, *(ptr_c1+i));
%05.5f,\n", i, *(ptr_c1+i));
%05.5f\n", i, *(ptr_m1+i));
%05.5f,\n\n", i, *(ptr_c1+i));
free(ptr_c1);
free(ptr_c2);
free(ptr_m1);
free(ptr_m2);
}
else
printf("Nema dovoljno memorije\n");
18
:
adresa
adresa
adresa
adresa
ptr_c1
ptr_c2
ptr_m1
ptr_m2
je
je
je
je
00430120,
004300E0,
004300A0,
00430060,
*ptr_c1[0]
*ptr_c2[0]
*ptr_m1[0]
*ptr_m2[0]
ima
ima
ima
ima
vrednost
vrednost
vrednost
vrednost
0.00000,
0.00000,
-431602080.00000
0.00000,
*ptr_c1[1]
*ptr_c2[1]
*ptr_m1[1]
*ptr_m2[1]
ima
ima
ima
ima
vrednost
vrednost
vrednost
vrednost
0.00000,
0.00000,
-431602080.00000
0.00000,
*ptr_c1[2]
*ptr_c2[2]
*ptr_m1[2]
*ptr_m2[2]
ima
ima
ima
ima
vrednost
vrednost
vrednost
vrednost
0.00000,
0.00000,
-431602080.00000
0.00000,
realloc
#include<stdio.h>
#include <stdlib.h>
int main()
{
int *ptr;
int i;
ptr = calloc(5, sizeof(int)); /*dinamicki niz od 5 elemenata indeks 0-4 */
if(ptr!=NULL) /* ako je dodeljena memorija...*/
{
*ptr = 1;
/* isto sto i ptr[0]=1 ili *ptr=1 */
*(ptr+1) = 2; /* isto sto i ptr[1]=2 */
*(ptr+2) = 4;
*(ptr+3) = 8;
*(ptr+4) = 16;
printf("\nNakon naredbe calloc(5, sizeof(int)) i dodele vrednosti...\n");
for(i=0 ; i<5 ; i++)
printf("*(ptr+%d) ukazuje na vrednost %d\n", i, *(ptr+i));
ptr = realloc(ptr, 7*sizeof(int)); /* dodaj jos 2 int (bilo je vec 5)*/
if(ptr!=NULL)
{
printf("\n Nakon naredbe ptr = realloc(ptr, 7*sizeof(int));... \n");
for(i=0 ; i<7 ; i++)
*(ptr+5) =
*(ptr+6) =
32;
64;
19
printf("\n Nakon naredbe dodele vrednosti 6. i 7. elementu... \n");

for(i=0 ; i<7 ; i++)
realloc(ptr,0); /* isto sto i free(ptr); */
}
else
printf("Nema dovoljno memorije - realloc neuspesan.\n");
}
else
printf("Nema dovoljno memorije - calloc neuspesan.\n");
}
:
Nakon naredbe calloc(5, sizeof(int)) i dodele vrednosti...
*(ptr+0) ukazuje na vrednost 1
Nakon naredbe ptr = realloc(ptr, 7*sizeof(int));...
*(ptr+5) ukazuje na vrednost -842150451
*(ptr+6) ukazuje na vrednost -842150451
Nakon naredbe dodele vrednosti 6. i 7. elementu...
20
C
6
......................................................................................................................................... 2
.................................................................................................................................. 2
................................................................................................................................................. 3
........................................................................................................................... 3
...................................................................................................... 4
..................................................................................................................... 5
.................................................................................................................................... 5
.................................................................................................................. 6
.......................................................................................................................... 6
.................................................................................. 6
......................................................................................................................... 8
......................................................................................................... 14
................................................................................. 18

C . ,
. C char
. () ,
char.

( ) "
. , ASCII .
.
ASCII 32 ( space) 126 (~).
48 0, 49 1, ..., 65 , 66 ,..., 97 , 98 b....
, (!"#$....+-...).
0 31 127 .
. . : (space)
(ff - form feed), (lf - line feed), (cr carriage return)...
char ,
().

( ASCII ).
char
.
1:
#include <stdio.h>
main()
{
char c1, c2, c3;
c1='A';
c2=65;
c3='#';
printf("Vrednost znakova: c1=%c, c2=%c, c3=%c\n",c1,c2,c3);
}
:
Vrednost znakova: c1=A, c2=A, c3=#
! char
.
(0,1,2,...7) (\)
1078 G '\107'.
(0,1,...,, b,...,f) \x \X. . 5116 (
81 Q) '\x51.'
2:
main()
{
char c1, c2, c3,c4;
c1='A';
c2=65;
c3='\101'; /* 65 dekadno je 101 oktalno */
c4='\x41'; /* 65 dekadno je 41 heksadecimalno */
printf("Vrednost znakova: c1=%c, c2=%c, c3=%c, c4=%c\n",c1,c2,c3,c4);
}
:
Vrednost znakova: c1=A, c2=A, c3=A, c4=A
. ,
(bell, 07) \a;
\n; ...

. ,
.
()
. . '\0' (null character) .
('\0'),
.
:
"John L. Johanson"
"Zdravo svima!"
'A' "A". ('A') :
, ("A") . , "A" :
'A' '\0'. "Zdravo" : 'Z', 'd', 'r', 'a', 'v', 'o' '\0'.
'' char, ""
char '' '\0'.
"Zdravo" char.
:
char ime[16]
ime 16 char.
16 , ime
15 . ime 10, 11
5 .
3:
char ime[16]={'J', 'o', 'h', 'n', '\0'};
ime 16 char "Jonh".
:
4
char ime[16]="John";
( 3 4) .
,
5:
char ime[16]={'J', 'o', 'h', 'n'};
char imeB[16]="John";
ime imeB ( 5) .
, ()
6:
char ime[]={'J', 'o', 'h', 'n', '\0'};
7:
char ime[]="John";
( 5 6) 5, !
, ( ) (
7)
8:
main()
{
char ime[]="John";
...
ime[0]='A'; /*ovo je dozvoljeno*/
...
ime="Marko"; /* Error! */
...
}

.
9:
#define ZVONO '\a'
#define NOVI_RED '\n'
#define VALUTA "US dollar"

.
.
, .
.
char daniA[7][11]={"ponedeljak", "utorak", "sreda", "cetvrtak", "petak", "subota", "nedelja"};
char *daniB[7]={"ponedeljak", "utorak", "sreda", "cetvrtak", "petak", "subota", "nedelja"};
7 11 7
.

printf() i scanf()
. :
() %c
%s.
:
#include <stdio.h>
main()
{
char a[8] = {'A','l','e','k','s','a'};
char b[5] = "Pera";
printf("ispis karaktera: %c\nIspis stringa: %s\n", a[3], b);
}
:
ispis karaktera: k
Ispis stringa: Pera

int getchar(void);
: , , ().
EOF
.
:
:
:
#include <stdio.h>
int main()
{
char znak;
printf ("Unesite tekst. Unesite tacku ('.') da bi izasli z programa:");
do
{
znak=getchar();
printf("%c",znak);
} while (znak != '.');

return(0);
int
putchar(int character);
: () .
: () . int unsigned
char .
: , EOF

:
#include <stdio.h>
int main ()
{
char znak;
for (znak = 'A' ; znak <= 'Z' ; znak++)
{
putchar (znak);
}
return(0);
}
:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
char *gets(char *buffer);

:
char ( buffer).
(\n).
(\0).
: buffer .
: ( ) , NULL
.
:
#include <stdio.h>
main()
{
char niz[5];
char *p;
int i;
printf ("Upisite do 5 karaktera: ");
p=gets(niz);
printf ("Uneti karakteri su:\n");
for(i=0; i<5; i++)
printf ("\t %c\n",*(p+i) );
}
#include <stdio.h>
main()
{
char niz[256];
printf ("Upisite vasu adresu: ");
int
gets(niz);
printf ("Vasa adresa je: %s\n",niz);
puts (const char *string);
: string ( char) \0
\n .
: string .
: , EOF

:
include <stdio.h>
int main ()
{
char string [] = "Hello world!";
char *ptr;
ptr = &string[0];
puts(ptr);
:
#include <stdio.h>
int main ()
{
char string [] = "Hello world!";
puts (string);
}

(, ...) .
<ctype.h>.
0 , .
int isalnum(int c);
/* slovo ili cifra? */
: :
('A'-'Z', 'a'-'z', '0'-'9')
: .
: 1 , 0 .
:
#include <ctype.h>
#include <stdio.h>
main()
{
short int i;
for (i = 0; i < 256; i++)
{
if(isalnum(i))
printf("isalnum (%c) Da \n", i);
else
printf("isalnum (%c) Ne\n", i);
}
}
int isalpha(int c);
/* c slovo? */
: : ('A'-'Z', 'a'-'z')
: .
: 1 , 0 .
:
#include <ctype.h>
#include <stdio.h>
main()
{
short int i;
for (i = 0; i < 256; i++)
{
if(isalpha(i))
printf("isalpha (%c) Da \n", i);
else
printf("isalpha (%c) Ne\n", i);
}
}
int islower(int c);
/* c malo slovo? */
: : ('a'-'z')
: .
: 1 , 0 .
:
#include <ctype.h>
#include <stdio.h>
main()
{
short int i;
for (i = 0; i < 256; i++)
{
if(islower(i))
printf("islower(%c) Da \n", i);
/* else
printf("islower(%c) Ne\n", i); */
}
}
int isupper (int c);
/* c veliko slovo? */
: : ('A'-'Z')
: .
: 1 , 0 .
:
#include <ctype.h>
#include <stdio.h>
main()
{
short int i;
for (i = 0; i < 256; i++)
{
if(isupper(i))
printf("isupper(%c) Da \n", i);
/* else
printf("isupper(%c) Ne\n", i); */
}
}
10
int isdigit (int c);
/* c cifra? */
: : ('0'-'9')
: .
: 1 , 0 .
:
#include <ctype.h>
#include <stdio.h>
main()
{
short int i;
for (i = 0; i < 256; i++)
{
if(isdigit(i))
printf("isdigit (%c) Da \n", i);
/* else
printf("isdigit (%c) Ne\n", i); */
}
}
int isxdigit(int c);
/* c heksadecimalna cifra? */
: : ('0'-'9', ''-'f',
'A'-'F')
: .
: 1 , 0 .
:
#include <ctype.h>
#include <stdio.h>
main()
{
short int i;
for (i = 0; i < 256; i++)
{
if(isxdigit(i))
printf("isxdigit(%c) Da \n", i);
/* else
printf("isxdigit(%c) Ne\n", i); */
}
}
int isspace (int c);
/* c beli znak? */
: : (, ,...)
: .
: 1 , 0 .
11
:
#include <ctype.h>
#include <stdio.h>
main()
{
short int i;
for (i = 0; i < 256; i++)
{
if(isspace(i))
printf("isspace(%c) Da \n", i);
/* else
printf("isspace(%c) Ne\n", i); */
}
}
int isgraph(int c);
/* c tampajui znak a nije razmak? */
: .
: .
: 1 , 0 .
:
#include <ctype.h>
#include <stdio.h>
main()
{
short int i;
for (i = 0; i < 256; i++)
{
if(isgraph(i))
printf("isgraph(%c) Da \n", i);
/* else
printf("isgraph(%c) Ne\n", i); */
}
}

int tolower(int c);
/* c se konvertuje u malo slovo */
: .
: .
: , .
12
:
#include <stdio.h>
#include<ctype.h>
main()
{
unsigned char i;
for (i = 0x20; i < 0x7F; i++)

/* od 32 do 127*/
printf ("tolower(%c) = %c\n", i, tolower(i));
int toupper(int c);
/* c se konvertuje u veliko slovo */
: .
: .
: , .
:
#include <stdio.h>
#include<ctype.h>
main()
{
unsigned char i;
for (i = 32; i < 128; i++)

printf ("toupper(%c) = %c\n", i, toupper(i));
13

C . ()
<string.h>.
strcpy( str_dest, str_src ); /* kopira string */

: str_src str_dest, .
str_dest
:
#include <stdio.h>
#include <string.h>
main ()
{
char str1[]="Sadrzaj stringa 1";
char str2[40];
char str3[40];
strcpy (str2,str1);
strcpy (str3,"Kopiranje uspesno");
printf (" str1: %s\n str2: %s\n str3: %s\n",str1,str2,str3);
:
str1: Sadrzaj stringa 1
str2: Sadrzaj stringa 1
str3: Kopiranje uspesno
strncpy( str_dest, str_src ,n); /* kopira n znakova */

: n str_src str_dest,
. n str_src
.
:
#include <stdio.h>
#include <string.h>
main ()
{
char str1[]= "To be or not to be";
char str2[30]="Pocetni sadrzaj pre kopiranja";
puts(str2);
strncpy (str2,str1,10);
str2[10]='\0'; /* !! */
}
puts(str2);
14
:
Pocetni sadrzaj pre kopiranja
To be or n
strcat(str_dest, str_src); /* dopisuje string */

: str_src str_dest,
str_dest. .
:
#include <stdio.h>
#include <string.h>
main ()
{
char str[80];
strcpy (str,"Stringovi ");
strcat (str,"su ");
strcat (str,"spojeni.");
}
puts (str);
:
Stringovi
su spojeni.
strncat(str_dest, str_src, n); /* dopisuje n znakova */

: n str_src str_dest,
str_dest.
.
:
#include <stdio.h>
#include <string.h>
main ()
{
char str1[20];
char str2[20];
strcpy (str1,"To be ");
strcpy (str2,"or not to be");
strncat (str1, str2, 6);
}
puts (str1);
:
To be or not
15
strcmp(str1, str2); /* poredi dva stringa */

: str1 str2,
. SCII .

<0
str1 str2
str1 str2
>0
str1 str2
:
#include <stdio.h>
#include <string.h>
main ()
{
char Resenje[] = "kruska";
char Odgovor[80];
do {
printf ("Koje je moje omiljeno voce? ");
gets (Odgovor);
} while (strcmp (Resenje,Odgovor) != 0);
printf ("Odgovor tacan!\n");
}
:
Koje je moje omiljeno voce? jabuka
Koje je moje omiljeno voce? kruska
Odgovor tacan!
strlen(str1); /* duina stringa */

: .
:
#include <stdio.h>
#include <string.h>
main ()
{
char Ulaz[256];
printf ("Unesite tekst: ");
gets (Ulaz);
printf ("Uneto je %u znakova\n",strlen(Ulaz));
}
Unesite tekst: nekoliko slova
Uneto je 14 znakova
16
strchr(char *str1, c); /* trazi prvu poziciju karaktera u stringu */

: c str1.
: A
NULL
:
#include <stdio.h>
#include <string.h>
int main ()
{
char str1[] = "Ovo je test recenica";
char * pch;
printf ("Trazim karakter 'e' u \"%s\"...\n",str1);
pch=strchr(str1,'e');
while (pch!=NULL)
{
printf ("pronasao sam 'e' na poziciji %d\n",pch-str1+1);
pch=strchr(pch+1,'e');
}
Trazim karakter 'e'

pronasao sam 'e' na
pronasao sam 'e' na
pronasao sam 'e' na
pronasao sam 'e' na
u "Ovo je test recenica"...

poziciji 6
poziciji 9
poziciji 14
poziciji 16
strrchr(char *str1, c); /* trai poslednju poziciju karak. u stringu */

: c str1.
: A
NULL
:
#include <stdio.h>
#include <string.h>
int main ()
{
char str1[] = "Ovo je test recenica";
char * pch;
pch=strrchr(str1,'e');
printf ("Poslednja pojava karaktera 'e' je na poziciji %d\n",pch-str1+1);
Poslednja pojava karaktera 'e' je na poziciji 16
17
strstr(str1, str2); /* tri poziciju stringa 2 u stringu1 */

: str2 str1.
: A
, NULL
:
#include <stdio.h>
#include <string.h>
int main ()
{
char str[] ="Ovo je jedan primer";
char *pch;
pch = strstr (str,"dan");
printf("Pronadjena pozicija je %d\n", pch-str+1);
}
Pronadjena pozicija je 10

( )
.
double atof(string); /* konverzija u tip double */

: ccc.cccEcc
double.
:
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
main ()
{
double n,m;
double pi=3.1415926535;
char Ulaz[256];
printf("Unesite vrednost u stepenima: ");
gets(Ulaz);
n =atof(Ulaz);
m = sin(n*pi/180);
printf("sin(%f) je %f\n" , n, m);
}
Unesite vrednost u stepenima: 90
sin(90.000000) je 1.000000
18
int
atoi(string); /* konverzija u tip int */
: cccc int.
#include <stdio.h>
#include <stdlib.h>
main ()
{
int i;
char Ulaz[256];
printf ("Unesite broj: ");

gets ( Ulaz );
i = atoi (Ulaz);
printf ("Uneta vrednost je %d, a njena dvostruka vrednost je %d\n",i,i*2);
Unesite broj: 243

Uneta vrednost je 243, a njena dvostruka vrednost je 486
long
atol(string); /* konverzija u tip
long */
: cccc long.
:
#include <stdio.h>
#include <stdlib.h>
main ()
{
int i;
char Ulaz[256];
printf ("Unesite broj: ");
gets ( Ulaz );
i = atol (Ulaz);
printf ("Uneta vrednost je %d, a njena dvostruka vrednost je %d\n",i,i*2);
}
Unesite broj: 56324
Uneta vrednost je 56324, a njena dvostruka vrednost je 112648
19
C
7
............................................................................................................................. 2
............................................................................................................. 2
............................................................................................................... 3
.............................................................................................. 3
............................................................................................................ 4
return ......................................................................................................................... 5
( ) .......................................................................... 8
- void ............................................................... 9
Void ............................................................................................. 9
Void ........................................................................................ 10
................................................................................. 11
............................................................................................................. 19
() .......................................................................... 21
...................................................................................................... 23

o .
.
C .
, .

, .
.

.
C :
( )
( ) : printf,
scanf, sin, malloc, free, .

, .
, ,
. , f ( x) = 2 x + 5 , f (1) = 7 , f (2) = 9 f (3) = 11 ,
1, 2 3 f , 7, 9 11 f .
C , ,
. ,
.
pow(x,y), sqrt(x) floor(x). pow(x,y)
(power function) xy pow(x,y)= xy. pow(2,3)= 23 = 8.0,
pow(2.5,3)= 2.53 = 15.625. () pow(x,y) double
pow double pow double. , x y
pow. pow .
sqrt(x) (square root) x x>=0.0. , sqrt(2.25)=1.5.
sqrt double .
floor(x) x. floor(23.21)=23.0.
double .
:
#include <math.h>
#include <stdio.h>
main()
{
double y;
y = floor( 2.8 ); /* poziv biblioteke funkcije*/
printf( "The floor of 2.8 is %f\n", y );
y = floor( -2.8 );
printf( "The floor of -2.8 is %f\n", y );
}
The floor of 2.8 is 2.000000

The floor of -2.8 is -3.000000

, ,
... ,
, , " .
,
.
:
, .
(void) .

pow(x,y), squrt(x) floor(x). ()
. (header file)
. #include
(. #include<math.h>). , :
1.
2.
3.
4.

( ),
5. , .
(function heading)
(function body). . ,
abs :
int abs(int x)

int abs(int x)
{
if(x < 0)
x = -x;
return x;
}
, x
abs.
stepen :
double stepen(double osnova, double eksponent)
stepen stepen osnova
eksponent. :
main()
{
double u = 2.5;
double v = 3.0;
double x,y,w;
x=stepen(u,v);
/* Linija 1 */
y=stepen(2.0, 3.2); /* Linija 2 */
z=stepen(v, 7);
/* Linija 3 */
...
}
1 stepen u v. u
v stepen. , u osnova
v eksponent. u v
stepen 1 . 2,
stepen 2.0 3.2. 2.0
osnova 3.2 eksponent. , 3
.
:
.
, .
( )
. , ,
. .

:
tip_funkcije ime_funkcije(lista formalnih argumenata)
{
naredbe;
}

,
( ) .
, .
.
, a .
.
tip_funkcije
. (tip_funkcije)
(return type) . tip_funkcije int.
void, .
int ime_funkcije(lista formalnih argumenata)
double ime_funkcije(lista formalnih argumenata)
void ime_funkcije(lista formalnih argumenata)
ime_funkcije
.
, *,
tip_funkcije.
( void *).
double *treci_stepen(lista formalnih argumenata)
void *moja_funkcija(lista formalnih argumenata)
lista formalnih argumenata
, , .
. .
tip_funkcije ime_funkcije(tip_prom1 ime_prom1, tip_prom2 ime_prom2,..., tip_promN ime_promN)
float funPrimer(int a, double b)

.
tip_funkcije ime_funkcije()
( ) ,
, . .
.

.
tip_funkcije ime_funkcije(int a[], double b)
tip_funkcije ime_funkcije(int *c)
,
.
tip_funkcije ime_funkcije(int a[][10], double b)
return
,
return.

return izraz;
izraz ,
.
return ,
. , "
, . return.
.
. , float.
, ,
. float. manji.
a . :
float manji(float x, float y)

{
float pom; /* lokalna promenljiva*/
if(x<=y)
pom=x;
else
pom=y;
return pom;
}
O :
{
if(x<=y)
return x;
else
return y;
}
return , (
else) :
{
if(x<=y)
return x;
return y;
}
manji pom (pom
manji) .
x y , return
. return
".
manji , main.
#include<stdio.h>
main( )
{
float prvi, drugi, MinBroj;
/* Linija1 */
printf("Manji broj od 5 i 6 je %f\n", manji(5,6)); /* Linija2 */

printf("Unesite dva broja\n");
/* Linija3*/
scanf("%f %f", &prvi ,&drugi);
/* Linija4*/
MinBroj=manji(prvi, drugi);
/* Linija5 */
printf("Manji od brojeva %f i %f je %f\n", prvi, drugi, MinBroj); /* L6 */
printf("Manji od brojeva %f i %f je %f\n", 0.9, drugi, manji(0.9, drugi));
}
:
Manji broj od 5 i 6 je 5.000000
Unesite dva broja
8 2
Manji od brojeva 8.000000 i 2.000000 je 2.000000
Manji od brojeva 0.900000 i 2.000000 je 0.900000
manji(5,6) 2 , 5 6 .
manji(prvi, drugi) 5 ( ), prvi drugi
. manji(0.9, drugi) 7 ,
0.9 drugi .

:
MinBroj=manji(float prvi, float drugi);
MinBroj=manji(float prvi, 0.9);
MinBroj=manji(float prvi, float 0.9);
!
/* Greska, ne treba navoditi tip */
void return izraz. , return

.
poruka
a a=1 poruka A
poruka B. , void
.
void poruka(short int a)
{
if(a==1)
{
printf("neka poruka A\n")
return ; /* Nema izraza!*/
}
printf("neka poruka B\n")
return ;
}
, void, return .
else return "
o .
void (
). :
void poruka(short int a)
{
if(a==1)
{
printf("neka poruka A\n")
return ; /* Nema izraza!*/
}
printf("neka poruka B\n")
}
( )
,
. , manji main?
,
main () manji manji
main.
main .
, , .
(
main)
( ).
- (;)
tip_funkcije
ime_funkcije(lista formalnih argumenata);
manji :
float manji(float x, float y);
.
. :
float manji(float , float );
:
#include<stdio.h>
/* Prototip funkcije*/
float manji(float x, float y);
main( )
{
float prvi, drugi, MinBroj;
/*ili float manji(float , float ); */
/* Linija1 */
printf("Manji broj od 5 i 6 je %f\n", manji(5,6)); /* Linija2 */

printf("Unesite dva broja\n");
/* Linija3*/
scanf("%f %f", &prvi ,&drugi);
/* Linija4*/
MinBroj=manji(prvi, drugi);
/* Linija5 */
printf("Manji od brojeva %f i %f je %f\n", prvi, drugi, MinBroj); /* L6 */
printf("Manji od brojeva %f i %f je %f\n", 0.9, drugi, manji(0.9, drugi));
}
{
if(x<=y)
return x;
else
return y;
}
/* Moze i bez else */
1 7 main manji .
.
( )
.
. manji main
.

.
C .
.
.

float proba(int x)
{
if(x< 5)
return 2.0*x;
}
float float.
x=2, o x<5 return 4.0. ,
x=10? x=10 x<5 return 2.0*x,
, .
:
float proba(int x)
{
if(x< 5)
return 2.0*x;
return x;
}
.
- void
Void .
. Void .
tip_funkcije return
. , void return ,
. ,
void .
Void
void :
void ime_funkcije()
{
naredbe
}
.
void :
ime_funkcije();

( void ).
.
#include<stdio.h>
void upozorenje();
#include<stdio.h>
main( )
{
float prvi;
int pom;
printf("Unesite broj manji od 45.00\n");
pom=0;
do
{
scanf("%f", &prvi);
if(prvi >45.0)
{
upozorenje();
pom=1;
}
else
{
printf("Uneti broj je manji od 45\n");
pom=0;
}
}while(pom !=0);
}
void upozorenje()
{
printf("_________________________________________________\n");
printf("Ponovite unos. Niste uneli odgovarajucu vrednost!\n");
printf("_________________________________________________\n");
}
Void
void :
void ime_funkcije(lista formalnih argumenata)
{
naredbe
}
.
lista formalnih argumenata
. .
.
10
void
ime_funkcije(tip_prom1 ime_prom1,tip_prom2 ime_prom2,...,tip_promN ime_promN)
void
ime_funkcije(int a, double b)
void :
ime_funkcije(lista stvarnih argumenata);
.
, void
.

. , .
.
.
, , :
1. (value arguments)
2. (reference arguments)
K ,
.
.
:
float moja_funk(float c);
#include<stdio.h>
main( )
{
float a, b;
printf("Unesite broj\n");
scanf("%f", &a);
printf("Vrednost promenljive pre poziva funkcije je =%f\n", a);
b=moja_funk(a);
printf("Vrednost promenljive nakon poziva funkcije je =%f\n", a);
printf("Povratna vrednost funkcije je %f\n", b);
}
float moja_funk(float c)
{
c=c*c;
return c+5.4;
}
11

Unesite broj
6.4
Vrednost promenljive pre poziva funkcije a=6.400000
Vrednost promenljive nakon poziva funkcije a=6.400000
Povratna vrednost funkcije je 46.360001
.
6.4 .
.
,
.
#include<stdio.h>
void moja_funk(float *c); /* deklaracija funkcije*/
/* argument je pokazivac na promen. tipa float*/
main( )
{
float a;
printf("Unesite broj\n");
scanf("%f", &a);
printf("Vrednost promenljive pre poziva funkcije a=%f\n", a);
moja_funk(&a); /* prenosi se adresa promenljive a */
printf("Vrednost promenljive nakon poziva funkcije a=%f\n", a);
}
void moja_funk(float *c)
{
printf("Vrednost promenljive na ulasku u funkciju je a=%f\n", *c);
*c=512.5;
printf("Vrednost promenljive pre izlaska iz funkcije je a=%f\n", *c);
return;
}
:
Unesite broj
6.4
Vrednost promenljive
pre poziva funkcije a=6.400000

na ulasku u funkciju je a=6.400000
pre izlaska iz funkcije je a=512.500000
nakon poziva funkcije a=512.500000
,
.
,
( ) .
, ,
.
, .
. ,

.
12
:
#include<stdio.h>
void funJedan(int a, int *b, char v);
void funDva(int *x, int y, char *w);
main( )
{
int num1, num2;
char ch;
num1=10;
/* Linija 1*/
num2=15;
/* Linija 2*/
ch='A';
/* Linija 3*/
printf("Linija 4: Unutar funk. main
funJedan(num1, &num2, ch); /* Linija
funDva(&num2, 25, &ch);
/* Linija
}
num1=%d, num2=%d, ch=%c\n",num1,num2,ch);

5*/
7*/
void funJedan(int a, int *b, char v)

{
int jedan;
jedan=a;
/* Linija 9*/
a++;
/* Linija 10*/
*b=(*b)*2;
/* Linija 11*/
v='B';
/* Linija 12*/
printf("Linija 13: Unutar funJedan
}
void funDva(int *x, int y, char *w)
{
(*x)++;
/* Linija 14*/
y=y*2;
/* Linija 15*/
*w='G';
/* Linija 16*/
printf("Linija 17: Unutar funDva
}
a=%d, *b=%d, v=%c\n",a,*b,v);
*x=%d, y=%d, *w=%c\n",*x,y,*w);
:
Linija 4: Unutar funk. main num1=10, num2=15, ch=A
Linija 13: Unutar funJedan
a=11, *b=30, v=B
Linija 6: Unutar funk. main num1=10, num2=30, ch=A
Linija 17: Unutar funDva
*x=31, y=50, *w=G
Linija 8: Unutar funk. main num1=10, num2=31, ch=G
1 () main. Ta
( ).
3 1
( ):
13
main
10
adresa:1200
ime: num1
.
.
.
15
adresa:1430
ime: num2
.
.
.
A
adresa:1620
ime: ch
.
.
.
1
4
Linija
4: Unutar funk. main num1=10, num2=15, ch=A
5 funJedan. funJedan int a, int *b,

char v int jedan.
. , b,
b .
. 5 2.
main
adresa:1200
funJedan
10
ime: num1
.
.
.
adresa:1430
15
A
.
.
.
ime:
.
.
1430
ime: num2
.
.
.
adresa:1620
10
.
.
A
ime: ch
ime: b
ime: v
.
??
ime: jedan
.
.
2
9, jedan=a; 3.
14
main
funJedan
10
adresa:1200
ime: num1
.
.
.
15
adresa:1430
ime:
.
.
1430
ime: num2
.
.
.
adresa:1620
10
.
.
A
ime: ch
ime: v
.
10
.
.
.
ime: b
ime: jedan
3
10 (++):
main
funJedan
10
adresa:1200
ime: num1
.
.
.
15
adresa:1430
ime:
.
.
1430
ime: num2
.
.
.
adresa:1620
11
.
.
A
ime: ch
ime: v
.
10
.
.
.
ime: b
ime: jedan
4
*b=(*b)*2; 11
main
adresa:1200
funJedan
10
ime: num1
.
.
.
adresa:1430
30
A
.
.
.
ime:
.
.
1430
ime: num2
.
.
.
adresa:1620
11
.
.
A
ime: ch
ime: b
ime: v
.
10
ime: jedan
15
v='B' 12
main
adresa:1200
funJedan
10
ime: num1
.
.
.
adresa:1430
30
ime:
.
.
1430
ime: num2
.
.
.
adresa:1620
11
ime: b
.
.
B
ime: v
ime: ch
ime: jedan
10
.
.
.
13
Linija 13: Unutar funJedan
a=11, *b=30, v=B
13 funJedan
6 main . main!
Me funJedan
.
main
adresa:1200
10
ime: num1
.
.
.
adresa:1430
30
ime: num2
.
.
.
adresa:1620
ime: ch
.
.
.
7
6
Linija
6: Unutar funk. main num1=10, num2=30, ch=A
7 funDva. funDva : x, y w. x, w
y .
14 :
16
main
funDva
10
adresa:1200
ime: num1
1430
.
.
.
.
.
30
adresa:1430
25
ime: num2
1620
ime: y
.
.
.
.
.
adresa:1620
ime: x
ime: w
ime: ch
.
.
.
8
14, (*x)++
main
funDva
10
adresa:1200
ime: num1
1430
.
.
.
31
adresa:1430
.
.
25
ime: num2
ime: y
.
.
.
.
.
adresa:1620
ime: x
1620
ime: w
ime: ch
.
.
.
9
num2. 15 (y=y*2)
main
adresa:1200
funDva
10
ime: num1
.
.
.
adresa:1430
31
ime: x
.
.
50
ime: num2
.
.
.
adresa:1620
1430
.
.
1620
ime: ch
ime: y
ime: w
.
.
.
10
17
16 (*w='G')
main
adresa:1200
funDva
10
ime: num1
.
.
.
adresa:1430
31
ime: x
.
.
50
ime: num2
.
.
.
adresa:1620
1430
ime: y
.
.
1620
ime: w
ime: ch
.
.
.
11
17
Linija 17: Unutar funDva
*x=31, y=50, *w=G
17 j funDva 8 main.
funDva .
main
main
adresa:1200
10
ime: num1
.
.
.
adresa:1430
31
ime: num2
.
.
.
adresa:1620
ime: ch
.
.
.
12
8
Linija
8: Unutar funk. main num1=10, num2=31, ch=G
8 .
18

.
. .
.
, .
, .
, , ,
. .
n n! :
n! =n*(n-1)*(n-2)*(n-3)*...*1

1! = 1
0! = 1
:
5! = 5*4*3*2*1= 120
broj for :
faktorijel = 1;
for(i=broj; i>=1; i--)
{
faktorijel *= i;
/*
}
faktorijel = faktorijel * i;
*/
:
:
5! = 5*4*3*2*1= 5*(4*3*2*1) = 5*(4!)
4!= 4*3*2*1=4*(3*2*1) = 4*(3!)
3! = 3*2*1=3*(2*1) = 3*(2!)
2! = 2*1=2*(1) = 2*(1!)
1! = 1
...

long faktorijel(long broj)
{
/* ako je broj 0 ili 1, 0!=1 i 1!=1 */
if( broj <= 1 )
{
return 1; /* vrati 1 i zavrsi rada sa funkcijom */
} /* kraj if */
else /* jedan korak rekurzije */
{
return (broj * faktorijel(broj - 1) ); /* rekurzivni poziv funkcije
} /* kraj else */
*/
} /* kraj funkcije faktorijel */

faktorijel 0 1, faktorijel
1 ( return 1), . , (
19
faktorijel(n), n 0 n 1)
( faktorijel(n-1)),
, . n=1.
faktorijel(4). To
faktorijel(4)) = 24
return 4*6
faktorijel(4)
broj=4
je broj>1
return (4 * faktorijel(3));
return 3*2
faktorijel(3)
broj=3
je broj>1
return 2*1
faktorijel(2)
broj=2
je broj>1
return 1
faktorijel(1)
broj=1
je broj==1
return 1;
13
20
,
.
( ) ,
() .
,
.
()
( )
.
. , . ".
,
.
:
float mojaFun(int x);
main()
{
int a, b;
float c
...
a=4;
c=mojaFun(a);
}
float mojaFun(int x)
{
int c
double a
float b
...
return b;
}
mojaFun main
. , ,
.
, () .
() ( ).
() .

.
.

( ) . ,
, . .
, . .
21
:
#include<stdio.h>
void funOne(int *a,int *b);
int t; /* Globalna promenljiva*/
main( )
{
int num1, num2;
num1=10; /* L1 */
num2=20; /* L2 */
t=15;
/* L3 */
printf("L 4: Funk. main: num1=%d, num2=%d, t=%d\n",num1,num2,t);

/* L4 */
funOne(&num1,&t);
/* L5 */
printf("L 6: Funk. main posle funOne: num1=%d, num2=%d, t=%d\n",num1,num2,t);
}
void funOne(int *a, int *x)
{
int z;
z=*a + *x;
/* L7 */
printf("L 8: FunOne a=%d,

*x=*x+5;
*a=*a+12;
t=t+13;
}
x=%d, z=%d, t=%d\n",*a,*x,z,t);

x=%d, z=%d, t=%d\n",*a,*x,z,t);
x=%d, z=%d, t=%d\n",*a,*x,z,t);
x=%d, z=%d, t=%d\n",*a,*x,z,t);
/*
/*
/*
/*
/*
/*
/*
L8
L9
L10
L11
L12
L13
L14
*/
*/
*/
*/
*/
*/
*/
:
Linija
4: Unutar funk. main: num1=10, num2=20, t=15
Linija
8: Unutar funOne a=10, x=15, z=25, t=15
Linija 10: Unutar funOne a=10, x=20, z=25, t=20

Linija
6: Unutar funk. main posle funOne: num1=22, num2=20, t=33
t .
,
. funOne .
5, main, funOne num1 t
. , funOne, num1
x, t. x
22
num1 t. t ,

13.

,
:
1. : ( ).
()
2. : .
:
a. ,
b. ,
c.
d. ( )
.
, .
.
, .
.
(linking) .
.
, .

.
.

, .
. (extern) .
23
:
fajl1.c
#include <stdio.h>
extern int brojac;
int rezultat=2;
/* deklaracija promenljive koja je definisana kao

globalna promenljiva u dugom fajlu */
/* definicija globalne promenljive */
void funkcija_1();
/* deklaracija (prototip) funkcije */
int main()
{
int i;
i=4;
/* pocetak funkcije main */
printf("M3: brojac=%d, rezultat=%d\n", brojac, rezultat);

rezultat++;
brojac=rezultat*i;
funkcija_1(); /* poziv funkcije */
return 0;
}
fajl2.c
#include <stdio.h>
extern int rezultat;
int brojac=0;
/* deklaracija promenljive koja je definisana kao

globalna promenljiva u dugom fajlu */
/* definicija i inicijalizacija globalne promenljive */
/* definicija funkcije */
void funkcija_1()
{
printf("F1: brojac=%d, rezultat=%d\n", brojac, rezultat);
rezultat=5;
brojac=1;
printf("F4: brojac=%d, rezultat=%d\n", brojac, rezultat);
return;
} /* kraj funkcije */
,
. brojac fajl2 rezultat
fajl1. Ka
extern.
.
( extern) .

extern (. extern int rezultat;). .
24
C
8
....................................................................................... 2
( #include) ....................................................................... 2
( #define) ...................................................................... 3
................................................................................ 3
- .......................................................................................................... 5
( #if, #ifdef, ...) ................................................................. 6
....................................................................................... 10

C .
.
.
:
( )
() #.
.
, .
,
.
,
C.
; .
, .
. ,
.
NSI :
#include
#define
#if
#ifdef
#ifndef
#elif
#else
#endif
#undef
( #include)
() :
#include ime fajla
#include <ime fajla>
( ),
.
< > ( )
() .
#include.
.h ( header) . C
, ,
. (stdio.h, math.h
string.h ...). .
, ,
, , (extern) .
#include
.
.
,
( .c).
( #define)
#define -.

:
#define SIMBOLICKA_KONSTANTA ZnakovniNiz
:
#define PI
3.1415926
#define NASLOV "Programski jezik C"

#define ZAUVEK for( ; ;)
:
#define SIMBOLICKA_KONSTANTA ZnakovniNiz SIMBOLICKA_KONSTANTA
ZnakovniNiz. (SIMBOLICKA_KONSTANTA)
.
:
#include<stdio.h>
#define PI 3.1415926
main()
{
float a;
float r=4.23;
char ch[ ]="PILICI"; /* slogovi PI LI CI */
/* L3 */
a=2*r*PI;
/* L5 */
printf("Niz ch je %s a obim a je %f\n ",ch,a);
}
Niz ch je PILICI a obim a je 26.577874

3 #define. , (PILICI)
ch (PI)
(3.1415926), , . 5
(PI) (3.1415926).

.
:
#include <stdio.h>
#define WIDTH
#define LENGTH
80
( WIDTH + 10 )
/* L1 */
/* L2 */
main()
{
int var;
var = LENGTH * 20; /* var = ( 80 + 10 ) * 20; */
printf("var=%d\n",var)...
}
var=1800
2 (WIDTH) 1.
:
#include <stdio.h>
#define WIDTH
80
main()
{
int x=2,y;
y=WIDTH*x;
printf("Vrednost y=%d\n",y);
}
Vrednost y=160

:
#undef SIMBOLICKA_KONSTANTA
#undef
, .
include <stdio.h>
#define WIDTH
80
main()
{
int x=2,y;
y=WIDTH*x;
printf("Vrednost y=%d\n",y);
#undef WIDTH
y=WIDTH; /* GRESKA! 'WIDTH': undeclared identifier */
}
-
- :
#define IME(param_a, param_b,...) Lista_znakovnih _nizova
IME -, param_a, param_b,... ,
Lista_znakovnih _nizova
- .
- , .
,
. -
.
:
#include<stdio.h>
#define MAX(a, b) a>b ? a : b
main()
{
int broj_a, broj_b;
printf("Odredjivanje maksimuma dva broja\n\n");
printf("Upisite dva broja razdvojena zarezom\n");
scanf("%d,%d",&broj_a,&broj_b);
printf("Veci broj je: %d\n",MAX(broj_a,broj_b));
}
Odredjivanje maksimuma dva broja

Upisite dva broja razdvojena zarezom
4,9
Veci broj je: 9
- .
.
:
#include<stdio.h>
#define KVADRAT(a) a*a
main()
{
int broj_a;
broj_a=8;
printf("\n%d * %d = %d\n",broj_a,broj_a,KVADRAT(broj_a));
printf("\n%d * %d = %d\n",broj_a+1,broj_a+1,KVADRAT(broj_a+1));
}
8 * 8 = 64
9 * 9 = 17
. ,
: 8+1*8+1, 17. #define
:
#define KVADRAT(a) ((a)*(a))
( #if, #ifdef, ...)

(
header-) , .
.
,
(printf ), .
.
:
#if uslov
O uslov . .
uslov , #if uslov .
uslov define
.
:
#define VERZIJA 1.1
#define TESTIRANJE
TESTIRANJE ,
( space). M
#define :

#ifdef TESTIRANJE
je ("1") #define TESTIRANJE ("0")
#define TESTIRANJE
#undef TESTIRANJE. #ifdef TESTIRANJE "
TESTIRANJE ".
:
#ifndef TESTIRANJE
" TESTIRANJE "
(e #if, #ifdef #ifndef) ( )
#lif uslov #lse ,
, #ndif. lse if
lse C.
#if, #ifdef #ifndef .
#if #ndif.
#lif #lse . #lse
#ndif.
:
#include<stdio.h>
#define TST
#define DAN 2
main()
{
#ifdef TST
int a=5;
#endif
#if (DAN==1)
printf("Ponedeljak\n");
#elif (DAN==2)
printf("Utorak\n");
#else
printf("Nije ni ponedeljak ni utorak\n");
#endif
#ifdef TST
a=a+7;
printf("Vrednost a= %d\n",a);
#endif
printf("DAN je %d\n",DAN);
}
Utorak
Vrednost a= 12
DAN je 2
TST ( #define TST)
2, 12 13. DAN 2,
: printf("Utorak\n");
( ) DAN

#include<stdio.h>
#define TST
#define DAN 5
main()
{
#ifdef TST
int a=5;
#endif
#if (DAN==1)
#elif (DAN==2)
printf("Utorak\n");
#else
#endif
#ifdef TST
a=a+7;
#endif
}
Nije ni ponedeljak ni utorak

Vrednost a= 12
DAN je 5
TST :
#ifdef TST
int a=5;
#endif

#ifdef TST
a=a+7;
#endif

:
#include<stdio.h>
#define DAN 2
main()
{
#ifdef TST
int a=5;
#endif
#if (DAN==1)
#elif (DAN==2)
printf("Utorak\n");
#else
#endif
#ifdef TST
a=a+7;
#endif
}
Utorak
DAN je 2

ANSI C
( ).
() (underscores).
#defined #undefined .

__LINE__
( )
__FILE__
. ()
.
__DATE__
( Mmm dd yyyy, Mmm

Apr Sep , dd yyyy
)
__TIME__
( hh:mm:ss )
:
.
#include <stdio.h>
int main()
{
printf("Upotreba konstante __LINE__\n");
printf("\tTrenutno se nalazim u %d liniji koda\n", __LINE__);
printf("\nUpotreba konstante __DATE__\n");
printf("\tDatum prevodjenja programa je: %s\n",__DATE__ );
printf("\nUpotreba konstante __TIME__\n");
printf("\tVreme prevodjennja programa je: %s\n",__TIME__ );
printf("\nUpotreba konstante __FILE__\n");
printf("\tProgram je zapisan u fajlu %s\n",__FILE__ );
}
return 0;
10
.

. :
(4.0 / 3) r 3 , = 3.14159
#include <stdio.h>
#define PI 3.14159
#define ZAPREMINA_LOPTE(r)
(4.0/3)*PI*(r)*(r)*(r)
int main()
{
float rezultat;
intpprecnik;
printf("plouprecnik
Zapremina lopte\n");
printf("________________________________\n");
for(pprecnik=1;pprecnik<11;pprecnik++)
{
rezultat=ZAPREMINA_LOPTE(pprecnik);
printf("%11d\t%9.2f\n",pprecnik, rezultat);
}
printf("________________________________\n\n");
}
return 0;
11
C
9
............................................................................................................................ 2
.................................................................................................... 5
................................................................. 5
....................................................................................................... 8
............................................................................................. 10

4 j , .
. ,
. , .
.
. , ,
, , . ,
. C
.
:
struct ime_strukture
{
tip_podatka ime_podatka1;
tip_podatka ime_podatka2;
.
.
.
tip_podatka ime_podatkaN;
};
struct , ime_strukture
. ,
";" .
.
:
struct student
{
char prezime[20];
char ime[20];
char dat_rodj[8];
int god_studija;
float prosecna_ocena;
};
struct
.
struct, ( student)
.
,
.
.
(. student)
struct.
:
struct student stud_pod;
struct student stud_novi;
O stud_pod
stud_novi student.
1.
stud_pod
stud_novi
prezime
prezime
ime
ime
dat_rodj
god_studija
Prosecna_ocena
dat_rodj
god_studija
?
?
Prosecna_ocena
?
?
?
1
stud_pod stud_novi .
.
.
:
struct student
{
char prezime[20];
char ime[20];
char dat_rodj[8];
int god_studija;
} stud_pod;

student stud_pod.
:
struct student
{
char prezime[20];
char ime[20];
char dat_rodj[8];
int god_studija;
} stud_pod, stud_novi;
C,
. .
:
struct datum
{
int dan;
int mesec;
int godina;
};
struct radnik
{
char prezime[20];
char ime[20];
struct datum datum_rodjenja;
struct datum datum_namestenja;
} Novi_zaposleni;
novi_zaposleni
prezime
ime
datum_rodjenja
dan
mesec
godina
dan
mesec
godina
datum_namestenja
2
: datum radnik. radnik datum
. datum .
C !
:
struct
{
int dan;
int mesec;
int godina;
} datum_rodjenja, datum_namestenja;

( datum_rodjenja, datum_namestenja).
,
.
. student
st_prve_godine ( 250) :
struct student st_prve_godine[250]
st_prve_godine
250
(st_prve_godine[0],..., st_prve_godine[249])
student.
st_prve_godine
[1]
[2]
[3]
.
.
.
[248]
[249]
student
prezime
ime
dat_rodj
god_studija
Prosecna_ocena
3
(
) .
(int, char,
float...).

C :
. ->
O &
sizeof
.

:
.
.
, . ->
:
struct student
{
char prezime[20];
char ime[20];
char dat_rodj[8];
int god_studija;
};
struct datum
{
int dan;
int mesec;
int godina;
};
main()
{
struct student stud_novi;
struct datum datum_rodjenja;
...
stud_novi.prezime[0]='B';
stud_novi.god_studija=4;
sud_novi.prosecna_ocena=7.82;
...
datum_rodjenja.dan=14;
datum_rodjenja.godina=1983;
...
}
( 0) prezime stud_novi
'B'. god_studija
stud_novi 4 .
,
.
, .

.
:
struct datum
{
int dan;
int mesec;
int godina;
};
main()
{
struct datum datum_rodjenja,
struct datum *point_struk_datum;
point_struk_datum= &datum_rodjenja;
point_struk_datum->dan=27;
point_struk_datum->mesec=6;
point_struk_datum->godina=1952;
printf(\nMesec rodjenja je %d \n, datum_rodjenja.mesec);
}
:
Mesec rodjenja je 6
datum
datum_rodjenja (struct datum datum_rodjenja) datum.
point_struk_datum datum.
point_struk_datum .
:
point_struk_datum= &datum_rodjenja;
dan datum_rodjenja 27.
->
. . ,
:
(*point_struk_datum).dan=27;
point_struk_datum , .
*.

(point_struk_datum+1 point_struk_datum++) ,
.
.
:
struct datum
{
int dan;
int mesec;
int godina;
}dan_u_godini={21,10,1968};
datum,
dan_u_godini datum.
:
struct datum
{
int dan;
int mesec;
int godina;
};
main()
{
struct datum dan_u_godini={21,10,1968};
...
}
datum
dan_u_godini datum.

,
, .

:
:
struct student
{
char prezime[20];
char ime[20];
char dat_rodj[11];
int god_studija;
};
main()
{
struct student prvi={Petrovic,Marko, 02.10.1983,1,8.96}; /* L1*/
struct student drugi;
...
drugi=prvi;
/* L3*/
...
}
1 prvi 4.
drugi
prvi
Petrovic
prezime
ime
Marko
prezime
ime
dat_rodj
02.10.83
dat_rodj
god_studija
god_studija
Prosecna_ocena
?
?
Prosecna_ocena
8.96
?
4
3 i drugi=prvi; drugi prvi,

5.
drugi
prvi
Petrovic
prezime
ime
Marko
prezime
Petrovic
ime
Marko
dat_rodj
02.10.83
dat_rodj
02.10.83
god_studija
god_studija
Prosecna_ocena
8.96
Prosecna_ocena
8.96

, .
.
:
struct lista_jedna
{
int dan;
int mesec;
int godina;
struct lista_jedna *point_na_listu;
};
lista_jedna .
struct lista_jedna *point_na_listu; point_na_listu
. , ,
.
.
(node). ( )
. :
(data) (link). ,
.
: head () prvi.
adresa
podatak
7.
,
.

rvi
45
65
34
76
8.
(link)
. .
0 (NULL), .
1200 1575 .
:
1200
rvi
1200
45
1575
1575
65
10
( ) .
, ,
.
:
struct lista_jedna
{
int dan;
struct lista_jedna *point_na_listu;
};

struct lista_jedna *prvi
(
1200).

:
struct lista_jedna
{
int podatak;
struct lista_jedna *sled_adresa;
};

struct lista_jedna *prvi
.
10.
prvi
2000
2000
17
2800
2800
92
1500
1500
podatak sled_adresa podatak sled_adresa
63
3600
3600
podatak sled_adresa
45
podatak sled_adresa
10
4 . prvi. ()
: podatak sled_adresa
. (
) int.
, 2000, 2800, 1500 3600.
prvi 2000, sled_adresa 2800,
sled_adresa 1500, . 0 (NULL) a sled_adresa
. .

11

prvi
2000
prvi->podatak
17
prvi->sled_adresa
2800
prvi->sled_adresa->podatak
92
prvi 2000
podatak 17
prvi->sled_adresa 2800
podatak 2800 92
tekuci
prvi.
struct lista_jedna *tekuci;
tekuci=prvi;
11:
prvi
2000
2000
17
tekuci
2800
2800
92
1500
1500
podatak sled_adresa podatak sled_adresa
63
3600
3600
45
podatak sled_adresa
podatak sled_adresa
2000
11
11
tekuci
2000
tekuci->podatak
17
tekuci ->sled_adresa
2800
tekuci ->sled_adresa->podatak
92

tekuci=tekuci->sled_adresa;
tekuci->sled_adresa ( 2800), tekuci.
tekuci .
12:
12
prvi
2000
2000
17
2800
2800
92
podatak sled_adresa
tekuci
1500
1500
podatak sled_adresa
63
3600
3600
podatak sled_adresa
45
podatak sled_adresa
2800
12
tekuci
2800
tekuci->podatak
92
tekuci->sled_adresa
1500
tekuci->sled_adresa->podatak
63
prvi :
prvi->sled_adresa->sled_adresa
1500
prvi->sled_adresa->sled_adresa->podatak
63
prvi->sled_adresa->sled_adresa->sled_adresa
3600
prvi->sled_adresa->sled_adresa->sled_adresa ->podatak
45
tekuci->sled_adresa->sled_adresa
3600
tekuci->sled_adresa->sled_adresa->podatak
45
tekuci->sled_adresa->sled_adresa->sled_adresa
0 (NULL)
tekuci->sled_adresa->sled_adresa->sled_adresa->podatak
? ( )
( )
()

. prvi
sled_adresa NULL. prvi ,
,
! (prvi
sled_adresa)
. prvi ,
( ),
.
prvi ,
. tekuci prvi.
:
13
:
tekuci=prvi;
while(tekuci != NULL)
{
/* obrada cvora na koji ukazuje pokazivac tekuci */
tekuci= tekuci-> sled_adresa;
/* prelazak na sledeci cvor*/
}
prvi
.
tekuci=prvi;
while(tekuci != NULL)
{
/* obrada cvora na koji ukazuje pokazivac tekuci */
printf("vrednost podatka je %d\n", tekuci -> podatak );
tekuci= tekuci-> sled_adresa;
/* prelazak na sledeci cvor*/

( podatak,
. int).
struct jedna_lista
{
int podatak;
struct jedna_lista *sled_adresa;
};
, :
struct jedna_lista
*prvi, *p, *novi_cvor,

13.
prvi
17
92
podatak sled_adresa
podatak sled_adresa
63
podatak sled_adresa
45
podatak sled_adresa
13
p 92 50
p. :
14
novi_cvor = malloc(sizeof(jedna_lista));
novi_cvor -> podatak=50;
/* kreiranje novog cvora */

/* upisi 50 u novi cvor */
(novi_cvor = malloc(sizeof(jedna_lista))) , ,
(novi_cvor).
(novi_cvor -> podatak=50;) 50 podatak ( 14).
prvi
17
92
podatak sled_adresa
63
podatak sled_adresa
45
podatak sled_adresa
podatak sled_adresa
p
50
podatak sled_adresa
novi_cvor
14
:
novi_cvor -> sled_adresa = p -> sled_adresa;
p -> sled_adresa = novi_cvor;
(novi_cvor -> sled_adresa = p -> sled_adresa)
prvi
17
podatak sled_adresa
92
63
podatak sled_adresa
podatak sled_adresa
45
podatak sled_adresa
p
50
novi_cvor
podatak sled_adresa
15
(p -> sled_adresa = novi_cvor;)
16.
15
prvi
17
92
podatak sled_adresa
63
podatak sled_adresa
podatak sled_adresa
45
podatak sled_adresa
p
50
podatak sled_adresa
novi_cvor
16

17.
prvi
17
92
podatak sled_adresa
podatak sled_adresa
63
podatak sled_adresa
45
podatak sled_adresa
17
63.
:
p -> sled_adresa = p -> sled_adresa -> sled_adresa;
18.
prvi
17
92
podatak sled_adresa
podatak sled_adresa
63
podatak sled_adresa
45
podatak sled_adresa
18
16

( int)
.
2 15 8 24 34
:
#include<stdio.h>
#include<malloc.h>
struct jedna_lista
{
int podatak;
struct jedna_lista
};
*sled_adresa;
main()
{
1 struct jedna_lista *prvi, *poslednji, *novi_cvor;
2 int vrednost[5]={2,15,8,24,34};
3 int i;
4
5
6
7
8
9
10
11
12
13
14
15
16
prvi=NULL;
poslednji=NULL;
novi_cvor=NULL;
for(i=0; i<5; i++)
{
novi_cvor = malloc(sizeof(struct jedna_lista));
if(novi_cvor)
{
novi_cvor->podatak=vrednost[i];
novi_cvor->sled_adresa=NULL;
}
else
break;
17
if(prvi==NULL) /* ako je lista je prazna */
18
{
19
prvi=novi_cvor;
20
poslednji=novi_cvor;
21
}
22
else
23
{
24
poslednji->sled_adresa=novi_cvor;
25
poslednji=novi_cvor;
26
}
28 }
29 }
4, 5 6 19
17
prvi
pslednji
novi_cvor
ji
19
9, ,
novi_cvor, novi_cvor->podatak=vrednost[i];
2. novi_cvor->sled_adresa=NULL;
() , .
(prvi) (prvi=NULL),
prvi=novi_cvor; poslednji=novi_cvor; 20.
prvi
pslednji
2
podatak sled_adresa
novi_cvor
ji
20
...
18
C
10
........................................................................................................................ 2
/ ....................................................................................... 2
/ ....................................................................................................................... 2
.............................................................................................................. 3
................................................................................................................................ 3
............................................................................................................................... 4
............................................................................................................ 5
................................................................................................... 10
............................................................................................................. 10
............................................................................................................ 13

(/ Input/Output I/O),
C, .
,
.
,
() .
. , , .
.
/

(temporary data).
, .
o .
.

. , ,
.

editor .

.
.
,
.
/
(reading) ,
(writing) .
:
,

(),
(\n) .
() (, ,
.). (),
,
(). ,
.

. ,
.
.
/
, :
#include<stdio.h>
stdio.h .
C :
(stdin) .
(stdut) .
(stderr) .
stdio.h
,
.
:
,
,

.
.
(struct)
: , .
.

.

.

/ .
,
, ,
( .) .
, ,
FILE. FILE stdio.h. FILE
, DOS Windows
struct _iobuf
{
char _ptr;
int
_cnt;
char *_base;
int
_flag;
int
_file;
} FILE;
/*
/*
/*
/*
/*
trenutna pozicija pokazivaca */

trenutno stanje broja bajtova */
polazna adresa rezerv. memorije */
indikator */
brojna oznaka fajla */

#include<stdio.h>
:
FILE
*ptr_ime;
ptr_ime .
, .
( ) , .
fopen ():
FILE *fopen(const char *ime_fajla, const char *mod_rada);
ime_fajla je ( ) ,
(path). ,
.
mod_rada . :
r (read) . .
w (write) . ,
.
a (append), .
.
r+ . .
w+ .
.
.
a+ .
.
.
.
b.
:
"rb", "wb","ab", "rb+", "wb+","ab+"
, .
, fopen (NULL) stdio.h.
,
"w", "w+","wb" "wb+" .

()
.
( ),
.
, , fclose, :
int fclose(FILE *ptr_fajl);
fclose :
0
.
( ) .
fclose
() .
.
:
#include <stdio.h>
void main( void )
{
FILE *ptr_file1, *ptr_file2;
int broj_zatvorenih;
ptr_file1=NULL;
ptr_file2=NULL;
/* Otvori za citanje (ukoliko fajl "data1.txt" ne postoji sledi ERROR) */
if((ptr_file1 = fopen("data1.txt", "r" )) == NULL )
printf( "Fajl 'data1.txt' NIJE otvoren\n" );
else
printf( "\nFajl 'data1.txt' je otvoren \n" );
/* Otvori fajl za citanje i upis */
if((ptr_file2 = fopen( "data2.txt", "w+" )) == NULL )
printf("Fajl 'data2.txt' NIJE otvoren\n" );
else
printf("Fajl 'data2.txt' je otvoren\n" );
/* Zatvori drugi fajl */
if( fclose(ptr_file2 ) )
printf( " Fajl 'data2.txt' NIJE zatvoren\n " );
else
printf( " Fajl 'data2.txt' je zatvoren\n " );
/* Svi preostali fajlovi se zatvaraju: */
broj_zatvorenih = fcloseall( );
printf("Broj fajlova zatvorenih naredbom fcloseall je: \
%d\n",broj_zatvorenih);
}
:
Fajl 'data1.txt' je otvoren
Fajl 'data2.txt' je otvoren
Fajl 'data2.txt' je zatvoren
Broj fajlova zatvorenih naredbom fcloseall je: 1

.
fgetc
fgetc . :
int fgetc( FILE *ptr_fajl );
, , .
unsigned char int.
, fgetc EOF (End Of File).

EOF je -1.
:
: opis.txt :
80 .
#include <stdio.h>
void main( void )
{
FILE *ptr_ulaz;
char buffer[81];
int i, ch;
/* Otvori fajl za citanje: */
if( (ptr_ulaz = fopen( "opis.txt", "r" )) != NULL )
{
/* Procitaj prvih 80 karaktera i smesti ih u "buffer": */
for( i=0; (i < 80 ) && ( ch!=EOF); i++ )
{
ch = fgetc( ptr_ulaz );
buffer[i] = (char)ch;
}
/* Dodaj znak '\0' na kraj niza da bi formirao string */

buffer[i] = '\0';
printf( "%s\n", buffer );
fclose( ptr_ulaz ); /* zatvaranje fajla */
}
FGETC.C: This program uses getc to read the first

80 input characters (or until
fgetc getc.
getc , .
fputc
fputc . :
int fputc( int c, FILE
*ptr_fajl );
int c , int unsigned char

.

EOF .
fputc putc.
putc , .
:
#include <stdio.h>
void main( void )
{
FILE *ptr_out;
char niz[] = "Ovo je primer za fputc!\n";
int i;
/* Otvori fajl za upis: */
if( (ptr_out = fopen( "upis.txt", "w" )) != NULL )
{
/* Upisi sve podatke niz-a u fajl primenom fputc. */
i=0;
while(niz[i]!= '\0')
{
fputc(niz[i] , ptr_out )
i++;
}
}
:
fgets
fgets . fgets
(\n) n-1
. :
char *fgets( char *niz, int n, FILE *ptr_fajl );
char *niz ,
int n n-1.
FILE *ptr_fajl .

NULL .
:
ulaz.txt
#include <stdio.h>
void main( void )
{
FILE *ptr_ulaz;
char niz[50];
if( (ptr_ulaz = fopen( "ulaz.txt", "r" )) != NULL )
{
if( fgets( niz, 40, ptr_ulaz ) == NULL)
printf( "fgets error\n" );
else
printf( "%s\n", niz);
fclose( ptr_ulaz);
}
}
:
Ovo je primer za funkciju fgets. U ovom
39 (n=40).
fputs
fputs . .
:
int fputs(char *niz, FILE *ptr_fajl );
char *niz ,
FILE *ptr_fajl .

EOF .
:
#include <stdio.h>
void main( void )
{
FILE *ptr_out;
char niz[] = "Ovo je primer za fputs!";
/* Otvori fajl za upis: */
if( (ptr_out = fopen( "upis.txt", "w" )) != EOF )
{
/* Upisi sve podatke niz-a u fajl primenom fputs. */
fputs(niz, ptr_out);
}
fclose(ptr_out);
}
:

printf
scanf.
( ). fprintf fscanf
() ,
, .
:
#include <stdio.h>
FILE *ptr_fajl;
void main( void )
{
int
i = 10;
double fp = 1.5;
char
niz[] = "Ovo je jedan niz podataka";
char
karakter = '\n';
ptr_fajl = fopen( "izlaz.txt", "w" );
fprintf( ptr_fajl, "%s%c", niz, karakter );
fprintf( ptr_fajl, "%d\n", i );
fprintf( ptr_fajl, "%f\n", fp );
fclose( ptr_fajl );
}
:

fread fwrite.
fwrite
fwrite :
int fwrite( void *bafer, int velicina, int broj, FILE *ptr_ime );
fwrite (ptr_ime) broj . velicina
.
(bafer) . .
.
broj .
10 (int 4 ) niz1 fajl1.txt
:
fwrite( niz1, 4, 10, ptr_na_fajl );
10
:
#include <stdio.h>
void main( void )
{
FILE *ptr_izlaz;
int list[]={1,2,3,4,5,16,7,683,9,10,11,12,13,14};
int broj_upisanih;
/* Otvori fajl u binarnom modu */
if( (ptr_izlaz = fopen( "izlaz.txt", "wb" )) != NULL )
{
broj_upisanih = fwrite( list, sizeof( int ), 10, ptr_izlaz );
printf( "Upisano %d vrednosti\n", broj_upisanih );
fclose( ptr_izlaz);
}
else
printf( "Problem kod otvaranja fajla\n" );
}
:
Upisano 10 vrednosti
fread
fread :
int fread( void *bfer, int velicina, int broj, FILE *ptr_ime );
fread (ptr_ime) broj velicina
bfer .
.
.
broj .
11
:
void main( void )
{
FILE *ptr_izlaz, *ptr_ulaz;
int list1[]={1,2,3,4,5,16,7,683,9,10,11,12,13,14};
int list2[12];
int i, broj_upisanih, broj_procitanih;
/* Otvori fajl u binarnom modu */
if( (ptr_izlaz = fopen( "izlaz.txt", "wb" )) != NULL )
{
broj_upisanih = fwrite( list1, sizeof( int ), 10, ptr_izlaz );
printf( "Upisano %d vrednosti\n", broj_upisanih );
fclose( ptr_izlaz);
}
else
printf( "Problem kod otvaranja fajla za upis\n" );
if( (ptr_ulaz = fopen( "izlaz.txt", "rb" )) != NULL )
{
/* citanje 10 vrednosti */
broj_procitanih = fread( list2, sizeof( int ), 10, ptr_ulaz );
printf( "Broj procitanih vrednosti je = %d\n", broj_procitanih);
printf( "Sadrzaj niza list2 je \n");
for(i=0; i<10;i++)
printf( "%d ",list2[i]);
fclose( ptr_ulaz );
}
else
printf( "Problem kod otvaranja fajla za citanje\n" );
}
:
Upisano 10 vrednosti
Broj procitanih vrednosti je = 10
Sadrzaj niza list2 je
1 2 3 4 5 16 7 683 9 10
12
.
/ ,
.
.
.
o . ,
.
C :
( ) .
fseek
fseek . :
int fseek( FILE *ptr_ime, long offset, int origin );
fseek (ptr_ime) offset
origin.
origin :
SEEK_CUR:
SEEK_ND:
SEEK_SET:

,
.
fseek , !
13
:
#include<stdio.h>
void main( void )
{
FILE *ptr_fajl;
char linija[81];
int rezultat;
ptr_fajl = fopen( "izlaz.txt", "w+" );

if( ptr_fajl == NULL )
printf( "Fajl nije otvoren \n" );
else
{
fprintf( ptr_fajl, "Fajl pocinje ovde: Ovo je fajl 'izlaz.txt'.\n" );
rezultat = fseek( ptr_fajl, 19L, SEEK_SET);
if( rezultat )
printf( "Fseek neuspesna\n" );
else
{
printf( "Pokazivac fajla je postavljen na 19-to mesto.\n" );
fgets( linija, 80, ptr_fajl );
printf( "%s", linija );
}
fclose( ptr_fajl);
}
Pokazivac fajla je postavljen na 19-to mesto.

Ovo je fajl 'izlaz.txt'.
14
ftell
ftell . :
long ftell( FILE *ptr_ime);
ftell .
, .
:

FILE *p_fajl;
void main( void )
{
long pozicija;
char lista[10];
if( (p_fajl = fopen( "tekst.txt", "rb" )) != NULL )

{
/* Pomeri pokazivac citajuci podatke: */
fread( lista, sizeof( char ), 10, p_fajl );
/* Odredi poziciju nakon citanja: */
pozicija = ftell( p_fajl );
printf( "Pozicija nakon citanja 10 bajtova je: %ld\n",pozicija );
fclose( p_fajl );
}
:
Pozicija nakon citanja 10 bajtova je: 10
feof
feof
. :
int feof(FILE *ptr_ime);

15
1. (++)
/* Upotreba operatora inkrementa */
#include <stdio.h>
/* funkcija main, mesto pocetka izvrsenja programa */
int main()
{
int c=5;
/* definisanje promenljive */
int x;
/* demonstracija operatora inkrementa NAKON imena promenljive (postincrement) */
printf( "Vrednost promenljive c je %d\n", c );
x=c;
/* dodela vrednosti */
/* ispis vrednosti promenljive x */

printf( "\nNakon naredbe x=c, vrednost promenljive x je %d\n", x );
x=c++;
printf( "\nNakon naredbe x=c++\n");
printf("\tvrednost promenljive x je %d\n", x );
printf("\tvrednost promenljive c je %d\n\n", c );
/* demonstracija operatora inkrementa PRE imena promenljive (preincrement) */
c = 5;
printf( "\nVrednost promenljive c je %d\n", c );
x=++c;
printf( "\nNakon naredbe x=++c\n");
return 0;
} /* kraj funkcije main */
2. (--)
/* Upotreba operatora dekrementa */
#include <stdio.h>
/* funkcija main, mesto pocetka izvrsenja programa */
int main()
{
int c=5;
int x;
/* demonstracija operatora dekrementa NAKON imena promenljive (postdecrement) */
printf( "Vrednost promenljive c je %d\n", c );
x=c;
printf( "\nNakon naredbe x=c, vrednost promenljive x je %d\n", x );
x=c--;
printf( "\nNakon naredbe x=c--\n");
/* demonstracija operatora dekrementa PRE imena promenljive (predecrement) */
c = 5;
printf( "\nVrednost promenljive c je %d\n", c );
x= --c;
printf( "\nNakon naredbe x= --c\n");
return 0;
3. + -. 10.
.
1:
/* Upotreba while petlje i operatora "?" */
#include <stdio.h>
/* funkcija main, odavde pocinje izvrsavanje programa */
int main()
{
int brojac = 1; /* inicijalizacija promenljive brojac */
char znak;
/* definisanje promenljive znak */
while ( brojac <= 10 ) /* sve dok je brojac manji ili jednak 10, radi */
{
znak = (brojac % 2) ? ('-') : ('+'); /* parne vrednosti +, neparne - */
/* Ispis na ekran */
printf( "%c \n", znak );
brojac++; /* inkrement brojaca, isto sto i brojac=brojac+1 */
} /* kraj while petlje */
return 0; /* povratna vrednost uspesnog zavrsetka programa */
2. (He znak)
/* Upotreba while petlje i operatora "?" */
#include <stdio.h>
int main()
{
int brojac = 1; /* inicijalizacija promenljive brojac */
while ( brojac <= 10 ) /* sve dok je brojac manji ili jednak 10, radi */
{
/* Ispisi na ekran */
printf("%c\n",(brojac % 2) ? ('-'):('+')); /* parni +, neparni - */
brojac++; /* inkrement brojaca, isto sto i brojac=brojac+1 */
}/* kraj while petlje */
4.
1
/* Sabiranje dva broja */
#include <stdio.h>
int main()
{
int integer1; /* prvi broj koji unosi korisnik */
int integer2; /* drugi broj koji unosi korisnik */
int sum;
/* promenljiva u kojoj ce biti smesten rezultat */
printf( "Unesite prvi broj\n" ); /* Prikazivanje poruke */
scanf( "%d", &integer1 ); /* ucitavanje unetog broja u promen. integer1 */
printf( "Unesite drugi broj\n" ); /* Prikazivanje poruke */
scanf( "%d", &integer2 ); /* ucitavanje unetog broja u prom. integer2 */
sum = integer1 + integer2; /* racunanje zbira i dodel vrednosti prom. sum */
printf( "Zbir je %d\n", sum ); /* Prikazi vrednost zbira (sum) */
2. (He sum)
#include <stdio.h>
int main()
{
/* racunanje zbira i dodel vrednosti prom. integer1 */
integer1 = integer1 + integer2;
printf( "Zbir je %d\n", integer1 ); /* Prikazi vrednost zbira */
3. (He sum)
#include <stdio.h>
int main()
{
/* racunanje zbira i prikaz vrednosti */
printf( "Zbir je %d\n", integer1 + integer2); /* Prikazi vrednost zbira */
5.
(==, !=, <,<=, >, >=) .
1.
/* Upotreba if naredbe, relacionih operatora i operatora dodele */
#include <stdio.h>
main()
{
int num1; /* prvi broj koji unosi korisnik */
int num2; /* drugi broj koji unosi korisnik */
printf( "Unesite dva cela broja a ja cu Vam reci\n" );
scanf( "%d%d", &num1, &num2 ); /* citanje dva cela broja */
if( num1 == num2 )
{
printf( "%d je jednako sa
to %d\n", num1, num2 );
if( num1 != num2 )

{
printf( "%d nije jednako sa %d\n", num1, num2 );
if( num1 < num2 )
{
printf( "%d je manje od %d\n", num1, num2 );
if( num1 > num2 )
{
printf( "%d je vece od %d\n", num1, num2 );
if( num1 <= num2 )
{
printf( "%d je manje ili jednako sa %d\n", num1, num2 );
if( num1 >= num2 )
{
printf( "%d je vece ili jednako sa %d\n", num1, num2 );
2. ( if )
/* Upotreba if naredbe, relacionih operatora i operatora dodele */
#include <stdio.h>
main()
{
int num1; /* prvi broj koji unosi korisnik */
int num2; /* drugi broj koji unosi korisnik */
printf( "Unesite dva cela broja a ja cu Vam reci\n" );
scanf( "%d%d", &num1, &num2 ); /* citanje dva cela broja */
if( num1 == num2 )
printf( "%d je jednako sa
to %d\n", num1, num2 );
if( num1 != num2 )

printf( "%d nije jednako sa %d\n", num1, num2 );
if( num1 < num2 )
printf( "%d je manje od %d\n", num1, num2 );
if( num1 > num2 )
printf( "%d je vece od %d\n", num1, num2 );
if( num1 <= num2 )
printf( "%d je manje ili jednako sa %d\n", num1, num2 );
if( num1 >= num2 )
printf( "%d je vece ili jednako sa %d\n", num1, num2 );
6. while ++
$ $ $ $ $, # # # # #.
/* upotreba while petlje, operatora "?", ++ i -- operatora */
#include <stdio.h>
int main()
{
int vrsta = 10; /* definisanje i inicijalizacija promenljive vrsta */
int kolona;
/* definisanje promenljive kolona */
while ( vrsta >= 1 ) /* kruzi u while petlji dve dok vrsta ne bude < 1 */
{
kolona =1; /* postavi prom. kolona na 1 pri ulasku u while petlju */
while ( kolona <= 5 ) /* sve dok je kolona manje i jednako 5... */
{
printf( "%c", (vrsta % 2) ? ('$'): ('#') ); /* Ispis na ekran */
kolona++;
/* isto sto i kolona = kolona + 1 ili kolona += 1*/
} /* kraj unutrasnje while petlje */
vrsta--;
/* isto sto i vrsta = vrsta 1 ili vrsta -= 1 */
printf( "\n" ); /* prelazak u novi red */
} /* kraj spoljsnje while petlje*/
}
/* kraj funkcije main */
7. 5
. .
1 ( )
int main()
{
int brojac;
/* Broj vrednosti koje treba uneti */
int vrednost;
/* vrednost koja se unosi */
int zbir;
/* suma unetih vrednosti */
int srednja_vred; /* srednja vrednost */
/* inicijalizacija */
zbir = 0;
/* inicijalizacija promenljive zbir */
brojac = 1;
/* inicijalizacija promenljive brojac */
/* faza obrade */
while ( brojac <= 5 ) /* sve dok je brojac manji ili jednak 5... */
{
printf( "Unesite vrednost: " ); /* Ispis poruke na ekran */
scanf( "%d", &vrednost );
/* ucitaj unetu vrednost */
zbir = zbir + vrednost
;
/* dodaj unetu vrenost prom. zbir */
brojac = brojac + 1;
/* inkrement promenljive brojac */
/* zavrsna faza */
srednja_vred = zbir / 5; /* celobrojno deljenje, odbacivanje decimalnog dela */
printf( "Srednja vrednost je %d\n", srednja_vred ); /* prikaz rezultata */
return 0; /* povratna vrednost uspesnog kraja programa */
}
:
zbir srednja_vred ( int )
srednja_vred = zbir / 5 .
10
2 ( )
/* funkcija main, odavde
int main()
{
int brojac;
/*
int vrednost;
/*
int zbir;
/*
float srednja_vred; /*
pocinje izvrsavanje programa */

Broj vrednosti koje treba uneti */
vrednost koja se unosi */
suma unetih vrednosti */
srednja vrednost */
zbir = 0;
brojac = 1;
/* faza obrade */
{
;
/* privremena promena tipa prom. zbir iz int u float, */
srednja_vred = (float)zbir / 5;
printf( "Srednja vrednost je %f\n", srednja_vred ); /* format %f */
}
:
zbir int srednja_vred float.
zbir/5 .
float double.
zbir int float (float)zbir.
11
3 ( srednja_vred )
int main()
{
int brojac;
/* Broj vrednosti koje treba uneti */
int vrednost;
/* vrednost koja se unosi */
int zbir;
/* suma unetih vrednosti */
zbir = 0;
brojac = 1;
/* faza obrade */
{
;
/* privremena promena tipa prom. zbir iz int u float, */
printf( "Srednja vrednost je %f\n", (float)zbir / 5 ); /* format %f */
}
12
8.
. -1.
#include <stdio.h>
int main()
{
int brojac;
/* broj unetih vrednosti */
int vrednost; /* uneta vrednost */
int zbir;
/* zbir unetih vrednosti */
float srednja_vred; /* srednja vrednost definisana kao realan broj */
zbir = 0;
brojac = 0; /* inicijalizacija promenljive brojac */
/* Obrada */
/* Procitaj prvu vrednost od korisnika */
printf( "Unesite vrednost, -1 za prekid: " ); /* Prikaz na ekran */
/* Ucitaj unetu vrednost */
/* Kruzi u while petlji dok korisnik ne unese vrednost -1 */
while ( vrednost != -1 )
{
zbir = zbir + vrednost; /* dodaj unetu vrednost promenljivoj zbir */
brojac = brojac + 1; /* inkrement brojaca */
/* ucitaj sledecu vrednost od korisnika */
printf( "Unesite vrednost, -1 za prekid: " ); /* Prikaz na ekran */
scanf("%d", &vrednost);
/* Ucitaj sledecu unetu vrednost */
/* zavrsna faza */
/* Ako je uneta bar jedna vrednost */
if ( brojac != 0 )
{
/* izracunaj srednju vrednost svih unetih vrednosti */
srednja_vred = ( float )zbir / brojac; /* privremena promena tipa */
/* prikazi srednju vrednost sa dve decimalne vrednosti */
printf( "Srednja vrednost je %.2f\n", srednja_vred );
else /* Ako nije uneta ni jedna vrednost, ispis poruke */
{
printf( "Nije unesena ni jedna vrednost\n" );
} /* kraj else naredbe */
}
13
9.
#include <stdio.h>
/* funkcija main,
int main()
{
int a = 0x0003;
int b = 0x0022;
int c = 5;
int d;
int e;
int f = 0x0100;
pocetak izvrsavanja programa */

/* a= 03h = 0000 0011b = 3d */
/* b= 22h = 0010 0010b= 34d */
/* f=100h = 0001 0000 0000b = 256d */
printf("a=%d, b=%d, c=%d, f=%d\n",a, b, c, f);

printf("-------------------------\n");
printf("a
printf("a
printf("a
printf("a
printf("a
bitsko
logicko
bitsko
logicko
bitsko
AND
AND
OR
OR
EXOR
b
b
b
b
b
=
=
=
=
=
%xh \n",a &

%d \n",a &&
%xh \n",a |
%d \n",a ||
%xh \n\n",a
b);
b);
b);
b);
^ b);
d = (a < b) && (b > c); /* logicko i (AND) */

printf("Vrednost logicke operacije (a < b) && (b > c) je %d \n\n",d);
e = a << 3; /* shift a za 3 u levo */
printf("Vrednost a je %x, vrednost a << 3 je %xh\n",a,e);
printf("Vrednost f je %d ili %xh\n",f,f);
f =f^(1 << 4); /* shift jedinice za 4 mesta u levo */
/* 1<<4= 0000 0001b << 4 = 0001 0000b = 10h = 16d */
/* f EXOR 16 = 100h EXOR 10h = 0001 0000 0000b EXOR 0000 0001
0000b */
printf("Vrednost f je 100h a f^(1 << 4) je %d ili %xh \n",f,f);
return 0; /* oznacava uspesan zavrsetak programa */
14
10.
.
1,
2.
1 2

P 1
/* Upotreba do while petlje i if elseif else naredbe */
#include <stdio.h>
int main()
{
/* definisanje i inicijalizacija promenljivih */
int polozilo = 0;
/* broj studenata koji su polozili ispit */
int palo = 0;
/* broj studenata koji nisu polozili ispit */
int rezultat;
/* uneta vrednost */
int izlaz=0;
do
{
printf( "Unesite rezultat ( 1=polozio, 2=pao ): " ); /* Ispis na ekran */
scanf( "%d", &rezultat );
/* Ako je rezultat 1, povecaj vrednost promenljive polozilo za 1 */
if ( rezultat == 1 )
{
polozilo = polozilo + 1;
else if(rezultat==2)/* inace inkrementiraj vrednost promenljive palo */
{
palo = palo + 1;
} /* kraj else if*/
else
{
izlaz = 1;
}
} while ( izlaz == 0 ); /* kraj do while petlje */
/* zavrsna faza */
printf( "Broj studenata koji su polozili ispit %d\n", polozilo );
printf( "Broj studenata koji nisu polozili ispit %d\n", palo );
/* Ako je polozilo vise od 8 studenata ispisi Odlican uspeh" */
if ( polozilo > 8 )
{
printf( "Odlican uspeh\n" );
} /* kraj if */
15
P 2
/* Upotreba do while petlje i if elseif else naredbe */
#include <stdio.h>
int main()
{
/* definisanje i inicijalizacija promenljivih */
int polozilo = 0;
/* broj studenata koji su polozili ispit */
int palo = 0;
/* broj studenata koji nisu polozili ispit */
int rezultat;
/* uneta vrednost */
do
{
printf( "Unesite rezultat ( 1=polozio, 2=pao ): " ); /* Ispis na ekran */
scanf( "%d", &rezultat );
/* Ako je rezultat 1, povecaj vrednost promenljive polozilo za 1 */
if ( rezultat == 1 )
polozilo++;
else if(rezultat==2)/* inace inkrementiraj vrednost promenljive palo */
palo++;
else
break;
} while (1); /* kraj do while petlje, BESKONANA petlja */
/* zavrsna faza */
printf( "Broj studenata koji su polozili ispit %d\n", polozilo );
printf( "Broj studenata koji nisu polozili ispit %d\n", palo );
/* Ako je polozilo vise od 8 studenata ispisi Odlican uspeh" */
if ( polozilo > 8 )
printf( "Odlican uspeh\n" );
:
do while ,
while(1). break.
16
11. for 1 10.

/* primena for petlje */
#include<stdio.h>
/* funkcija main, program pocinje da se izvrsava odavde */
int main(void)
{
int num;
printf("\tk\tk na treci stepen\n");
for(num=1; num <= 10 ;num++ )
{
printf("%5d %5d\n", num , num*num*num);
}
12. for
/* primena for petlje, dekrement; if else if else grananje */
#include<stdio.h>
int main(void)
{
int num;
printf("\nPreostalo je:\n");
for(num=10; num >= 1 ;num-- )
{
if( num >=5 )
printf("%2d sekundi\n", num);
else if(num > 1)
printf("%2d sekunde \n", num);
else
printf("%2d sekunda \n", num);
}
printf("\nVreme isteklo\n");
17
13. for ++
#.
/* Upotreba for petlje */
#include <stdio.h>
int main()
{
int x;
int y;
int i;
int j;
/* Prikaz na ekran */
printf( "Unesite dva cela broja: " );
scanf( "%d%d", &x, &y ); /* procitaj vrednosti za x i y */
for ( i = 1; i <= y; i++ ) /* broj od 1 do y */
{
for ( j = 1; j <= x; j++ ) /* broj od 1 do x */
{
printf( "#" ); /* ispisi # */
} /* kraj unutrasnje for petlje */
printf( "\n" ); /* predji u novu liniju */
} /* kraj spoljasnje for petlje */
18
14. while 1 10
/* Upotreba while petlje */
#include <stdio.h>
/* funkcija main, pocetak izvrsavanja programa */
int main()
{
int brojac = 1; /* inicijalizacija */
while ( brojac <= 10 ) /* uslov ponavljanja */
{
printf ( "%d\n", brojac ); /* ispis vrednosti brojaca */
brojac++; /* povecaj vrednost brojaca za 1 */
return 0; /* oznacava uspesan kraj programa */
15. fr 1 10
P 1
#include <stdio.h>
int main()
{
int i;
for(i = 1; i < 11; i++) /* uslov ponavljanja */
{
printf ( "%d\n", i ); /* ispis vrednosti brojaca */
19
P 2
#include <stdio.h>
int main()
{
int i;
i = 1;
for( ; i < 11; i++) /* uslov ponavljanja */
{
:
for (
). i (i=0) for .
P 3
/* Upotreba while petlje */
#include <stdio.h>
int main()
{
int i;
i = 1;
for( ; i < 11; ) /* uslov ponavljanja */
{
i++;
:
for (
). : i (i=0) for
i (i++) for .
20
4
#include <stdio.h>
int main()
{
int i;
i = 1;
for( ; ; ) /* uslov ponavljanja */
{
i++;
if(i > 10)
break;
:
for (
). : i (i=0) for ,
for ( if(i > 10)break; )
i (i++) for .
16. fr 1 20.
#include <stdio.h>
int main()
{
int broj;
for ( broj = 2; broj < 21; broj += 2 )
{
printf("%2d\n", broj); /* ispis vrednosti */
} /* kraj for */
} /* kraj funkcije
main */
21
17. fr 1 20.
#include <stdio.h>
int main()
{
int broj;
for ( broj = 1; broj < 21; broj += 2 )
{
printf("%2d\n", broj); /* ispis vrednosti */
} /* kraj for */
18. fr 1 100.
/* Sumiranje sa for petljom 2+4+6+8+...+100 */
#include <stdio.h>
int main()
{
int zbir= 0; /* inicijalizacija promenljive zbir */
int broj;
/* broj koji se dodaje zbiru */
for ( broj = 2; broj <= 100; broj += 2 )
{
zbir += broj; /* dodaj broj zbiru */
} /* kraj for */
printf( "Suma je %d\n", zbir ); /* Ispisi zbir */
} /* kraj funkcije
main */
22
19. break for

/* Upotreba naredbe break */
#include <stdio.h>
int main()
{
int i; /* brojac */
/* 10 puta uradi sledece naredbe... */
for ( i = 1; i <= 10; i++ )
{
/* Ako je i jednako 5, napusti for petlju */
if ( i == 5 )
{
printf( "\nNapustam for petlju naredbom break\n");
break; /* prekid for petlje */
} /* kraj if */
printf( "%d ", i ); /* prikazi vrednost promenljive i x */
} /* kraj for */
printf( "\nNakon izlaska iz for petlje vrednost brojaca je: %d\n", i );
} /* kraj funkcije
20.
main */
break while
/* Upotreba naredbe break */
#include <stdio.h>
int main()
{
int i=0; /* brojac */
/* 10 puta uradi sledece naredbe... */
while ( i <= 10)
{
i++;
/* Ako je i jednako 5, napusti for petlju */
if ( i == 5 )
{
printf( "\nNapustam while petlju naredbom break\n");
break; /* prekid for petlje */
} /* kraj if */
printf( "%d ", i ); /* prikazi vrednost promenljive i x */
} /* kraj for */
printf( "\nNakon izlaska iz while petlje vrednost brojaca je: %d\n", i );
} /* kraj funkcije
main */
23
21. continue for

/* Upotreba naredbe continue */
#include <stdio.h>
int main()
{
int i; /* brojac */
for ( i = 1; i <= 10; i++ ) /* 10 puta uradi sledece naredbe... */
{
/* Ako je i jednako 5, napusti preskoci naredbe do kraja for petlje */
if ( i == 5 )
{
printf( "\n\n Ne napustam for petlju, samo preskacem jednu vrednost\n\n");
continue; /* preskoci naredbe do kraja for petlje */
} /* kraj if */
printf( "%d\n", i ); /* prikazi vrednost promenljive i */
} /* kraj for */
24
22. continue while

/* Upotreba naredbe continue */
#include <stdio.h>
int main()
{
int i; /* brojac */
while( i <= 10) /* radi sve dok je ... */
{
/* Ako je i jednako 5, preskoci naredbe do kraja while petlje */
if ( i == 5 )
{
printf( "\n\n Ne napustam while petlju, preskacem jednu vrednost\n\n");
continue; /* preskoci naredbe do kraja while petlje */
} /* kraj if */
printf( "%d\n", i ); /* prikazi vrednost promenljive i */
} /* kraj while */
25
isdigit, isalpha, isalnum, isxdigit

/* funkcije: isdigit, isalpha, isalnum, isxdigit */
#include <stdio.h>
#include <ctype.h>
int main()
{
printf( "%s\n%s%s\n%s%s\n\n", "Prema funkciji isdigit: ",
isdigit('8') ? ("8 je ") : ("8 nije "), "cifra",
isdigit('#') ? ("# je ") : ("# nije "), "cifra" );
printf( "%s\n%s%s\n%s%s\n%s%s\n%s%s\n\n",
isalpha( 'A' ) ? "A je " : "A nije ",
isalpha( 'b' ) ? "b je " : "b nije ",
isalpha( '&' ) ? "& je " : "& nije ",
isalpha( '4' ) ? "4 je " : "4 nije ",
"Prema funkciji isalpha:",

"slovo",
"slovo",
" slovo",
"slovo" );
printf( "%s\n%s%s\n%s%s\n%s%s\n\n", "Prema

isalnum( 'A' ) ? "A je " : "A nije ",
isalnum( '8' ) ? "8 je " : "8 nije ",
isalnum( '#' ) ? "# je " : "# nije ",
funkciji isalnum:",
"cifra ili broj",
"cifra ili broj",
"cifra ili broj" );
printf( "%s\n%s%s\n%s%s\n%s%s\n%s%s\n%s%s\n", "Prema funkciji isxdigit:",

isxdigit( 'F' ) ? "F je " : "F nije ", "heksadecimalna cifra",
isxdigit( 'J' ) ? "J je " : "J nije ", "heksadecimalna cifra",
isxdigit( '7' ) ? "7 je " : "7 nije ", "heksadecimalna cifra",
isxdigit( '$' ) ? "$ je " : "$ nije ", "heksadecimalna cifra",
isxdigit( 'f' ) ? "f je " : "f nije ", "heksadecimalna cifra" );
return 0; /* uspesan zavrsetak programa */
islower, isupper, tolower, toupper

#include <stdio.h>
#include <ctype.h>
int main()
{
printf( "%s\n%s%s\n%s%s\n%s%s\n%s%s\n\n", "Prema funkciji islower:",
islower( 'p' ) ? "p je " : "p nije ", "malo slovo",
islower( 'P' ) ? "P je " : "P nije ", "malo slovo",
islower( '5' ) ? "5 je " : "5 nije ", "malo slovo",
islower( '!' ) ? "! je " : "! nije ", "malo slovo" );
printf( "%s\n%s%s\n%s%s\n%s%s\n%s%s\n\n", "Prema fukciji isupper:",
isupper( 'D' ) ? "D je " : "D nije ", "veliko slovo",
isupper( 'd' ) ? "d je " : "d nije ", "veliko slovo",
isupper( '8' ) ? "8 je " : "8 nije ", "veliko slovo",
isupper( '$' ) ? "$ je " : "$ nije ", "veliko slovo" );
printf( "%s%c\n%s%c\n%s%c\n%s%c\n",
"m konvertovano u veliko slovo je ", toupper( 'm'
"7 konvertovano u veliko slovo je ", toupper( '7'
"$ konvertovano u veliko slovo je ", toupper( '$'
"K konvertovano u malo slovo je ", tolower( 'K' )
return 0; /* oznacava uspesan zavrsetak */
),
),
),
);
isspace,
isgraph
#include <stdio.h>
#include <ctype.h>
int main()
{
printf( "%s\n%s%s%s\n%s%s%s\n%s%s\n\n", "Prema funkciji isspace:",
"Novi red", isspace('\n') ? " je " : " nije ", "beli znak",
"Tab", isspace('\t') ? " je " : " nije ", "beli znak",
isspace( '%' ) ? "% je " : "% nije ", "beli znak" );
printf( "%s\n%s%s\n%s%s%s\n", "Prema funkciji isgraph:",
isgraph( 'Q' ) ? "Q je " : "Q nije ", "stampajuci znak ",
"Space", isgraph( ' ' ) ? " je " : " nije ", "stampajuci znak " );
"99.50" double
double 3 .
#include <stdlib.h>
int main()
{
char str_a[]="99.50";
double nova; /* promenljiva koja cuva konvertovani string */
nova = atof(str_a);
printf("String \"%s\" konvertovan u double je %.2f\n", str_a, nova);
printf("Konvertovana vrednost podeljena sa 3 je %.2f\n",nova/3 );
: printf
( printf("String \"%s\"...)
"3245" int int

245 .
#include <stdio.h>
#include <stdlib.h>
int main()
{
char str_a[]="3245";
int celo; /* promenljiva koja cuva konvertovani string */
celo = atoi(str_a);
printf("String \"%s\" konvertovan u integer je %d\n", str_a, celo);
printf("Konvertovana vrednost minus 245 je %d\n",celo -245 );

1:
#include<stdio.h>
#include<string.h>
int main()
{
char linija_teksta[80]; /* definisanje niza od 80 elemenata */
char *ptr;
/* pokazivac na char promenljivu */
int indeks_poklapanja;
int i;
printf( "Unesite jednu liniju teksta:\n" );
/* Primena funkcije gets da se u zadati niz ucita jedna linija teksta */
gets(linija_teksta);
/* Primena funkcije strchr da se u zadatom nizu pronadje pozicija (indeks) prvog
pojavljivanja zadatog karaktera, ovde trazimo kraj stringa ili karakter '\0' */
ptr=strchr(linija_teksta, '\0');
indeks_poklapanja=ptr - linija_teksta - 1;
/* moze i ovako: indeks_poklapanja=ptr-&linija_teksta[0] - 1; ili
indeks_poklapanja=ptr-&linija_teksta - 1;
printf( "\nLinija odstampana unazad je:\n" );
for(i=indeks_poklapanja;i>=0;i--)
{
printf("%c", linija_teksta[i]);
}
printf("\n");
5
*/
2:
#include<stdio.h>
#include<string.h>
int main()
{
char linija_teksta_a[80]; /* definisanje niza od 80 elemenata */
char linija_teksta_b[80]; /* definisanje niza od 80 elemenata */
char *ptr;
/* pokazivac na char promenljivu */
int indeks_poklapanja;
int i;
printf( "Unesite jednu liniju teksta:\n" );
/* Primena funkcije gets da se u zadati niz ucita jedna linija teksta */
gets(linija_teksta_a);
/* trazimo kraj stringa ili ADRESU na kojoj se nalazi karakter '\0'
ptr=strchr(linija_teksta_a, '\0');
*/
/* indeks se dobija kao razlika adresa */

indeks_poklapanja=ptr - linija_teksta_a - 1;
printf( "\nLinija odstampana unazad je:\n" );
/* u niz linija_teksta_b upisi unazad sadrzaj niza linija teksta_a */
/* for petlja ima samo jednu naredbu, moze i bez { } */
for(i=0;i<=indeks_poklapanja;i++)
linija_teksta_b[i]=linija_teksta_a[indeks_poklapanja-i];
/* string mora da se zavrsi nul karakterom! */
linija_teksta_b[i]='\0';
/* Primenom funkcije puts ispisujemo sadrzaj stringa */
/* puts zamenjuje '\0' sa '\n' pa automatski imamo novi red! */
puts(linija_teksta_b);
.

1
/* Primena funkcija getchar i puts */
#include <stdio.h>
int main()
{
char znak;
/* promen. u koju se upisuje znak
char recenica[80]; /* niz od 80 elemenata */
int i = 0;
/* brojac inicijalizovan na 0 */
koji unese korisnik */
/* Ispis poruke na monitor */

puts( "Unesite jednu liniju teksta:" );
/* Inicijalizacija promenljive znak */
znak=' ';
/* Primena funkcije getchar da se procita svaki uneti znak (character) */
while (znak != '\n')
/* radi sve dok se ne pritisne ENTER */
{
znak = getchar();
/* ucitaj jedan znak */
recenica[i] = znak; /* upisi ucitani znak u niz*/
i++;
recenica[i] = '\0'; /* string se mora zavrsit ovim znakom */
/* funkcija puts ispisuje sadrzaj stringa na monitor */
puts( "\nUneli ste sledeci tekst:" );
puts(recenica);
} /* karaj funkcije main */
2
#include <stdio.h>
int main()
{
char znak;
/* promen. u koju se upisuje znak
char recenica[80]; /* niz od 80 elemenata */
int i = 0;
/* brojac inicijalizovan na 0 */
koji unese korisnik */
/* Ispis poruke na monitor */

puts( "Unesite jednu liniju teksta:" );
/* Primena funkcije getchar da se procita svaki uneti znak (character) */
while ( ( znak = getchar() ) != '\n')
{
recenica[i++] = znak;
recenica[i] = '\0'; /* string se mora zavrsit ovim znakom */
/* funkcija puts ispisuje sadrzaj stringa na monitor */
puts( "\nUneli ste sledeci tekst:" );
puts(recenica);
} /* karaj funkcije main */
Happy Birthday to You x . : y z.
strcpy x y, 14 y
z. .
1
/* Primena funkcija strcpy i strncpy */
#include <stdio.h>
#include <string.h>
int main()
{
char x[] = "Happy Birthday to You"; /* inicijalizacija niza x */
char y[ 25 ]; /* definisanje niza y */
char z[ 15 ]; /* definisanje niza z */
printf( "%s %s\n", "Sadrzaj stringa x je:", x);
strcpy( y, x );
/* kopiraj sadrzaj stringa x u string y */
printf( "%s %s\n","Sadrzaj stringa y je:", y);

/* Kopiraj prvih 14 karaktera iz x u z. Ne kopira se null character! */
strncpy( z, x, 14 );
z[14] = '\0'; /* dodaj nul karakter stringu z */
printf( "String u nizu z je: %s\n", z );
return 0; /* oznacava uspesan zavrsetaka programa */
} /* kraj fukcije main */
2
#include <stdio.h>
#include <string.h>
int main()
{
char x[] = "Happy Birthday to You"; /* inicijalizacija niza x */
char y[ 25 ]; /* definisanje niza y */
char z[ 15 ]; /* definisanje niza z */
puts("Sadrzaj stringa x je:");
puts(x);
/* kopiraj sadrzaj stringa x u string y */
strcpy( y, x );
puts("\nSadrzaj stringa y je:");
puts(y);
/* Kopiraj prvih 14 karaktera iz x u z. Ne kopira se null character! */
strncpy( z, y, 14 );
z[14] = '\0'; /* dodaj nul karakter stringu z */
puts( "\nString u nizu z je:");
puts(z);
return 0; /* oznacava uspesan zavrsetaka programa */
} /* kraj fukcije
main */
() s1 20 "Srecna ",
() s2 "Nova godina " s3
40 "". strcat s1 s2,
. 7 s1 s3
s3. s3 s1
s3.
/*strcat, strncat */
#include <stdio.h>
#include <string.h>
int main()
{
char s1[20] = "Srecna ";
char s2[] = "Nova godina ";
char s3[40] = "";
/* inicijalizacija niza s1 */
/* inicijalizacija niza s2 */
/* inicijalizacija niza s3 "prazn" niz */
/* Ispis sadrzaja stringova s1 i s2*/

printf( "s1 = %s \ns2 = %s \n", s1, s2 );
/* na sadrzaj stringa s1 dopisi sadrzaj stringa s2 */
strcat( s1, s2 );
/* ispisi sadrzaj stringa s1 */
printf( "Nakon naredbe strcat(s1, s2),\t sadrzaj stringa s1 je: %s\n", s1 );
/* dopisi prvih 7 karaktera stringa s1 u string s3.*/
strncat( s3, s1, 7);
printf( "Nakon naredbe strncat(s3,s1,7),\t sadrzaj stringa s3 je: %s\n",s3);
/* na sadrzaj stringa s3 dopisi sadrzaj stringa s1 */
strcat( s3, s1);
printf( "Nakon naredbe strcat(s3, s1),\t sadrzaj stringa s3 je: %s\n",s3);
return 0; /* Oynacava uspesan zavrsetak programa */
10
() s1 "Happy New Year".

() s2 "Happy New Year". () s3
" Happy Holidays". strcmp
.
#include <stdio.h>
#include <string.h>
int main()
{
const char s1[] = "Happy New Year"; /* inicijalizacija stringa */
const char s2[] = "Happy New Year"; /* inicijalizacija stringa */
const char s3[] = "Happy Holidays"; /* inicijalizacija stringa */
printf("%s %s\n","Sadrzaj stringa s1 je:", s1);
printf("\nRezultat funkcije %s je: %2d","strcmp(s1, s2) = ", strcmp( s1, s2 ) );
printf("\nRezultat funkcije %s je: %2d","strcmp(s1, s3) = ", strcmp( s1, s3 ) );
printf("\nRezultat funkcije %s je: %2d\n","strcmp(s3, s1) = ", strcmp( s3, s1 ) );
return 0;
} /* kraj funkcije
main */
strchr 'n' 'z' "Ovo je jedan test"

/* strchr */
#include <stdio.h>
#include <string.h>
int main()
{
const char niz_znakova[] = "Ovo je jedan test"; /* inicijalizacija niza */
char znak1 = 'n';
char znak2 = 'z';
/* Ako je znak1 (karakter) pronadjen u stringu... */
if ( strchr( niz_znakova, znak1 ) != NULL )
printf( "Znak \'%c\' je pronadjen u stringu \"%s\".\n", znak1, niz_znakova);
else /* ako znak1 nije pronadjen */
printf( "Znak \'%c\' nije pronadjen u stringu \"%s\".\n",znak1,niz_znakova);
/* Ako je znak2 (karakter) pronadjen u stringu... */
if ( strchr( niz_znakova, znak2 ) != NULL )
printf( "znak \'%c\' je pronadjen u stringu \"%s\".\n", znak2, niz_znakova);
else /* ako znak2 nije pronadjen */
printf( "Znak \'%c\' nije pronadjen u stringu \"%s\".\n",znak2,niz_znakova);
return 0;
11
strstr "def"
"abcdefabcdef"
/* strstr */
#include <stdio.h>
#include <string.h>
int main()
{
char str1[] = "abcdefabcdef"; /* string koji se pretrazuje */
char str2[] = "def"; /* string koji se trazi */
char *pch;
printf( "%s \"%s\"\n", "string1 = ", str1);
printf( "%s \"%s\"\n", "string2 = ", str2);
pch=str1; /* pch=&str1[0] ili pch=&str1; ; */
do
{
pch=strstr(pch, str2);
if(pch != NULL)
{
printf("String \"%s\" se nalazi u stringu \"%s\" na poziciji %2d\n",
str2, str1, pch-str1+1);
pch++;
}while(pch != NULL);
return 0;
strlen : "abcdefghijklmnopqrstuvwxyz", "tri"

"Kikinda"
/* strlen */
#include <stdio.h>
#include <string.h>
int main()
{
/* initialize 3 char pointers */
const char str1[] = "abcdefghijklmnopqrstuvwxyz";
const char str2[] = "tri";
const char str3[] = "Kikinda";
printf("%s \"%s\" %s %d\n","Duzina stringa", str1, "je", strlen(str1));
12
1. 1 10.
.
:
/* Kreiranje i primena funkcije */
#include <stdio.h>
int kvadrat( int y ); /* deklaracija ili prototip funkcije */
/* funkcija main, mesto pocetka izvrsavanja programa */
int main()
{
int x; /* brojac */
/* 10 pita izracunaj i ispisi kvadrat x */
for (x = 1; x <= 10; x++)
{
printf( "%d ", kvadrat(x) ); /* poziv funkcije */
printf( "\n" );
} /* kraj main */
/* funkcija kvadrat, definicija */
int kvadrat(int y) /* u y se kopira vrednost x */
{
return y*y; /* vraca kvadrat y kao int */
} /* kraj funkcije kvadrat */
2. .
:
/* Pronalazenje maksimuma od tri broja */
#include <stdio.h>
int maximum( int x, int y, int z ); /* prototip funkcije */
/* funkcija main,
int main()
{
int number1; /*
int number2; /*
int number3; /*
mesto pocetka izvrsavanja programa */

prvi broj */
drugi broj */
treci broj */
printf( "Unesite tri cela broja: " );

scanf( "%d%d%d", &number1, &number2, &number3 );
/* number1, number2 i number3 su argumenti pri pozivu funk. maximum */
printf( "Maksimalna vrednost je: %d\n", maximum( number1, number2, number3 ) );
/* Funkcija maximum, definicija */
/* x, y z su formalni argumenti */
int maximum( int x, int y, int z )
{
int max = x;
/* pretpostavimo da je x najveci broj */
if(y > max)
{
max = y;
} /* kraj if */
/* ako je y veci onda je max jednak y */
if(z > max)

{
max = z;
} /* kraj if*/
/* ako je z vece od max, onda je max jednak z */
return max;
/* max je najveca vrednost */
} /* kraj funkcije maximum */
3. :
1
2 1
3 2 1
4 3 2 1
5 4 3 2 1
6 5 4 3 2 1
7 6 5 4 3 2 1
8 7 6 5 4 3 2 1
9 8 7 6 5 4 3 2 1
10 9 8 7 6 5 4 3 2 1
() broji_unazad( int x)
.
:
/* prenos argumenta po vrednosti*/
#include <stdio.h>
void broji_unazad(int x); /* prototip funkcije */
int main()
{
int br;
for (br=1; br <= 10; br++)
{
broji_unazad(br);
}
return 0;
void broji_unazad(int x)
{
int i;
for (i = x; i > 0; i--)

{
printf("%d", x);
x--;
}
putchar('\n'); /* novi red */
} /* kraj funkcije broji_unazad */
4.
void zameni(int *a, int *b);
/* prototip funkcije */
#include <stdio.h>
int main()
{
int x=6, y=10;
printf("Pre poziva funkcije, x = %d i y = %d\n\n", x, y);
zameni(&x, &y); /* Poziv funkcije i prosledjivanje promen. po adresi */
printf("Nakon povratka iz funkcije
x = %d i y = %d\n\n", x, y);
return 0;
void zameni(int *a, int *b) /* funkcija nema povratnu vrednost, tip void */
{
/* u promenljivu a je preslikana adresa promen. x */
/* u promenljivu b je preslikana adresa promen. y */
int temp;
temp= *a; /* u promen. temp upisi vrednost na koju pokazuje pointer a, tj.
vrednost prom. x */
*a = *b; /* na adresu na koju ukazuje pointer a upisi vrednost sa adrese
na koju ukazuje pointer b */
*b = temp; /* na adresu na koju ukazuje pointer b upisi vrednost promen. temp*/
} /* kraj funkcije zameni */
5. 1 6.
( ). rand().
rand
.
()
int rand( void );
(Return)
0 RAND_MAX.
(32767), <stdlib.h>.
srand
rand.
:
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i; /* brojac */
/* ponovi
for ( i =
{
/* uzmi
printf(
20 puta */
1; i <= 20; i++ )
slucajan (random) broj izmedju 1 i 6 i ispisi ga */
"%10d", 1 + ( rand() % 6 ) ); /* moduo po 6 daje vrednosti od 0 do 5 */
/* ako je brojac deljiv sa 5, predji u novi red */

if(i % 5 == 0)
{
printf( "\n" );
} /* kraj if */
} /* kraj for */
. rand?

6. 1 6 rand() 6000
.
:
#include <stdio.h>
#include <stdlib.h>
/* funkcija main, mesto
int main()
{
int frekvencija1 = 0;
pocetka izvrsavanja programa */

/*
/*
/*
/*
/*
/*
brojac
brojac
brojac
brojac
brojac
brojac
pojavljivanja
pojavljivanja
pojavljivanja
pojavljivanja
pojavljivanja
pojavljivanja
broja
broja
broja
broja
broja
broja
1
2
3
4
5
6
*/
*/
*/
*/
*/
*/
int i;
int vrednost; /* dobijena vrednost od generatora pseudoslucajnih brojeva 6 */
/* ponovi 6000 puta i daj rezultat */
for (i = 1; i<=6000; i++ )
{
vrednost = 1 + rand() % 6; /* pseudosl. broj od 1 do 6 */
/* odredi vrednost i povecaj odgovarajuci brojac */
switch ( vrednost )
{
case 1: /* dobijena jedinica */
++frekvencija1;
break;
case 2: /* dobijena dvojka */
++frekvencija2;
break;
case 3: /* dobijena trojka */
++frekvencija3;
break;
case 4: /* dobijena cetvorka */
++frekvencija4;
break;
case 5: /* dobijena petica */
++frekvencija5;
break;
case 6: /* dobijena sestica */
++frekvencija6;
break;
} /* kraj switch */
} /* kraj for */
/* prikazi rezultat u tabelarnom formatu */
printf( "%s%13s\n", "Vrednost", "Frekvencija" );
printf( "
1%13d\n", frekvencija1 );
printf( "
printf( "
printf( "
printf( "
printf( "
return 0;/* oznacava uspesan zavrsetak programa */
7. , ,
#include <stdio.h>
#include <stdlib.h>
int main()
{
int frekvencija[7] = {0,0,0,0,0,0,0}; /* brojac pojavljivanja brojva 1 do 6 */
int i;
int vrednost; /* dobijena vrednost od generatora pseudoslucajnih brojeva 6 */
/* ponovi 6000 puta i daj rezultat */
for (i = 1; i<=6000; i++ )
{
vrednost = 1 + rand() % 6; /* pseudosl. broj od 1 do 6 */
/* odredi dobijenu vrednost i povecaj odgovarajuci brojac */
++frekvencija[vrednost];
} /* kraj for */
/* prikazi rezultat u tabelarnom formatu */
printf( "%s%13s\n", " Vrednost", "Frekvencija" );
for(i=1;i<7;i++)
printf( "\t%d%13d\n", i,frekvencija[i] );
return 0;/* oznacava uspesan zavrsetak programa */
8. .
rand .
(
) ( ), .
rand
srand(unsigned int), unsigned int
rand. srand(unsigned int)
#include <stdlib.h>
#include <stdio.h>
int main()
{
int i;
/* brojac */
unsigned int seed; /* broj koji odredjuje mesto pocetka rada rand generatora */
printf( "Unesite vrednost parametra za rand generator: " );
scanf( "%u", &seed ); /* primetite %u za unsigned int */
srand( seed ); /* postavi pocetnu vrednost rand generatora */
/* petlja
for ( i =
{
/* uzmi
printf(
10 puta */
1; i <= 10; i++ )
slucajnu vrednost od 1 do 6 i ispisi je */
"%10d", 1 + ( rand() % 6 ) );
/* ako je brojac deljiv sa 5 predji u novi red */

if ( i % 5 == 0 )
{
printf( "\n" );
} /* kraj if */
} /* kraj for */
} /* kraj main */
9. .
rand .
srand .
time(NULL) .
( ) (00:00:00), 1. 1970. . A NULL
time .

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
/* sadrzi prototip funkcije time */
int main()
{
int i;
/* brojac */
srand(time(NULL)); /* postavi pocetnu vrednost rand generatora svaki put kad se
pokrene program na drugu vrednost*/
/* petlja 10 puta */
for(i = 1; i <= 10; i++)
{
/* uzmi slucajnu vrednost od 1 do 6 i ispisi je */
printf( "%10d", 1 + ( rand() % 6 ) );
/* ako je brojac deljiv sa 5 predji u novi red */
if( i % 5 == 0 )
{
printf( "\n" );
} /* kraj if */
} /* kraj for */
} /* kraj main */
10.
. .
. n
n! :
n! =n*(n-1)*(n-2)*(n-3)*...*1

1! = 1
0! = 1
:
5! = 5*4*3*2*1= 120
broj for :
faktorijel = 1;
for(i=broj; i>=1; i--)
{
faktorijel *= i;
/*
}
faktorijel = faktorijel * i;
*/
:
:
5! = 5*4*3*2*1= 5*(4*3*2*1) = 5*(4!)
4!= 4*3*2*1=4*(3*2*1) = 4*(3!)
3! = 3*2*1=3*(2*1) = 3*(2!)
2! = 2*1=2*(1) = 2*(1!)
1! = 1
...
#include <stdio.h>
long faktorijel(long broj);
/* prototip funkcije */

int main()
{
int i; /* brojac */
/* 11 puta ponovi naredbe, svaki put izracunaj faktorijel(i) i ispisi rezultat */
for ( i = 0; i <= 10; i++ )
{
printf("%2d! = %ld\n", i, faktorijel(i) ); /* poziv funkcije faktorijel i */
} /* kraj for */
/* Definicija rekurzivne funkcije faktorijel */

long faktorijel(long broj)
{
/* ako je broj 0 ili 1, 0!=1 i 1!=1 */
if( broj <= 1 )
{
return 1; /* vrati 1 i zavrsi rada sa funkcijom */
} /* kraj if */
else /* jedan korak rekurzije */
{
return (broj * faktorijel(broj - 1) ); /* rekurzivni poziv funkcije
} /* kraj else */
*/
} /* kraj funkcije faktorijel */

faktorijel 0 10.
broj 1 0, 1
faktorijel.
(broj) 1 return(broj*faktorijel(broj-1));
faktorijel (broj-1)
11. .
Fibonacci- 0 1
, .
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...
fibonacci( i )

fibonacci(0)=0,
fibonacci(1)=1,
fibonacci(n) = fibonacci(n-1) + fibonacci(n-2)
1
#include <stdio.h>
long fibonacci( long broj ); /* prototip funkcije */
int main()
{
long rezultat; /* fibonacci vrednost */
long indeks;
/* broj koji unosi korisnik */
/* Uzmi broj od korisnika */
printf( "Unesite celi broj: " );
scanf( "%ld", &indeks );
/* Izracunaj fibonacci vrednost ya uneti broj */
rezultat = fibonacci(indeks);
/* prikazi rezltat */
printf( "Fibonacci( %ld ) = %ld\n", indeks, rezultat );
/* definicija rekurzivne funkcije fibonacci */
long fibonacci(long broj)
{
long i;
long n_minus1=1, n_minus2=0, n;
if (broj==0 || broj==1)
return broj;
for(i=1;i<broj;i++)
{
n=n_minus1+n_minus2;
n_minus2=n_minus1;
n_minus1=n;
}
return n;
} /* kraj funkcije fibonacci */
2
#include <stdio.h>
long fibonacci(long broj); /* prototip funkcije */
int main()
{
long rezultat; /* fibonacci vrednost */
long indeks;
/* broj koji unosi korisnik */
/* Uzmi broj od korisnikao */
printf( "Unesite celi broj: " );
scanf( "%ld", &indeks );
/* Izracunaj fibonacci vrednost ya uneti broj */
rezultat = fibonacci( indeks );
/* prikazi rezltat */
printf( "Fibonacci( %ld ) = %ld\n", indeks, rezultat );
/* definicija rekurzivne funkcije fibonacci */

long fibonacci(long n)
{
/* osnovni slucaj */
if(n == 0 || n == 1)
{
return n;
} /* kraj if */
else
{ /* rekurzija */
return fibonacci(n - 1) + fibonacci(n - 2);
} /* kraj else */
} /* kraj funkcije fibonacci */
12. .
#include <stdio.h>
#include <string.h> /* potrebno zbog funkcije strchr() */
#include<stdlib.h> /* potrebno zbog funkcije atoi() */
#include <ctype.h> /* potrebno zbog funkcije isdigit() */
int ucitaj_datum(int *d, int *m, int *g ); /* prototip funkcije*/
int proveri_datum( int xd, int ym, int yg ); /* prototip funkcije*/
int main()
{
int dan;
int mesec;
int godina;
int pom;
pom=ucitaj_datum(&dan, &mesec, &godina); /* poziv funkcije, unos podataka */
/* ako je po formatu korektno unet datum poroveri da li je moguc */
if(!pom) /* funkcija vraca vrednost u pom */
pom =proveri_datum(dan, mesec, godina); /* poziv funkcije, provera unosa */
switch(pom) /* i druga funkcija vraca vrednost u pom */
{
case 1:
printf("\n");
break;
case 2:
printf("Niste uneli odgovarajuci mesec\n\b");
break;
case 3:
printf("Niste uneli odgovarajuci dan u mesecu\n\b");
break;
default:
printf("Uneti datum je korektan!\n");
break;
}
return 0;
} /* kraj funkcije main*/
/* definicija funkcije ucitaj_datum */

int ucitaj_datum(int *d, int *m, int *g )
{
char niz[80];
char podniz[5];
int kontrola;
int duzina;
int i;
char *ptr;
kontrola=1;
do
{
printf("\nUnesite datum u formatu dd.mm.gggg ili dd.mm.gg, x za prekid\n" );
gets(niz);
/* ucitaj unos korisnika */
duzina=strlen(niz); /* odredi broj unetih karaktera */
/* zahtev korisnika za prekid programa*/
if(niz[0]=='x' || niz[0]=='X')
return 1;
/* da li je broj unetih karaktera odgovarajuci? */
if(duzina != 10 )
printf("Broj unetih vrednosti nije odgovarajuci\n", duzina);
else
kontrola=0; /* ok */
/* Ako je broj unetih karaktera odgovarajuci... */
if(!kontrola)
{
/* da li je pozicija delimitera na pravom mestu (3. i 6.) */
ptr=strchr(niz, '.'); /* pozicija prvog delimitera */
if((ptr - niz+1) != 3)
{
printf("Pozicija delimitera ('.') nije odgovarajuca");
kontrola=1; /* greska u formatu */
}
if(!kontrola)
{
ptr=strchr(ptr+1, '.'); /* pozicija drugog delimitera */
if((ptr - niz+1) != 6)
{
printf("Pozicija delimitera ('.') nije odgovarajuca");
kontrola=1;
}
}
}
if(kontrola)
continue;
for(i=0; i<10;i++) /* da li su na svim pozicijama (sem 3 i 6) brojevi */

{
if(i==2 || i==5)
continue;
if( !( isdigit(niz[i]) ) )
{
printf("datum moze sadrzati samo brojeve\n");

kontrola =1;
break;
/* ako je format odgovarajuci, izdvoj podtke o danu mesecu i godini */

if(!kontrola)
{
strncpy( podniz, niz ,2);
podniz[2]='\0';
*d=atoi(podniz);
strncpy( podniz, niz+3 ,2);
podniz[2]='\0';
*m=atoi(podniz);
strncpy( podniz, niz+6 ,4);
podniz[4]='\0';
*g=atoi(podniz);
/* ukoliko je bar jedna od vrednosti 0 (uneto 00 ili slovo).. */

if( !(*d && *m && *g ) )
{
printf("Unete vrednosti moraju bit brojevi razliciti od 00 odnosno 0000\n");
kontrola =1;
}
}while(kontrola);
return 0;
}
int proveri_datum( int xd, int ym, int yg )

{
int max_dana;
int prestupna=0;
/* proveri da li je godnia prestupna */
if((yg % 4)==0)
prestupna =1;
/* utvrdi maks broj dana u mesecu */
if(ym>12)
return 2; /* mesec nije odgovarajuci*/
switch(ym)
{
case 4:
case 6:
case 9:
case 11:
max_dana = 30;
break;
case 2:
if (prestupna)
max_dana=29;
else
max_dana=28;
break;
default:
max_dana=31;
break;
}
if(xd>max_dana)
return 3; /* broj dana u mesecu nije odgovarajuci */
}
return 0;
1. 10 50 for ,
.
/* Inicijalizacija niza */
#include <stdio.h>
int main()
{
int n[10]; /* n je niz od 10 celih brojeva */
int i; /* brojac */
/* inicijalizacija elementa niza na vrednost 50 */
for ( i = 0; i < 10; i++ )
{
n[ i ] = 50; /* dodeli vrednost e0 elementu niza sa indeksom i */
printf( "%s %11s \n\n", "Niz n", "Vrednost" ); /* %s je format za string */
printf("-----------------\n"); /* ispis crtica */
/* ispis vrednosti elemenata niza u obliku
for ( i = 0; i < 10; i++ )
{
printf( "n[%d] %6d\n", i, n[ i ] );
} /* kraj for */
tabele */

2. 2x5 1, 2, 3, 4, 5 2, 4, 6,
8, 10, .
#include <stdio.h>
int main()
{
/* Deklarisanje niza dimenzija 2 x 5 */
int x[2][5] = { {1, 2, 3, 4, 5},
{2, 4, 6, 8, 10} };
int red, kolona;
/* Prikaz elemenata niza po redovima */
for (red=0; red<2; red++)
{
/* Prikaz elemenata niza po kolonama */
for (kolona=0; kolona<5; kolona++)
{
printf("%2d\t", x[red][kolona]);
printf("\n"); /* putchar('\n');*/
} /* kraj spoljasnje for petlje */
return 0;
}/* kraj funkcije main */
3.
/* Inicijalizacija niza */
#include <stdio.h>
int main()
{
int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
int i; /* brojac */
printf( "%s%13s\n\n", "Niz n", "Vrednost" );
for ( i = 0; i < 10; i++ )
{
printf( "n[%d] %6d\n", i, n[ i ] );
} /* kraj for */
tabele */

4. 2 20
/* Inicijalizacija niza parnim brojevima od 2 do 20 */
#include <stdio.h>
#define SIZE 10
int main()/* funkcija main, pocetak izvrsavanja programa */
{
int s[ SIZE ];
int i; /* brojac */
for(i = 0; i < SIZE; i++) /* dodela pocetnih vrednosti */
{
s[i] = 2 + 2 * i;
} /* kraj for */
printf( "%s%13s\n\n", "Niz s", "Vrednost" );
for(i = 0; i < 10; i++)
{
printf( "s[%d] %6d\n", i, s[ i ] );
} /* kraj for */
tabele */

5. . 12
.
/* Izracunavanje sume elemenata niza */
#include <stdio.h>
#define SIZE 12
int main()
{
int a[ SIZE ] = { 1, 3, 5, 4, 7, 2, 99, 16, 45, 67, 89, 45 };
int i; /* brojac */
int suma = 0; /* zbir vrednosti elemenata niza */
for ( i = 0; i < SIZE; i++ ) /* dodela pocetnih vrednosti */
{
suma += a[ i ];
} /* kraj for */
printf( "Zbir svih vrednosti elemenata niza je %d\n", suma );
6. 10 float, ,
.
/* Izdvajanje elementa niza koji ima najvecu vrednost*/
#include<stdio.h>
int main()
{
#define BR_ELEMENATA 10
double niz[BR_ELEMENATA] =
double max;
int i;
{117.0, 129.95, 276.22, 201.10,106.31,

358.11, 31.85, 256.45, 269.09, 197.81};
max = niz[0];
for (i = 1; i < BR_ELEMENATA; i++)
{
if (niz[i] > max) max = niz[i];
/* Primetite da i pocinje od 1 */
}
printf("\nMaksimalna vrednost niza je %f\n", max);
return 0;
}
7. . 1 10.
() .
(. , ....)
#include <stdio.h>
#define BROJ_STUDENATA 40
#define FREKV_VELICINA 11
/* definisi velicinu nizova */

/* 10 ocena, 11 zbog zanemarivanja indeksa 0*/
/* funkcija main pocetak izvrsavanja programa */

int main()
{
int i; /* brojac koji kruzi od 1. do 40. odgovora */
/* inicijaliacija niza sa brojem dobijenih ocena na 0 */
int frekvOcena[FREKV_VELICINA] = { 0 };
/* inicijalizacija niza odgovor studenata, proizvoljno */
int odgovor[ BROJ_STUDENATA ] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10,
1, 6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, 6, 6,
5, 6, 7, 5, 6, 4, 8, 6, 8, 10 };
/* za svaki odgovor, odredite vrednost elementa niza odgovor
i uzmite tu vrednost kao indeks niza frekvOcena i da bi se
pozicionirali na taj element niza frekvOcena i povecajte ga za 1 */
for(i = 0; i < BROJ_STUDENATA; i++)
{
++frekvOcena[ odgovor[i] ];
/* prikazi rezultate */
printf( "Ocena Broj glasova\n" );
/* Prikaz u tabelarnom formatu */
for ( i = 1; i < FREKV_VELICINA; i++ )
{
printf("%5d%14d\n", i, frekvOcena[i]);
} /* kraj for */
return 0;
8. 10 .
30. ,
, .
#include <stdio.h>
#define VELICINA 10 /* definisi velicinu niza */
int main()
{
/* inicializacija niza n */
int n[VELICINA] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };
int i; /* brojac za elemente polja */
int j; /* brojac zvezdica */
printf("Element
Vrednost
Histogram\n" );
/* za svaki element polja ispisi index, vrednost i nacrtaj histogram */

for ( i = 0; i < VELICINA; i++ )
{
/* ispis indeksa i vrednosti*/
printf( "%7d%10d
", i, n[i]) ;
{
for ( j = 1; j <= n[i]; j++ )
printf( "%c", '*' ); /* ispisi jednu zvezdicu */

} /* kraj unutrasnje petlje */
printf( "\n" ); /* kraj ispisa histigrama za jedan element niza */
} /* kraj spoljasnje petlje */
return 0;
9. bubble sort
#include <stdio.h>
#define DIMENZIJA 10
int main()
{
/* inicijalizacija niza a */
int a[DIMENZIJA] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
int prolaz; /* brojac prolaza */
int i;
/* brojac poredjenjar */
int priv;
/* privremeno cuvanje vrednosti */
printf( "Vrednosti niza u pocetnom redosledu\n" );
/* ispisi vrednosti u pocetnom redosledu */
for ( i = 0; i <DIMENZIJA; i++ )
printf( "%4d", a[ i ] );
/* bubble sort */
for ( prolaz = 1; prolaz < DIMENZIJA; prolaz++ )
{
for ( i = 0; i < DIMENZIJA - 1; i++ )
{
/* poredi vrednost susednih elemenata i yameni im mesta ako je
vrednost prvog elementa veca od drugog */
if ( a[i] > a[i + 1] )
{
priv = a[i];
a[i] = a[i + 1];
a[i + 1] =priv;
} /* kraj if */
}
/* kraj spoljasnje for petlje */
printf( "\nVrednosti niza nakon sortiranja\n" );
/* Ispis vrednosti */
for ( i = 0; i < DIMENZIJA; i++ )
printf( "%4d", a[ i ] );
printf( "\n" );
return 0;
1. .
#include <stdio.h>
int main()
{
int broj_a;
int *ptr_br;
float real1, real2;
float *ptr_re;
broj_a=4;
real1=3.2f;
ptr_br = &broj_a; /* pointer ukazuje na adresu prom. broj_a*/
broj_a = broj_a + *ptr_br + 1; /* *ptr_br je sadrzaj adrese na koju ukazuje
*/
printf("\n%d\n",broj_a);
ptr_re=&real1;
real2= *ptr_re;
printf("%f\n",real2);
return 0;
ptr_br = &broj_a; ptr_br
broj_a. broj_a = broj_a + *ptr_br + 1;
broj_a 4+4+1 ...
2. .
#include <stdio.h>
int main()
{
int broj_a, broj_b, broj_c;
int *ptr_br;
broj_a=8;
broj_b=4;
ptr_br=& broj_c; /* pokazivac pokazuje na adresu promen. broj_c */
*ptr_br= broj_a + broj_b; /* isto sto i broj_c = broj_a + broj_b */
printf("\n%d\n",broj_c);
ptr_br=& broj_a; /* pokazivac pokazuje na adresu promen. broj_a */
broj_a = broj_b * broj_c; /* mnozenje */
printf("\n%d\n",*ptr_br);
ptr_br=& broj_b; /* pokazivac pokazuje na adresu promen. broj_b */
return 0;
3. 5. 7.
. 10 . , , 5.
6 7. . .
#include <stdio.h>
int main()
{
int niz[10]={10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int broj_a;
int *ptr_br;
/* pointer ukazuje na 0ti indeks niza */
ptr_br=niz; /* isto sto i ptr =niz[0] ili ptr=&niz[0] */
broj_a= *(ptr_br+4); /* *(ptr+4) citaj kao sadrzaj 5 elementa niza (indeks
4) */
printf("\n%d\n",broj_a);
ptr_br=&niz[6]; /* isto sto i ptr =niz[6]
*/
*(ptr_br-1)=*ptr_br + *(ptr_br +1);

/* ptr pokazuje na niz[6], *(ptr_br-1) je sadrzaj niz[5], *ptr_br je sadrzaj
niz[6]
*(ptr_br +1); je sadrzaj niz[6], pa je ovo ekvival. niz[5]=niz[6]+ niz[7]
*/
printf("\n%d\n",*(ptr_br-1));
printf("\n%d\n",niz[5]);
return 0;
4. : 10
.
1
#include <stdio.h>
int main()
{
int niz[10];
int i;
int *pok;
i=1;
for(pok=niz; pok <= &niz[9]; pok++)
{
printf("upisite %d. element niza\n",i);
scanf("%d", pok);
i++;
}
i=2;
for(pok=&niz[1];pok <= &niz[9]; pok = pok+2)
{
printf("%d. element je: %d\n",i, *pok);
i+=2;
}
return 0;
2
#include <stdio.h>
int main()
{
int niz[10];
int i;
int *pok;
for(pok=niz, i=1; pok <= &niz[9]; pok++, i++)
{
printf("upisite %d. element niza\n",i);
scanf("%d", pok);
}
for(pok=&niz[1], i=2; pok <= &niz[9]; pok = pok+2, i+=2)
printf("%d. element je: %d\n",i, *pok);
return 0;
}
: (,) - (;).
5.
#include <stdio.h>
main()
{
int a[8] = {1,23,17,4,-5,100,55,44};
int *pa, *pb;
int x, y;
pa=&a[4]; /* pa ukazuje na a[4] tj na vrednost -5 */
printf("Vrednost *pa nakon naredbe pa=&a[4] je: %d\n", *pa);
x=*(pa+3); /* x=a[7]=44 */
printf("Vrednost x nakon naredbe x=*(pa+3) je: %d\n", x);
y=*pa+3;
/* y=a[4]+3=-2*/
printf("Vrednost y nakon naredbe y=*pa+3; je: %d\n", y);
*pa++;
/* povecava se sadrzaj pokazivaca, isto sto i *(pa++)
ili pa=&a[5] */
printf("Vrednost *pa nakon naredbe *pa++ je: %d\n", *pa);
(*pa)++;
/* povecava se pokazani podatak a[5]=a[5]+1=101 */
printf("Vrednost *pa nakon naredbe (*pa++) je: %d\n", *pa);
pb=&a[2];
}
6. malloc
#include <stdio.h>
main()
{
int number;
int *ptr;
int i;
printf("Koliko int vrednosti zelite da sacuvate? ");
scanf("%d", &number);
ptr = malloc(number*sizeof(int)); /* zahtev za dodelu memorije */
/* ptr = (int *)malloc(number*sizeof(int)); */ /* moze i ovako */
if(ptr!=NULL)
{
for(i=0 ; i<number ; i++)
{
*(ptr+i) = i;
}
for(i=number ; i>0 ; i--)
{
printf("%d\n", *(ptr+(i-1))); /* prikazi u suprotnom redosledu */
}
free(ptr); /* oslobodi dodeljenu memoriju */
}
else
printf("\nDodela
memorije
nije
izvrsena
memorije.\n");
}
nema
dovoljno
7. calloc
#include <stdio.h>
main()
{
float *ptr_c1, *ptr_c2, *ptr_m1, *ptr_m2;
int i;
ptr_c1
ptr_c2
ptr_m1
ptr_m2
=
=
=
=
calloc(3, sizeof(float)); /* moze se zahtevati konverzija */

calloc(3, sizeof(float));
if(ptr_c1!=NULL
{
printf("adresa
printf("adresa
printf("adresa
printf("adresa
&& ptr_c2!=NULL && ptr_m1!=NULL && ptr_m2!=NULL)

ptr_c1
ptr_c2
ptr_m1
ptr_m2
for(i=0 ; i<3 ; i++)

{
printf("*ptr_c1[%d]
printf("*ptr_c2[%d]
printf("*ptr_m1[%d]
printf("*ptr_m2[%d]
}
je
je
je
je
ima
ima
ima
ima
%05.5p,\n", ptr_c1);
%05.5p,\n", ptr_c2);
%05.5p,\n", ptr_m1);
%05.5p,\n\n", ptr_m2);
vrednost
vrednost
vrednost
vrednost
%05.5f,\n", i, *(ptr_c1+i));
%05.5f,\n", i, *(ptr_c1+i));
%05.5f\n", i, *(ptr_m1+i));
%05.5f,\n\n", i, *(ptr_c1+i));
free(ptr_c1);
free(ptr_c2);
free(ptr_m1);
free(ptr_m2);
}
else
printf("Nema dovoljno memorije\n");
8. realloc
#include<stdio.h>
#include <stdlib.h>
int main()
{
int *ptr;
int i;
ptr = calloc(5, sizeof(int)); /*dinamicki niz od 5 elemenata indeks 0-4
*/
if(ptr!=NULL) /* ako je dodeljena memorija...*/
{
*ptr = 1;
/* isto sto i ptr[0]=1 ili *ptr=1 */
*(ptr+1) = 2; /* isto sto i ptr[1]=2 */
*(ptr+2) = 4;
*(ptr+3) = 8;
*(ptr+4) = 16;
printf("\nNakon
naredbe
calloc(5,
sizeof(int))
i
vrednosti...\n");
for(i=0 ; i<5 ; i++)
dodele
ptr = realloc(ptr, 7*sizeof(int)); /* dodaj jos 2 int (bilo je vec 5)*/

if(ptr!=NULL)
{
printf("\n Nakon naredbe ptr = realloc(ptr, 7*sizeof(int));... \n");
for(i=0 ; i<7 ; i++)
*(ptr+5) =
*(ptr+6) =
32;
64;
printf("\n Nakon naredbe dodele vrednosti 6. i 7. elementu... \n");

for(i=0 ; i<7 ; i++)
realloc(ptr,0); /* isto sto i free(ptr); */
}
else
printf("Nema dovoljno memorije - realloc neuspesan.\n");
}
else
printf("Nema dovoljno memorije - calloc neuspesan.\n");
}
1. (klijenti.dat) ,
. , Ctrl+Z.
:
/* Upis podataka u fajl */
#include <stdio.h>
int main()
{
int broj_racuna;
char ime[ 30 ];
double stanje;
/* broj racuna korisnika */

/* ime korisnika */
/* stanje na racunu */
FILE *prt_na_fajl;
/* prt_na_fajl = fajl pointer
*/
/* fopen otvara fajl, w za upisivanje. */

/* Ukoliko ne uspe pointer je jednak 0, izadji iz programa */
if ( ( prt_na_fajl = fopen( "klijenti.dat", "w" ) ) == NULL )
{
printf( "Fajl se ne moze otvoriti\n" );
} /* kraj if */
else
{
printf( "Unesite broj racuna, ime korisnika i stanje.\n" );
printf( "Unesite Ctrl+Z za kraj rada.\n" );
printf( "? " );
scanf( "%d%s%lf", &broj_racuna, ime, &stanje );
/* Upisite broj racuna, ime i stanje u fajl nredbom fprintf */
while ( !feof( stdin ) )
{
fprintf( prt_na_fajl, "%d %s %.2f\n", broj_racuna, ime, stanje );
printf( "? " );
scanf( "%d%s%lf", &broj_racuna, ime, &stanje );
} /* kraj while */
fclose( prt_na_fajl ); /* fclose zatvara fajl */
} /* kraj else */
return 0; /* oznacava uspesan zavrsetaka */
} /* kraj main */
feof( stdin ) end-of-file .
(stdin),
. (Ctrl+Z) za (end-of-file), feof
1.
0
( )
?
?
?
?
?
?
?
100
121
111
246
343
654
^Z
Petric 324.22
Markovic 0.00
Simic 32.33
vac -34.56
Jack -200
Jon 9567.34
2. ( ), .
:
/* citanje podataka iz fajla*/
#include<stdio.h>
int main()
{
int broj_racuna; /* broj racuna korisnika */
char ime[ 30 ];
/* ime korisnika */
double stanje;
FILE *prt_na_fajl;
/* prt_na_fajl = fajl pointer
*/
/* fopen otvara fajl, r (read) za citanje. */

if ( ( prt_na_fajl = fopen( "klijenti.dat", "r" ) ) == NULL )
{
} /* kraj if */
else
{
printf( "%-14s%-16s%s\n", "Broj racuna","Ime","Stanje" );
fscanf( prt_na_fajl,"%d%s%lf", &broj_racuna, ime, &stanje );
/* Citanje podataka iz fajla naredbom fscanf */
while ( !feof( prt_na_fajl ) )
{
printf( "%-14d%-16s%7.2f\n", broj_racuna,ime, stanje );
} /* kraj while */
} /* kraj else */
return 0; /* oznacava uspesan zavrsetaka */
} /* kraj main */
3.
:
. 0
.
.
.
:
#include<stdio.h>
int main()
{
int zahtev;
int broj_racuna;
char ime[ 30 ];
double stanje;
FILE *prt_na_fajl;
/*
/*
/*
/*
broj racuna korisnika */

ime korisnika */
stanje na racunu */
prt_na_fajl = fajl pointer
*/
/* fopen otvara fajl, r (read) za citanje. */

if ( ( prt_na_fajl = fopen( "klijenti.dat", "r" ) ) == NULL )
else
{
/* prikazi zahtevane opcije */
printf( "Unesite zahtev\n"
" 1 - Izlistaj racune sa stanjem NULA\n"
" 2 - Izlistaj racune sa stanjem u MINUSu\n"
" 3 - Izlistaj racune sa POZITIVNIM stanjem\n"
" 4 - Kraj\n? " );
scanf( "%d", &zahtev );
while(zahtev !=4)
{
switch(zahtev)
{
case 1:
printf( "\nRacuni sa stanjem NULA:\n" );
/* citaj sadrzaj fajla do kraja (sve do eof) */
{
if ( stanje == 0 )
printf( "%-14d%-16s%7.2f\n", broj_racuna, ime, stanje );
/* procitaj broj racuna, ime i stanje iz fajla */
fscanf( prt_na_fajl, "%d%s%lf", &broj_racuna, ime, &stanje );
} /* kraj while */
break;
case 2:
printf( "\nRacuni sa stanjem u MINUSu:\n" );
{
if ( stanje < 0 )
printf( "%-14d%-16s%7.2f\n", broj_racuna, ime,
fscanf( prt_na_fajl, "%d%s%lf", &broj_racuna, ime,
} /* kraj while */
break;
case 3:
printf( "\nRacuni sa POZITIVNIM stanjem:\n" );
{
if ( stanje > 0 )
printf( "%-14d%-16s%7.2f\n", broj_racuna, ime,
fscanf( prt_na_fajl, "%d%s%lf", &broj_racuna, ime,
} /* kraj while */
break;
}/* kraj switch */
stanje );
&stanje );
stanje );
&stanje );
fseek(prt_na_fajl, 0, SEEK_SET); /* pozicioniraj se na pocetak fajla*/

/*potpuno je isto sto i rewind( ptr_na_fajl); */
printf( "\n? " );
scanf( "%d", &zahtev );
} /* kraj while(zahtev !=4 ) */
printf("Kraj rada\n");
} /* kraj else */
} /* kraj main */
4. 100 . : ,
, . 0
, 0 . 100
fwrite
/* Rad sa binarnim fajlovima */
#include <stdio.h>
/* Definicija strukture podaci_klijenta */
struct podaci_klijenta
{
int broj_racuna;
/* broj_racuna klijenta */
char prezime[ 15 ]; /* prezime klijenta */
char ime[ 10 ];
/* ime klijenta */
double stanje;
}; /* kraj definicije strukture */
int main()
{
int i; /* brojac racuna od 1 do 100 */
/* kreiraj promen. novi_klijent tipa strukture podaci_klijenta i inicijalizuj */
struct podaci_klijenta novi_klijent = { 0, "", "", 0.0 };
FILE *ptr_fajl; /* fajl pointer */
/* fopen otvara fajl, izlaz iz programa ukoliko ne uspe */
if ( ( ptr_fajl = fopen( "kredit.dat", "wb" ) ) == NULL )
printf( "Fajl se ne moze otvoriti.\n" );
else
{
/* upisi 100 "praznih" zapisa (struktura) u fajl */
for ( i = 1; i <= 100; i++ )
fwrite( &novi_klijent, sizeof( struct podaci_klijenta ), 1, ptr_fajl );
fclose ( ptr_fajl ); /* fclose zatvara fajl */
} /* kraj else */
return 0; /* indicates successful termination */
} /* end main */
5. .
1 100 ( ).
#include <stdio.h>
{
int broj_racuna;
char ime[ 10 ];
/* ime klijenta */
double stanje;
int main()
{
struct podaci_klijenta klijent = { 0, "", "", 0.0 };
if ( ( ptr_fajl = fopen( "kredit.dat", "rb+" ) ) == NULL )
else
{
/* traziti od korisnika da unese broj racuna */
printf("Unesite broj racuna (1-100):");
scanf("%d", &klijent.broj_racuna);
/* Korisnik treba da unese podatke za klijenta */
while(klijent.broj_racuna>0 && klijent.broj_racuna<101)
{
/* Unos prezimena, imena i stanja */
printf( "Unesite prezime, ime i stanje\n? " );
/* vrednosti */
fscanf( stdin, "%s%s%lf", &klijent.prezime, &klijent.ime, &klijent.stanje );
/* Pozicioniraj se na poziciju racuna (zadao je korisnik) */
fseek( ptr_fajl, ( klijent.broj_racuna - 1 ) *
sizeof( struct podaci_klijenta), SEEK_SET );
/* upisi unete vrednosti u fajl */
fwrite( &klijent, sizeof( struct podaci_klijenta), 1, ptr_fajl);
/* Omogui korisniku da unese podatke za druge racune */
printf( "Unesite broj racuna\n? " );
scanf( "%d", &klijent.broj_racuna );
} /* kraj while*/
fclose( ptr_fajl ); /* fclose zatvara fajl */
} /* kraj else */
} /* kraj main */
6. () .
#include <stdio.h>
{
int broj_racuna;
char ime[ 10 ];
/* ime klijenta */
double stanje;
int main()
{
struct podaci_klijenta klijent = { 0, "", "", 0.0 };
if ( ( ptr_fajl = fopen( "kredit.dat", "rb" ) ) == NULL )
else
{
printf( "%-6s%-16s%-11s%10s\n", "Racun", "Prezime","Ime", "Stanje" );
/* Procitaj sve racune do kraja fajla */
while(!feof(ptr_fajl))
{
fread( &klijent, sizeof( struct podaci_klijenta ), 1, ptr_fajl );
/* prikazi podatke racuna */
if ( klijent.broj_racuna != 0 )
printf( "%-6d%-16s%-11s%10.2f\n",klijent.broj_racuna, klijent.prezime,
klijent.ime,klijent.stanje );
} /* kraj while */
fclose( ptr_fajl ); /* fclose zatvara fajl */
} /* kraj else */
} /* kraj main */

Singidunum Uvod U Programski Jezik C PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Singidunum Uvod U Programski Jezik C PDF

Uploaded by

Copyright:

Available Formats

C

. (Libraries, RunTime Library) .

/*ne preporuuje se upotreba malih slova za simbolicke

tip_podatka ime_podatka = poetna_vrednost;

const float obim=2*radijus*3.14;

printf(%c %d, A, 35);

/* \n je znak za novi red*/

scanf("%c %d %f", &cVar,&dVar, &fVar);

/* broj_c je jednak 6 a nakon toga

izraz2 && izraz2

izraz2 && izraz2

/* 0001 0010 0011 0100 | 0101 00110 0111 1000 = 0x567c */

/* 0001 0010 0011 0100 ^ 0101 00110 0111 1000 = 0x444c */

/* ~ 0001 0010 0011 0100

/* 0000 0000 0010 0000*/

/* isto sto i 5.0+6.0*/

/* 5/4 zbog celobrojnog deljenja je 1 pa je rezultat 4*/

/* (3.0*5)/4, zbog automatske konverzije (3.0*5) postaje (3.0*5.0)

/* parametar funkcije sinus mora biti tipa double */

printf("%d\n %f\n", prom1, prom3);

/* pocetak unutrasnjeg bloka*/

/* kraj unutrasnjeg bloka*/

printf("%d %f\n", prom1, prom3);

/* pocetak unutrasnjeg bloka*/

/* kraj unutrasnjeg bloka*/

printf("%d \n", prom4); /* Greska */

printf("\nVrednost promenljive u spoljasnjem bloku, ponovo, \

count int 5. count

Vrednost promenljive u spoljasnjem bloku, count = 5

%d\n", num1, num2);

if(num1 >= num2)

printf("\nVrednost ocene je %d\n", ocena);

while(izraz) {naredba_1; naredba_2;...;

while(farenhajt <= maks)

(izraz_1, izraz_2 izraz_3) ;

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

for(num = 10; num >= 0 ;

printf("Unesite karkter:\n(unesite x za izlaz)\n");

tip ( int float double....)

int tablica [3]={3, 5, 7, 9};

short kvadratA[4][4]={ {0,1,2,0},{3,4,0,0},{5,6,7,8},{9,0,0,0} };

indeks izvan opsega */

Press any key to continue

/* Nema ; iza pretprocesorske naredbe!*/

{117.0f, 129.95f, 276.22f, 201.10f,106.31f,

for (for ( i = 0; i < BROJ_STUDENATA; i++ ){++frekvOcena[odgovor[i]];})

/* za svaki element polja ispisi index, vrednost i nacrtaj histogram */

} /* kraj spoljasnje petlje */

/* Greska! Tip pokazivaca nije odgovarajuci*/

/* px ukazuje na adresu promenljive x */

/* p1 ukazuje na adresu promenljive x */

*pa nakon naredbe pa=&a[4] je: -5

free(ptr); /* oslobodi dodeljenu memoriju */

int main( void )

calloc(3, sizeof(float)); /* moze se zahtevati konverzija */

&& ptr_c2!=NULL && ptr_m1!=NULL && ptr_m2!=NULL)

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

printf("\n Nakon naredbe dodele vrednosti 6. i 7. elementu... \n");

} while (znak != '.');

char *gets(char *buffer);

puts (const char *string);

int isalnum(int c);

/* slovo ili cifra? */

const float obim=2radijus3.14;

/* (3.05)/4, zbog automatske konverzije (3.05) postaje (3.0*5.0)

char gets(char buffer);

strchr(char str1, c); / trazi prvu poziciju karaktera u stringu */

strrchr(char str1, c); / trai poslednju poziciju karak. u stringu */

/ili float manji(float , float ); /

a=%d, b=%d, v=%c\n",a,b,v);

x=%d, y=%d, w=%c\n",x,y,w);

x=31, y=50, w=G

x=%d, z=%d, t=%d\n",a,x,z,t);