01. Uvod u Programski Jezik C

Goran Banjac

1. Uvod u programski jezik C++

10/28/2010

“C++ is a general-purpose programming language with a bias towards systems programming that: is a better C, supports data abstraction, supports object-oriented programming, and supports generic programming. ”(Bjarne Stroustrup, autor programskog jezika C++)

C++ nije “čisti” objektno-orijentisani programski jezik (OOPL) koji bi korisnika naterao da ga koristi na OO način

Veliki deo jezika C++ je nasleđen iz jezika C, pa C++ predstavlja (uz minimalne izuzetke) nadskup jezika C

Programski jezici 1 2

MinGW kompajliranje:

▪ g++ -c compile-options file.cpp

linkovanje:▪ g++ -o prog link-options file1.o file2.o ... other-libraries

izvršavanje: ▪ prog arguments


#include <iostream>

using namespace std;

int main(int argc, char **argv)

{

cout << "Hello, world!" << endl;

return 0;

}

Linije koje započinju “hash” znakom (#) su pretprocesorske direktive

Nisu iskazi nego indikatori za pretprocesor Obrađuju se pre prevođenja programa Pretprocesorske direktive su: #if, #ifdef, #ifndef, #else, #elif, #endif #include

#define

#undef

#line

#error

#pragma

NULL direktiva Predefinisani macro-i


Kada pretprocesor naiđe na #include direktivu zamenjuje je sadržajem datoteke koja se navodi kao parametar

Dva načina navođenja parametra: #include <nazivdatoteke>

#include “nazivdatoteke”

Razlikuju se po direktorijumima u kojima će kompajler tražiti datoteku

Primeri: #include <iostream>

#include <cmath>


Za definisanje pretprocesorskih macro-a koristi se: #define ime zamena

Primeri: #define PI 3.14159

#define MAX(a,b) ((a)>(b)?(a):(b))

#define REV(T,A,B) { T tmp = A; A = B; B = tmp; }



#include <iostream>

#define PI 3.14159

#define MAX(a,b) ((a)>(b)?(a):(b))

#define REV(T,A,B) { T abc = A; A = B; B = abc; }



{

int a = 10, b = 20;

cout << PI << " " << MAX(a, b) << endl;

REV(int,a,b)

cout << a << " " << b << endl;

cout << MAX(++a, ++b) << endl;

return 0;

}

Namespace omoguća grupisanje entiteta (kao što su, na primer, klase, objekti i funkcije) pod nekim imenom

Na ovaj način, globalni opseg može biti podeljen na podopsege

Definisanje: namespace ime

{

entiteti

}

Za pristup elementima nekog namespace-a koristi se operator ::


Svi entiteti u C++ standardnoj biblioteci su deklarisani u okviru std namespace-a


#include <iostream>

namespace myNamespace

{

int x = 11;

double y = 12.25;

}


{

std::cout << myNamespace::x << " " << myNamespace::y << std::endl;

return 0;

}

Ključna reč using se koristi da se uvede ime iz nekog namespace-a u trenutni deklarativni region


#include <iostream>


namespace firstNamespace

{

int x = 11, y = 12;

}

namespace secondNamespace

{

int x = 21, y = 22;

}


{

using firstNamespace::x;

using secondNamespace::y;

cout << x << " " << y;

return 0;

}


C++ Library Headers

<algorithm> <iomanip> <list> <ostream> <streambuf>

<bitset> <ios> <locale> <queue> <string>

<complex> <iosfwd> <map> <set> <typeinfo>

<deque> <iostream> <memory> <sstream> <utility>

<exception> <istream> <new> <stack> <valarray>

<fstream> <iterator> <numeric> <stdexcept> <vector>

<functional> <limits>

C++ Headers for C Library Facilities

<cassert> <ciso646> <csetjmp> <cstdio> <ctime>

<cctype> <climits> <csignal> <cstdlib> <cwchar>

<cerrno> <clocale> <cstdarg> <cstring> <cwctype>

<cfloat> <cmath> <cstddef>

C++ standardna biblioteka uključuje header datoteku <iostream> gde su deklarisani standardni ulazni i izlazni objekti za rad sa tokovima (eng. stream – dugački niz bajtova)

Podrazumevani standarni izlaz programa je ekran, a objekat za rad sa izlaznim tokom koji pristupa standarndnom izlazu je cout

Standardni ulazni uređaj je obično tastatura, objekat za rad sa ulaznim tokom je cin


Primeri: cout << “Hello, world!”;

cout << “Hello, ” << “world!”;

cout << “Hello, ”;

cout << “world!”;

cout << 350;

cout << hello;

cout << “Hello, world!\n”;

cout << “Hello, world!” << endl;

int a;

cin >> a;

int a, b;

cin >> a >> b;



#include <iostream>



{

int a;

cout << "Hello, world!\n";

cout << "Hello" << "," << " " << "world" << "!" << "\n";

cout << "Hello" << "," << " " << "world" << "!" << endl;

cout << "Hello";

cout << ",";

cout << " ";

cout << "world";

cout << "!";

cout << endl;

cin >> a;

cout << "Echo: " << a;

return 0;

}

Formiraju se od slova, cifara i znaka “_” (eng. underscore) ne mogu započinjati cifrom case-sensitive ključne reči (npr. new, int) se ne mogu koristiti kao identifikatori

Preporučuje se da se kod izbora naziva identifikatora vodi računa o tome šta taj identifikator označava, pa da mu se u skladu s tim da odgovarajući naziv

Primeri validnih identifikatora: value

_abc

abC

ABC

var10

hello_world

Primeri nevalidnih identifikatora: 10var

else

int

new

ab.c


Opseg vidljivosti identifikatora je blok u kojem je deklarisan, kao i u svim ugnježdenim podblokovima, osim ako u njima nije maskiran drugim identifikatorom istog imena

U istom bloku ne može se više puta deklarisati isti identifikator


Promenljiva je simboličko ime za neku memorijsku lokaciju

Svaka promenljiva ima naziv, tip i vrednost Svaka promenljiva mora biti deklarisana pre nego što bude

upotrebljenja Deklaracijom se specificira njen tip i naziv Promenjiva može biti inicijalizovana prilikom deklaracije Tip promenljive se ne može menjati tokom izvršavanja

programa (može da se menja samo vrednost) Primeri: int a, b = 10, c;

double pi = 3.14;

char neg = „-‟, s;


Konstante odgovarajućeg tipa se mogu definisati korištenjem const prefiksa

Definisanoj konstanti nije moguće promeniti vrednost

Primer: const double PI = 3.14;


U C++ postoje dve vrste komentara:

jednolinijski – započinje sa dve kose crte i završava krajem linije

višelinijski – započinje parom simbola /* izavršava sa parom simbola */

Primeri: // ovo je jednolinijski komentar

/* Ovo je

viselinijski

komentar */


Ugrađeni tipovi podataka u C++ se dele na: logičke (bool) znakovne (npr. char) celobrojne (npr. int) realne (npr. double)

Postoji i: tip koji se koristi da označi nedostatak informacija (void)

Dodatno, korisnik može definisati: prebrojive tipove podataka za predstavljanje specifičnog skupa

vrednosti (enum) Iz navedenih tipova moguće je konstruisati druge tipove: pokazivače (npr. double*) nizove (npr. int[]) reference (npr. char&) strukture podataka i klase


Logički tip podataka - bool Koristi da se iskaže rezultat logičkih operacija Može imati dve vrednosti: true i false true ima celobrojnu vrednost 1, false 0 Celobrojni podaci se mogu konvertovati u

logičke:

0 se konvertuje u false

sve osim 0 se konvertuje u true



#include <iostream>



{

bool t1 = true, f1 = false, t2 = 350, f2 = 0;

int a = true, b = false, c = 350;

bool rez1 = t1+f1, rez2 = f1+f2, rez3 = a+c;

int rez4 = t1+f1, rez5 = f1+f2, rez6 = a+c;

cout << t1 << " " << f1 << " " << t2 << " " << f2 << endl;

cout << a << " " << b << " " << c << endl;

cout << rez1 << " " << rez2 << " " << rez3 << endl;

cout << rez4 << " " << rez5 << " " << rez6 << endl;

return 0;

}

Znakovni tipovi podataka su: char

signed char

unsigned char

wchar_t

Varijable tipa char se koriste za smeštanje karaktera iz osnovnog skupa karaktera implementacije (npr. ASCII), a wchar_t za smeštanje karaktera iz većeg skupa karaktera (npr. Unicode)

Svaka znakovna konstanta ima celobrojnu vrednost Implementacijom je definisano da li je char označena ili neoznačena

vrednost Literali tipa char se navode pod jednostrukim navodnicima Primeri:

char a = „a‟;

char b = „0‟;

char c = „\n‟;

char d = 0x40;


‘a’: 6016 + 116 = 6116 = 97 ‘B’: 4016 + 216 = 4216 = 66


0 1 2 3 4 5 6 7 8 9 A B C D E F

00 NULL BELL BS HT LF VT FF CR

10 CAN ESC

20 SPC ! “ # $ % & ‘ ( ) * + , - . /

30 0 1 2 3 4 5 6 7 8 9 : ; < = > ?

40 @ A B C D E F G H I J K L M N O

50 P Q R S T U V W X Y Z [ \ ] ^ _

60 ` a b c d e f g h i j k l m n o

70 p q r s t u v w x y z { | } ~ DEL

Name ASCII Name C++ Name

New line NL (LF) \n

Horizontal tab HT \t

Vertical tab VT \v

Backspace BS \b

Carriage return CR \r

Form feed FF \f

Alert BEL \a

Backslash \ \\

Question mark ? \?

Single quote ' \'

Double quote " \"

Octal number ooo \ooo

Hexadecimal number hh \xhh



#include <iostream>



{

char a = 'a';

char b = 'B';

char c = 48;

cout << a << " " << int(a) << '\n';

cout << b << " " << int(b) << '\n';

cout << c << " " << char(48) << '\n';

cout << int('\n') << '\n';

return 0;

}

Celobrojni tipovi podataka su: int

signed int

unsigned int

Veličine celobrojnih tipova podataka: short int (short) int

long int (long) long long int (long long)

Celobrojni tipovi podataka su, podrazumevano, signed Upotreba unsigned tipa umesto int tipa u cilju dobijanja jednog bit-a

više za predstavljanje pozitivnih celobrojnih podataka nije dobra ideja Takođe, upotreba unsigned tipa ne znači da neki podatak ne može biti

negativan (zbog implicitne konverzije) usigned tipovi su idelni za upotrebu kada se prostor posmatra kao niz

bit-a


Literali celobrojnih tipova podataka mogu biti: decimalni (0, 78, 123) oktalni (0, 0116, 0173) – prefiks kod oktalnih literala je 0 heksadecimalni (0x0, 0x4e, 0x7B) – prefiks kod heksadecimalnih literala je

0x

Kod celobrojnih literala moguće je koristiti i sufikse za specifikaciju tipa: celobrojni literal bez sufiksa je, podrazumevano, tipa int unsigned literal se specificira korištenjem sufiksa u ili U long literal se specificira korištenjem sufiksa l ili L long long literal se specificira korištenjem sufiksa ll ili LL

Primeri: 123

123u

123l

123ul



#include <iostream>



{

unsigned int a = 65535u;

int b = 123, c = 0173, d = 0x7B, e = -654;

unsigned long ul = 9876543ul;

short f = a;

cout << a << endl;

cout << b << " " << c << " " << d << " " << e << endl;

cout << ul << endl;

cout << f << endl;

return 0;

}

Realni tipovi podataka služe za predstavljanje brojeva u pokretnom zarezu

Tri veličine realnih tipova podataka: float (single-precision) double (double-precision) long double (extended-precision)

Literali: podrazumevani literal za predstavljanje realnih podataka je tipa double float literal se specificira korištenjem sufiksa f ili F long double literal se specificira korištenjem sufiksa l ili L

Primeri: 1.23

.23f

1.

1.23e2

123e-2



#include <iostream>



{

float a = 1.23, b = 1., c = .23, d = 1.23e2f;

double e = 1.23456;

cout << a << " " << b << " " << c << " " << d << endl;

cout << e << endl;

cout << 1/2 << " " << 1/2.f << " " << 1/2. << endl;

return 0;

}

Standardom nisu definisane veličine ugrađenih tipova podataka <limits>, <climits> i <cfloat> pružaju detalje o

implementaciji ugrađenih tipova podataka Takođe, veličina nekog objekta ili nekog tipa podatka se može

dobiti korištenjem operatora sizeof Ono što je garantovano, kada su veličine ugrađenih tipova u

pitanju, je sledeće: char ima najmanje 8 bit-a shortint ima najmanje 16 bit-a long int ima najmanje 32 bit-a 1 ≡ sizeof(char) ≤ sizeof(short) ≤ sizeof(int) ≤ sizeof(long) ≤ sizeof(long

long) sizeof(float) ≤ sizeof(double) ≤ sizeof (long double) sizeof (N) ≡ sizeof (signedN) ≡ sizeof (unsignedN)

▪ N može biti char, short int, int ili long int


Primer:


Tip Veličina

char 1 byte

wchar_t 2 byte-a

short int 2 byte-a

int 4 byte-a

long int 4 byte-a

long long int 8 byte-ova

bool 1 byte

float 4 byte-a

double 8 byte-ova

long double 12 byte-ova


#include <iostream>

#include <limits>



{

cout << "sizeof(char) = " << sizeof(char) << endl;

cout << "char digits = " << numeric_limits<char>::digits << endl;

cout << "char is_signed = " << numeric_limits<char>::is_signed << endl;

cout << "int max = " << numeric_limits<int>::max() << endl;

cout << "int min = " << numeric_limits<int>::min() << endl;

cout << "float has_denorm = " << numeric_limits<float>::has_denorm << endl;

return 0;

}

Tip void se koristi kao:

povratni tip za funkcije koje nemaju povratne vrednosti

pokazivač na objekat nekog tipa

Ne postoje objekti void tipa

void val; //greska


enum je tip koji može sadržavati skup vrednosti specificiranih od strane korisnika

Definisanje: enum ime { lista-enumeratora };


#include <iostream>


enum Week { Mon, Tue = 2, Wed, Thu = Tue+Wed, Fri, Sat, Sun = 10 };


{

cout << Mon << " " << Tue << " " << Wed << " " << Thu << " ";

cout << Fri << " " << Sat << " " << Sun << endl;

return 0;

}

Pokazivač je promenljiva koja sadrži adresu nekog objekta Ako promenljiva pa sadrži adresu nekog objekta a, tada

“pa pokazuje na a” Operatori za rad sa pokazivačima: adresni operator: & (daje adresu nekog objekta u memoriji) operator indirekcije: * (omogućava indirektan pristup

promenljivoj koristeći pokazivač na tu promenljivu) Deklaracija pokazivača: T *ime;

Pošto niti jedan objekat ne može biti alociran sa adresom 0, 0 se ponaša kao pokazivački literal koji označava da pokazivač ne pokazuje na objekat



#include <iostream>



{

char c = 'a';

char *pc = &c;

char **ppc = &pc;

char c2 = *pc;

char c3 = **ppc;

cout << c << " " << c2 << " " << c3 << endl;

return 0;

}

‘a’c:

&cpc:

&pcppc:

Korištenjem operatora new moguće je dinamički alocirati potrebnu količinu memorije na heap-u

Sintaksa: new tip

new tip(args)

new tip[broj-elemenata]

Operator new vraća pokazivač na dodeljeni prostor, a tip pokazivača je tip *

Za oslobađanje dinamički zauzete memorije koristi se operator delete

Sintaksa: delete pokazivac;

delete [] pokazivac;



#include <iostream>



{

int *pi = 0;

char *pc = 0;

pi = new int;

*pi = 10;

pc = new char('a');

cout << *pi << " " << *pc;

delete pi;

delete pc;

return 0;

}

Referenca je alternativno ime za neki objekat Ne zauzima prostor u memoriji i ne može da se

dobije njegova adresa Mora da se inicijalizuje prilikom definisanja

(mora da upućuje na neki stvarni objekat) Sve operacije deluju na stvarne podatke, a ne na

reference Glavna primena referenci je prenos argumenata

u funkciju Primer: int a = 10;

int &ra = a;



#include <iostream>



{

int a = 10;

int &ra = a;

cout << a << " " << ra << endl;

ra++;

cout << a << " " << ra << endl;

int b = ra;

cout << b << endl;

b = 15;

cout << a << " " << ra << " " << b << endl;

a = 20;

cout << a << " " << ra << " " << b << endl;

return 0;

}

Aritmetički operatori: + (sabiranje), - (oduzimanje), *(množenje), / (deljenje) i % (moduo), ++ (inkrement) i --(dekrement)

Relacioni operatori: < (manje), > (veće), <= (manje ili jednako), >= (veće ili jednako), == (jednako) i != (različito)

Logički operatori: && (AND), || (OR) i ! (NOT) Bitski operatori: & (bitsko AND), | (bitsko OR), ~ (bitsko

NOT), ^ (bitsko XOR) Operatori pomeranja: << (pomeranje bita u levo), >>

(pomeranje bita u desno) Operator dodele vrednosti: = Složeni operatori dodele: +=, -=, *=, /=, %=, >>=, <<=, &=, |=, ^=


Uslovni (ternarni) operator: uslov ? izraz1 : izraz2

Primer: a = (b == 0) ? 0 : 1;

Inkrement i dekrement: i++ ≡ ++i ≡ i = i + 1

i-- ≡ --i ≡ i = i – 1

Primer: i = 10;

j = (i++) + 10;

// i = 11, j = 20

i = 10;

j = (++i) + 10;

// i = 11, j = 21


Prioriteti operatora i pravila asocijativnosti definišu kako će izraz biti izračunat kada se u njemu javlja više operatora

Primer izraza, bez zagrada i sa zagradama, koji se identično izračunavaju: x + y * z

x + (y * z)

Ako operatori imaju isti prioritet, onda se redosled operacija određuje na osnovu pravila asocijativnosti: x * y / z

(x * y) / z



Prioritet Operatori Asocijativnost

Najviši :: →

[] () {} . -> ++ --

typeid→

++ -- sizeof new delete

~ ! - + & * (type)←

.* ->* →

* / % →

+ - →

<< >> →

< <= > >= →

== != →

& →

^ →

| →

&& →

|| →

?: ←

= *= /= %= += -= >>=

<<= &= |= ^=←

Najniži , →


#include <iostream>



{

short a = 0x9B, r1, r2, r3, r4, r5;

r1 = a & 0xA;

r2 = a | 0xA;

r3 = a ^ 0xA;

r4 = ~a;

r5 = -0x9B;

int b = 3, c = -8, d, e, f;

d = b << 2;

e = b >> 1;

f = c >> 2;

int p1 = 10, p2, p3;

p2 = 10 + 5/2*p1;

p3 = 10 + 5/2.*p1;

double p4 = 10 + 5/2*p1, p5 = 10 + (double)5/2*p1;

cout << r1 << " " << r2 << " " << r3 << " " << r4 << " " << r5 << endl;

cout << d << " " << e << " " << f << endl;

cout << p2 << " " << p3 << " " << p4 << " " << p5 << endl;

return 0;

}


#include <iostream>


int x;


{

int a = 1;

cout << x << endl;

int x = 20;

cout << x << " " << ::x << endl;

{

int a = 2;

cout << a << " ";

a = x == 0 ? 10 : 20;

cout << a << endl;

}

cout << a << endl;

return 0;

}

Postoje 4 osnovne kategorije naredbi za kontrolu toka:

naredbe uslovnog grananja: if, if else i switch

naredbe petlji: while, do while i for

naredbe za nasilnu promenu toka: break, continue i return

naredbe za rad sa izuzecima: try catch i throw


Koristi se kada se treba odlučiti da li će se neki iskaz/složeni iskaz izvršiti u zavisnosti od ispunjenosti određenog uslova

Sintaksa: if (uslov)

iskaz ili slozeni-iskaz

Primeri: if (a > 0)

cout << “Broj je pozitivan.”;

if (a > 0)

{


}


Koristi se kad je potrebno odlučiti koji će se iskaz/složeni iskaz od dva izvršiti u zavisnosti od ispunjenosti nekog uslova

Sintaksa: if (uslov)

iskaz1 ili slozeni-iskaz1

else

iskaz2 ili slozeni-iskaz2

Primer: if (a > 0)


else

cout << “Broj nije pozitivan.”;


if else naredbe je moguće ugnježdavati gde se naredna if else naredba povezuje sa prethodnom else klauzulom

Na taj način se dobija kaskada if elsenaredbi

Primer: if (a > 0)


else if (a < 0)

cout << “Broj je negativan.”;

else

cout << “Broj je jednak 0.”;


Omogućava realizaciju selektivnog višeblokovskog grananja

Sintaksa: switch (selektorski-izraz)

{

case labela1: niz-iskaza1

case labela2: niz-iskaza2

…

case labelan: niz-iskazan

default: niz-iskaza

}

switch izraz mora da proizvede celobrojnu vrednost Ako se želi izlaz iz naredbe kada se završi odgovarajući case, treba koristiti naredbu break (inače će propasti u sledeći case)


Primer: switch (number)

{

case 1:

cout << “Jedan”;

break;

case 2:

cout << “Dva”;

break;

case 3:

cout << “Tri”;

break;

default:

cout << “Nepoznat broj”;

}


Sintaksa: while (uslov-izvrsavanja-petlje)

telo-petlje

Uslov izvršavanja while petlje izvršava se pre izvršavanja tela petlje

Ukoliko je uslov izvršavanja petlje nije istinit pri prvom testiranju, telo petlje se neće izvršiti niti jednom


Primer: int i = 1, suma = 0;

while (i < 100)

{

suma += i;

i++;

}


Sintaksa: do

telo-petlje

while (uslov-izvrsavanja-petlje);

Uslov izvršavanja petlje se izračunava nakon izvršavanja tela petlje

Telo do while petlje se uvek izvršava bar jedanput, tj. telo do while petlje se može izvršiti jednom ili više puta


Primer: int i = 1, suma = 0;

do

{

suma += i;

i++;

}

while (i < 100);


Sintaksa: for (inicijalizacija; uslov-izvrsavanja-petlje; izraz-

za-inkrementiranje)

telo-petlje

for petlja se sastoji iz zaglavlja i tela petlje Zaglavlje for petlje čine tri sekcije: sekcija za inicijalizaciju

sekcija za testiranje uslova izvršavanja petlje

sekcija u kojoj se nalazi izraz za inkrementiranje Inicijalizacija podrazumeva deklaraciju i inicijalizaiciju

promenljive koja kontroliše telo petlje i izvršava se samo jednom (prilikom ulaska u petlju)


Ako je uslov izvršavanja petlje istinit izvršava se telo petlje U suprotnom, telo petlje se ne izvršava Nakon svake iteracije izvršava se izraz za inkrementiranje Nakon toga proverava se uslov izvršavanja petlje Opseg vidljivosti promenljivih koje su deklarisane za

vreme inicijalizacije for petlje je određen blokom forpetlje, tako da ove promenljive nisu dostupne nakon završetka for petlje

Za vreme inicijalizacije moguće je deklarisati više promenljivih, odvojenih zarezom

Sve sekcije u for petlji su opcione Izostavljanje sekcije za proveru uslova izvršavanja petlje

označava da je uslov uvek istinit


Primeri: int suma = 0;

for (int i = 0; i < 100; i++)

{

suma += i;

}

for (int i = 0, j = 1; i < 10 && j != 15;

i++, j *= 2)

cout << i + j << “ ”;

for ( ; ; )

;


break naredba: prekida naredbu petlje i prelazi na prvi iskaz iza naredbe

petlje

prekida naredbu switch i prelazi na prvi iskaz iza naredbe switch

continue naredba: prekida naredbu petlje i otpočinje sledeću iteraciju petlje

return naredba: izlazak iz funkcije

▪ prekida izvršavanje funkcije (svi iskazi iza return se ignorišu)

▪ prekid programa (iz funkcije main)

omogućava da funkcija vrati neku vrednost



#include <iostream>



{

for (int i = 0 ; i < 100; i++)

{

if (i == 75)

break;

if (i % 10 == 0)

continue;

cout << i << " ";

};

return 0;

}

Nizovi

jednodimenzionalni

višedimenzionalni

Strukture Unije


Najjednostavniji način da se napravi složeniji tip podatka (u odnosu na ugrađene tipove) jeste davanje alternativnih imena (alijasa) drugim imenima pomoću ključne reči typedef

Sintaksa: typedef postojeci-tip alijas

Primer: typedef unsigned long ulong

ulong a, b;


Niz ili vektor je jednodimenzionalno polje Skup podataka istog tipa U memoriji se smešta u niz uzastopnih

memorijskih lokacija Ime niza predstavlja početnu adresu niza u

memoriji Svaki element je određen imenom niza i

indeksom (pomerajem u odnosu na početak niza) ako niz ima n elemenata prvi element niza ima indeks 0, a poslednji n-1


Deklaracija niza: tip ime-niza [broj-elemenata] = { lista-vrednosti }

Primeri: int niz[5];

char text[255];

int niz1[3] = {1, 2, 3}; // 1, 2, 3

int niz2[] = {1, 2, 3}; // 1, 2, 3

int niz3[3] = {10}; // 10, 0, 0

niz3[1] = 5; // 10, 5, 0

niz3[2] = niz3[0] + niz3[1]; // 10, 5, 15

int niz[3] = {1, 2, 3, 4}; // greska

int niz[]; // greska



#include <iostream>


const int MAX_SIZE = 10;


{

int n, sum = 0, a[MAX_SIZE];

double avg;

do

{

cout << "Unesite broj elemenata niza: ";

cin >> n;

}

while (n < 1 || n > 10);

for (int i = 0; i < n; i++)

{

cout << i+1 << ". element: ";

cin >> a[i];

sum += a[i];

}

avg = double(sum)/n;

cout << endl;

cout << "Aritmeticka sredina: " << avg << endl;

for (int i = 0; i < n; i++)

if (a[i] > avg)

cout << a[i] << " ";

return 0;

}

Elementni niza mogu biti drugi nizovi; na taj način se dobijaju višedimenzionalni nizovi

Primeri: int mat[2][3];

int mat[2][3] = {{1, 2, 3}, {4, 5, 6}}; // mat[0][1] == 2

▪ // 1, 2, 3 | 4, 5, 6

int mat[2][3] = {{1, 2, 3}};

▪ // 1, 2, 3 | 0, 0, 0

int mat[2][3] = {1, 2, 3, 4, 5, 6};

▪ // 1, 2, 3 | 4, 5, 6

int mat[][3] = {{1, 2, 3}, {4, 5, 6}};

▪ // 1, 2, 3 | 4, 5, 6

int mat[][3] = {1, 2, 3, 4, 5, 6, 7};

▪ // 1, 2, 3 | 4, 5, 6 | 7, 0, 0

int mat[][3] = {{1, 2}, {3, 4, 5}, {6}, {7}};

▪ // 1, 2, 0 | 3, 4, 5 | 6, 0, 0 | 7, 0, 0

int mat[][3]; //greska

int mat[2][] = {{1, 2, 3}, {4, 5, 6}}; //greska

int a[3][4][5];

int a[][7][8]; //greska

int b[3][3][3][3];



#include <iostream>



{

int mat1[][3] = {{1}, {0, 1}, {0, 0, 1}};

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

int mat3[3][2] = {0};

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

for (int j = 0; j < 2; j++)

for (int k = 0; k < 3; k++)

mat3[i][j] += mat1[i][k] * mat2[k][j];

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

{

for (int j = 0; j < 2; j++)

cout << mat3[i][j] << " ";

cout << endl;

}

return 0;

}

Ime jednodimenzionalnog niza predstavlja adresu početnog elementa niza i samo po sebi je pokazivač (statički pokazivač)

Primeri: int a[10] = {0};

int *p = a; // int *p = &a[0];

int *q = &a[4]; //

*p = 10; // a[0] = 10;

*(p+1) = 20; // a[1] = 20;

p++; // p = &a[1];

*(p-1) = 30; // a[0] = 30;

*q++ = 10; // a[4] = 10; q = &a[5];

(*q)++; // a[5]++;

*++q = 40; // a[6] = 40;

a[3] = q – p; // a[3] = 5;

int a[2][3] = {0};

int *p = &a[0][0]; //int *p = a[0];

*(p + 3*i + j) = 10; // a[i][j] = 10;



#include <iostream>



{

int a[10] = {0};

int *p = a;

int *q = &a[4];

*p = 10;

*(p+1) = 20;

p++;

*(p-1) = 30;

for (int i = 0; i < 10; i++)

cout << *(p+i-1) << " ";

cout << endl;

*q++ = 10;

(*q)++;

*++q = 40;

a[3] = q - p;

for (int i = 0; i < 10; i++)

cout << a[i] << " ";

return 0;

}


#include <iostream>



{

int a[2][3] = {0};

int *p = &a[0][2];

*p = 1;

p++;

*p = 2;

*(p+1) = 3;

for (int i = 0; i < 2; i++)

{

for (int j = 0; j < 3; j++)

cout << a[i][j] << " ";

cout << endl;

}

p = a[0];

for (int i = 0; i < 2; i++)

{

for (int j = 0; j < 3; j++)

cout << *(p + 3*i + j) << " ";

cout << endl;

}

return 0;

}


#include <iostream>



{

int n, *parray = 0;

do

{

cout << "Unesite broj elemenata niza: ";

cin >> n;

}

while (n < 1 || n > 100);

parray = new int[n];

for (int i = 0; i < n; i++)

{

cout << i+1 << ". element: ";

cin >> *(parray + i);

}

for (int i = n - 1; i > -1; i--)

cout << *(parray + i) << " ";

delete [] parray;

return 0;

}

String je jednodimenzionalni niz znakova koji završava null-znakom („\0‟) – znak čiji je kod 0

String literal je niz znakova koji se navodi pod dvostrukim navodnicima “Ovo je string literal”

Primeri: char c1[] = “Hello”;

char c2[] = {„H‟, „e‟, „l‟, „l‟, „o‟, „\0‟};

char c3[] = "a\xd\0127"



#include <iostream>



{

char str[] = "Banja Luka";

char *p = str;

int i;

for (i = 0; *(p + i); i++)

;

cout << "strlen (\"" << str << "\"): " << i;

return 0;

}

Struktura je skup heterogenih podataka koji su međusobno logički povezani

Deklaracija: struct ime-strukture

{

tip1 element1;

tip2 element2;

…

tipn elementn;

} lista-promenljivih;

Primer: struct point

{

double x, y;

} var1, var2, varArray[100], *pvar;


Alternativni oblik deklaracije: struct ime-strukture

{

tip1 element1;

tip2 element2;

…

tipn elementn;

};

ime-strukture lista-promenljivih;


{

double x, y;

};

point var1, var2, varArray[100], *pvar;


U slučaju da u istom bloku postoji podatak prostog tipa i stuktura sa istim imenom tada se mora koristiti ključna reč struct


{

double x, y;

};

int point = 10;

struct point a;


Elementima strukture se pristupa pomoću operatora . Primer:

struct point

{

double x, y;

};

point var, varray[5];

var.x = 10.0;

var.y = 20.0;

varray[0].x = 15.5;

varray[0].y = 100;

U slučaju da imamo definisan pokazivač na strukturu, tada se elementima strukture može pristupiti pomoću operatora ->


{

double x, y;

};

point var, *pvar = &var;

pvar->x = 10.0; // (*pvar).x = 10.0;

pvar->y = 20.0; // (*pvar).y = 20.0;


Element strukture može da bude neka druga struktura Primer: struct point

{

double x, y;

};

struct line

{

point a, b;

};

line l;

l.a.x = 10.0;

l.a.b = 20.0;


Element strukture može da bude i pokazivač Primer: struct point

{

double *x, *y;

};

double a = 10.0, b = 20.0;

point p, *pp = &p;

p.x = &a;

pp->y = &b;

*p.x = 15.0;

*pp->y = 25.0;



#include <iostream>

#include <cmath>


struct point

{

double x, y;

};

struct line

{

point a, b;

};


{

point p = {3.0, 4.0};

line l;

l.a = p;

l.b.x = 0.0;

l.b.y = 0.0;

double len = sqrt((l.a.x-l.b.x)*(l.a.x-l.b.x) + (l.a.y-l.b.y)*(l.a.y-l.b.y));

cout << len;

return 0;

}


#include <iostream>


struct point

{

double *x, *y;

};


{

double xx, yy;

point p, *pp = &p;

p.x = &xx;

*p.x = 10.0;

pp->y = &yy;

*pp->y = 20.0;

cout << xx << " " << yy;

return 0;

}

Kombinovanjem pokazivača na strukturu i strukture sa pokazivačem možemo da dobijemo strukturu sa pokazivačem na istu strukturu tj. imamo povezane strukture

Primer (jednostruko povezana lista): struct node

{

int data;

node *next;

};

node *head = new node;

head->data = 10;

head->next = 0;

node *second = new node;

second->data = 20;

second->next = 0;

head->next = second;


10 20 0

head nextdata nextdata

Unija je skup podataka različitih tipova koji su smešteni u isti memorijski prostor

Promena jednog podataka u uniji može dovesti do promene drugog podataka u uniji

Deklaracija: union ime-unije

{

tip1 element1;

tip2 element2;

…

tipn elementn;

} lista-promenljivih;

Primer: union example

{

char c;

int x;

} var;


Alternativni oblik deklaracije: union ime-unije

{

tip1 element1;

tip2 element2;

…

tipn elementn;

};

ime-unije lista-promenljivih;


{

char c;

int x;

};

example var, varArray[100], *pvar;


U slučaju da u istom bloku postoji podatak prostog tipa i unija sa istim imenom tada se mora koristiti ključna reč union


{

char c;

int x;

};

int example= 10;

union example a;


Elementima unije se pristupa preko operatora .


{

char c;

int x;

};

example a;

a.x = 10;

a.c = „a‟;


Uniju je moguće definisati i bez korštenja identifikatora iza ključne reči union – bezimena unija

Članovi bezimene unije ponašaju se kao “obične promenljive”

Primer: union { int x; char c; };

x = 10;

c = „a‟;

Unija za koju je definisan neki podatak nije bezimena Primer: union { int x, char c; } var;

var.x = 10;

var.c = „a‟;



#include <iostream>



{

union example

{

char c;

int x;

};

example ex;

ex.x = 256;

ex.c = 'a';

cout << ex.c << " " << ex.x;

return 0;

}

Funkcija se obično definiše kao potprogram koji na osnovu određenog broja argumenata daje jedan rezultat

Podatak koji vraća funkcija naziva se povratna vrednost funkcije

Tip funkcije je tip podataka koji funkcija vraća


Definicija funkcije: tip ime-funkcije(tip1 arg1, tip2 arg2, … , tipn argn)

telo-funkcije

Formalni argumenti – automatske promenljive kroz koje funkcija prima podatake

Opšti oblik poziva funkcije: ime-funkcije(sarg1, sarg2, … , sargn)

Stvarni argumenti – parametri koji se šalju funkciji


Deklaracija (prototip) funkcije predstavlja “opis funkcije za spoljašnji svet”

Deklaracija funkcije sadrži tip funkcije, ime funkcije, tipove (a može i imena) argumenata

Opšti oblik deklaracije: tip ime-funkcije(tip1, tip2, … , tipn);



#include <iostream>


int circleLeftShift8(int value)

{

int res, left, right;

left = value << 8;

right = value >> 24;

res = left | right & 0xff;

return res;

}


{

int a = 0xefffffff, r;

r = circleLeftShift8(a);

cout << r << endl;

cout << circleLeftShift8(1) << endl;

r = 10 + circleLeftShift8(a);

cout << r << endl;

return 0;

}


#include <iostream>


int duplicate(int);


{

cout << duplicate(10);

return 0;

}

int duplicate(int x)

{

return 2*x;

}


#include <iostream>


void printHello()

{

cout << "Hello, world!" << endl;

}


{

printHello();

return 0;

}

Prenos parametara u funkciju putem vrednosti prilikom poziva funkcija šalje se vrednost funkcija prihvata vrednost u formalne argumente po izlasku iz funkcije formalni argumenti automatski

nestaju Dakle, kod prenosa parametara u funkciju putem

vrednosti, u funkciji se kreira slika stvarnih argumenata i koriste se te slike, a ne stvarne promenljive

Nakon izlaska iz funkcije stvarne promenljive ostaju nepromenjene



#include <iostream>


void increase(int x)

{

cout << "increase: " << x << endl;

x++;


}


{

int x = 10;

cout << "main: " << x << endl;

increase(x);


return 0;

}

Da bi se omogućilo da funkcija menja vrednost stvarnog argumenta, potrebno je:

1. način:

▪ formalni argument definisati kao pokazivač

▪ u telu funkcije koristiti operator indirekcije

▪ prilikom poziva funkcije proslediti adresu stvarnog argumenta

2. način:

▪ vršiti prenos parametara u funkciju putem reference



#include <iostream>


void increase(int *x)

{

cout << "increase: " << *x << endl;

(*x)++;

cout << "increase: " << *x << endl;

}


{

int x = 10;


increase(&x);


return 0;

}


#include <iostream>


void increase(int &x)

{


x++;


}


{

int x = 10;


increase(x);


return 0;

}

U definiciji funkcije moguće je navesti podrazumevane vrednosti formalnih argumenata

Podrazumevane vrednosti formalnih argumenata se koriste kad u pozivu funkcije nedostaju stvarni argumenti

Ako se za neki argument navede neka podrazumevana vrednost, onda se podrazumevana vrednost mora navesti i za sve argumente iza njega

Prilikom poziva funkcije mogu se izostaviti samo poslednji argumeni (nema preskakanja)

Dozvoljeno je navođenje podrazumevanih vrednosti za sve argumente



#include <iostream>


int add(int a, int b = 0)

{

return a+b;

}


{

int a = 10, b = 20;

cout << add(a, b) << endl;

cout << add(a) << endl;

return 0;

}

Preklapanje imena funkcija (eng. function overloading) – moguće je definisati više funkcija istog imena ukoliko se one razlikuju po broju i/ili tipu argumenata

Dakle, prevodilac razlikuje preklopljene funkcije samo preko argumenata

Posebnu pažnju treba obratiti kod funkcija sa podrazumevanim vrednostima argumenata



#include <iostream>


int add(int a, int b)

{

cout << "int2" << endl;

return a+b;

}

int add(int a, int b, int c)

{

cout << "int3" << endl;

return a+b+c;

}

double add(double a, double b)

{

cout << "double" << endl;

return a+b;

}


{

cout << add(10, 20) << endl;

cout << add(10, 20, 30) << endl;

cout << add(10.5, 20.5) << endl;

return 0;

}


#include <iostream>


int add(int a, int b = 0)

{

cout << "int" << endl;

return a+b;

}

int add(int a, double b = 0.0)

{

cout << "double" << endl;

return a+b;

}


{

cout << add(10, 10) << endl;

cout << add(10, 10.0) << endl;

//cout << add(10) << endl;

return 0;

}

Inline funkcije – za jednostavnije funkcije pogodnije je direktno ugrađivanje u kod, nego da se nezavisno prevode i pozivaju iz nekog koda jer se tako ubrzava rad, štede resursi

Prevodilac ne mora da uvaži inline sugestiju i u tom slučaju se funkcija ponaša kao “standardna” funkcija

Opšti oblik: inline tip ime-funkcije (tip1 arg1, … , tipn argn)

telo-funkcije



#include <iostream>


inline int max(int a, int b)

{

return (a > b) ? a : b;

}


{

int a = 10, b = 20;

cout << max(a, b) << endl;

cout << max(++a, ++b) << endl;

return 0;

}

Rekurzivne funkcije su funkcije koje pozivaju same sebe

Na taj način se rešavanje nekog problema svodi na rešavanje istog, ali jednostavnijeg problema i funkcija poziva samu sebe sve dok problem ne postane trivijalan

Rekurzivne funkcije su manje efikasne, ali postoje problemi koji su po prirodi jednostavni i koje je gotovo nemoguće rešiti bez rekurzije



#include <iostream>


int factorial(int x)

{

if (x == 0)

return 1;

else

return x*factorial(x-1);

}


{

cout << factorial(5);

return 0;

}

automatske promenljive: navode se korištenjem ključne reči auto definišu se u telu funkcija i mogu da se koriste samo u funkciji u kojoj su

definisane nastaju automatski u funkciju i automatski nestaju nakon izlaska iz funkcije podrazumeva se da je promenljiva automatska, ukoliko se drugačije ne

navede nemaju podrazumevanu vrednost

globalne promenljive: definišu se izvan svih funkcija ako se u definiciji ne navede vrednost, podrazumeva se da je vrednost

definisane promenljive 0

vidljiva je u svim funkcijama koje su definisane nakon definicije date promenljive

korištenjem ključne reči extern moguće je eksplicitno navesti korištenje neke globalne promenljive u funkciji


registarske promenljive: automatske promeljive za kojima je izražena želja da se drže u

registrima procesora ne garantuje se da će promenljiva strvarno biti registarska –

zavisi od konkretnog prevodioca, procesora, ukupnog broja registarskih promenljivih

definišu se korištenjem ključne reči register statičke promenljive: definišu se korištenjem ključne reči static vrednost im se određuje pre početka izvršavanja progama ukoliko se vrednost ne navede, podrazumeva se početna

vrednost 0

postoje od početka do kraja izvršavanja programa (vrednost im ostaje sačuvana do sledećeg poziva date funkcije)



#include <iostream>


int g;

void function()

{

auto int i = 10;

static int si = 10;

i++;

si++;

g++;

cout << i << " " << si << " " << g << endl;

}


{

cout << g << endl;

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

function();

return 0;

}

main(int argc, char **argv)

argc – broj argumenata

argv – niz argumenata

Argumenti komandne linije su stringovi Naziv programa se prosleđuje kao prvi

argument Primer: for (int i = 0; i < argc; i++)

cout << *(argv + i);



#include <iostream>



{

if (argc == 3)

{

for (int i = 0; i < argc; i++)

{

if (i == 0)

cout << "Naziv programa je: " << *argv << endl;

else

cout << i << ". argument je: " << *(argv + i) << endl;

}

}

else

{

cout << *argv << ": broj argumenata je pogresan" << endl;

cout << "Koristenje: " << *argv << " arg1 arg2";

}

return 0;

}

01. Uvod u Programski Jezik C

Documents

cout b

autor programskog jezika

goran banjac c

uvod u programski jezik

systems programming

programming language

generic programming

namespace std int mainint