Elektrotehniki fakultet

Banja Luka

Programski jezici 1

GENERIKI MEHANIZAM

Goran Banjac
goran.banjac@etfbl.net

12/24/14

Generiki mehanizam
Sadraj

Koncept generikog mehanizma

Generisanje funkcija

Generisanje klasa

Generisanje funkcija lanica

abloni i prijatelji

abloni i nasleivanje

Kontejnerski abloni i iteratori

STL

Koncept generikog mehanizma

Generiki mehanizam omoguava automatsko generisanje klasa i funkcija (od strane

prevodioca) na osnovu ablona (template).

ablon predstavlja definiciju klase ili funkcije koja u sebi sadri, kao formalne
argumente, tipove koji e u fazi generisanja konkretne klase ili funkcije biti
zamenjeni konkretnim tipovima.

Na primer, esto je u praksi potreban vei broj funkcija koje se identino ponaaju, ali nad
razliitim tipovima podataka (npr. funkcija za sortiranje). Ovo je mogue realizovati
preklapanjem funkcija. Meutim, programer mora da napie sve te funkcije, za svaki tip po
funkciju - moe da bude naporno i dugotrajno!

Slino je i sa klasama. esto se u praksi definiu klase koje implementiraju iste operacije nad
svojim podacima lanovima, ali su ti podaci razliitih tipova. Npr. klasa Niz treba da se ponaa
isto bez obzira na to da li je re o nizu celih brojeva ili nizu realnih brojeva. Slino je i sa ostalim
kontejnerskim klasama (lista, stek, stablo, ...).

Generiki mehanizam obezbeuje da kompajler automatski generie odgovarajuu

funkciju ili klasu za konkretan tip podataka. Pri tome programer mora da definie
izgled ili ablon te funkcije ili klase sa tipom podataka kao argumentom.

Generikim mehanizmom uvode se tzv. parametrizovani tipovi, odnosno klase ija e

se stvarna definicija generisati na osnovu parametra (argumenta), koji predstavlja
tip podataka nad kojima klasa operie.

Iz jednog ablona klase moe da se generie proizvoljan broj konkretnih klasa.

Slino je i sa ablonima funkcija.

Koritenjem generikog mehanizma ne gubi se na efikasnosti programa, jer se

konkretne klase i funkcije generiu u toku prevoenja programa, kao da ih je
programer sam pisao. Generiki mehanizam ubrzava produkciju softvera.

Koncept generikog mehanizma

Generiki mehanizam omoguava automatsko generisanje klasa i funkcija (od strane

prevodioca) na osnovu ablona (template).

ablon predstavlja definiciju klase ili funkcije koja u sebi sadri, kao formalne
argumente, tipove koji e u fazi generisanja konkretne klase ili funkcije biti
zamenjeni konkretnim tipovima.

Na primer, esto je u praksi potreban vei broj funkcija koje se identino ponaaju, ali nad
razliitim tipovima podataka (npr. funkcija za sortiranje). Ovo je mogue realizovati
preklapanjem funkcija. Meutim, programer mora da napie sve te funkcije, za svaki tip po
funkciju - moe da bude naporno i dugotrajno!

Slino je i sa klasama. esto se u praksi definiu klase koje implementiraju iste operacije nad
svojim podacima lanovima, ali su ti podaci razliitih tipova. Npr. klasa Niz treba da se ponaa
isto bez obzira na to da li je re o nizu celih brojeva ili nizu realnih brojeva. Slino je i sa ostalim
kontejnerskim klasama (lista, stek, stablo, ...).

Generiki mehanizam obezbeuje da kompajler automatski generie odgovarajuu

funkciju ili klasu za konkretan tip podataka. Pri tome programer mora da definie
izgled ili ablon te funkcije ili klase sa tipom podataka kao argumentom.

Generikim mehanizmom uvode se tzv. parametrizovani tipovi, odnosno klase ija e

se stvarna definicija generisati na osnovu parametra (argumenta), koji predstavlja
tip podataka nad kojima klasa operie.

Iz jednog ablona klase moe da se generie proizvoljan broj konkretnih klasa.

Slino je i sa ablonima funkcija.

Koritenjem generikog mehanizma ne gubi se na efikasnosti programa, jer se

Generisanje funkcija

ablon funkcije (function template)

definicija funkcije koju prevodilac
koristi za generisanje konkretne
funkcije.
esto se naziva i
generika funkcija.

ablonska funkcija (template function)

konkretna funkcija generisana na
osnovu ablona funkcije.
ORIGINALNI KOD

GENERISANI KOD
// Sablonska funkcija za int
void funkcija(int x)
{
cout << x;
}

// Sablon funkcije
template <class Tip>
void funkcija(Tip x)
{
cout << x;
}

// Sablonska funkcija za double

void funkcija(double x)
{
cout << x;
}

// glavni program
int main()
{
int i=100; funkcija(i);
double d=5.25; funkcija(d);
return 0;
}

// glavni program
int main()
{
int i=100; funkcija(i);
double d=5.25; funkcija(d);
return 0;
}

Generisanje funkcija
ablon moe da ima vie parametara,
ali svi moraju da budu
tipovi
(ispred svakog se navodi class ili
// ISPRAVNOtypename)!
template <class T>
void funkcija(T data)
{ cout << data; }
// ISPRAVNO
template <class T>
T funkcija(T data)
{ T x(data); return x;

Primer:

#include <iostream>
using namespace std;
template <typename T>
void f1(T i) { cout << i << endl; }
template <typename T>
T f2(int i) { return (T)i; }

// ISPRAVNO
template <class T1, class T2>
void funkcija(T1 x, T2 y)
{ cout << x << y; }

Poziv ablonske funkcije:

funkcija(argument) ili
funkcija<tip>(argumenti).

int main()
{
f1(100); f1('A');
f1<int>(200); f1<char>('B');
cout << f2<int>(100) << endl;
cout << f2<char>(100) << endl;
return 0;
}
100
A
200
B
100
d

Generisanje funkcija
Primer:

#include <iostream>
using namespace std;
template <class Tip>
void sort(Tip niz[], int n)
{
int i, j, rb;
Tip tmp;
for (i=0; i<n-1; i++)
{
for (rb=i, j=i+1; j<n; j++)
if (niz[j]<niz[rb]) rb=j;
if (rb!=i)
{
tmp = niz[i];
niz[i] = niz[rb];
niz[rb] = tmp;
}
}
original: 15 3245 3 62
}
sortirano: 3 15 62 3245
original: 12.5 5
sortirano: 5 12.5

template <class Tip>

void print(Tip niz[], int n)
{
for (int i=0; i<n; i++)
cout << niz[i] << " ";
cout << endl;
}
int main()
{
int x1[] = { 15, 3245, 3, 62 };
double x2[] = { 12.5, 5.0 };
cout << "original: "; print(x1,4);
sort(x1,4);
cout << "sortirano: "; print(x1,4);
cout << endl;
cout << "original: "; print(x2,2);
sort(x2,2);
cout << "sortirano: "; print(x2,2);
return 0;
}

Generisanje funkcija

ablonom funkcije generie se itava

familija funkcija sa preklopljenim
imenom!

Razreavanje poziva ablonske

funkcije:
1.
Trai se funkcija sa potpunim
slaganjem tipova argumenata
2.
Ako se ona ne pronae, trai se
ablon iz kojeg se moe generisati
funkcija sa potpunim slaganjem
3.
Primenjuju se uobiajena pravila
za razreavanje poziva pomou
konverzija

Primer:
#include <iostream>
using namespace std;
template <class Tip>
Tip maks(Tip a, Tip b)
{
cout << "(Sablon
a=";
cout << a << " b=" << b <<") ";
return (a>b) ? a : b;
}
int maks(int a, int b)
{
cout << "(Original a=";
cout << a << " b=" << b <<") ";
return (a>b) ? a : b;
}
int main()
{
int a=100, b=200;
char c='C', d='D';
int m1 = maks(a,b);
cout << "\tm1: " <<
char m2 = maks(c,d); cout << "\tm2: " <<
int m3 = maks(c,d);
cout << "\tm3: " <<
int m4 = maks(a,c);
cout << "\tm4: " <<
return 0;
}

(Original
(Sablon
(Sablon
(Original

m1
m2
m3
m4

<<
<<
<<
<<

endl;
endl;
endl;
endl;

a=100 b=200)
a=C b=D)
a=C b=D)
a=100 b=67)

m1:
m2:
m3:
m4:

200
D
68
100

Generisanje klasa

ablon klase (class template)

definicija klase koju prevodilac
koristi za generisanje konkretne klase.
esto
se naziva i generika klasa.
ablonska klasa (template class)
konkretna klasa generisana na osnovu
ablona klase.
ORIGINALNI KOD

GENERISANI KOD
// Sablonska klasa za int
class Klasa<int>
{
public: int data;
};

// Sablon klase
template <class Tip>
class Klasa
{
public: Tip data;
};

// Sablonska klasa za char

class Klasa<char>
{
public: char data;
};

// glavni program
int main()
{
Klasa<int> i;
i.data=100; cout << i.data;
Klasa<char> c;
c.data=A; cout << c.data;
return 0;
}

// glavni program
int main()
{
Klasa<int> i;
i.data=100; cout << i.data;
Klasa<char> c;
c.data=A; cout << c.data;
return 0;
}

Generisanje klasa
Primer:
#include <iostream>
using namespace std;
template <class T>
class Niz
{
public:
Niz(int nn=1)
{
void set(int ii, T dd) {
void print()
{
~Niz()
{
private:
T *data;
int n;
};

n = (nn<1)?1:nn; data = new T[n]; }

if (ii>=0 && ii<n) data[ii]=dd; }
for (int i=0; i<n; i++) cout << data[i] << " ";
delete [] data; }

int main()
{
Niz<int> x(5);
for (int i=0; i<5; i++) x.set(i,i);
cout << "x: "; x.print(); cout << endl;
Niz<char> y(10);
for (int i=0; i<100; i++) y.set(i,'A'+i);
cout << "y: "; y.print(); cout << endl;
return 0;
}

x: 0 1 2 3 4
y: A B C D E F G H I J

Generisanje klasa
Primer:
#include <iostream>
using namespace std;

Osim formalnog argumenta koji

predstavlja tip (parametar klase),
ablon klase moe da ima i argumente
koji predstavljaju konkretne objekte
(nisu parametri).

template <class T, int N=10>

class Niz
{
public:
Niz()
{ n=-1; data = new T[N]; }
void dodaj(T dd) { if (n<N-1) { n++; data[n]=dd; } }
void print()
{ for (int i=0; i<=n; i++) cout << data[i] << " ";
~Niz()
{ delete [] data; }
private:
T *data;
int n;
};
int main()
{
Niz<int,5> x;
for (int i=0; i<5; i++) x.dodaj(i);
cout << "x: "; x.print(); cout << endl;
typedef Niz<char> REC; REC y;
for (int i=0; i<100; i++) y.dodaj('A'+i);
cout << "y: "; y.print(); cout << endl;
return 0;
}

x: 0 1 2 3 4
y: A B C D E F G H I J

Generisanje funkcija lanica

Primer: (Razdvojen interfejs i
Funkcija lanica nekog ablona klase je
implicitno i generika funkcija (ablon
funkcije), pri emu su argumenti
ablona klase ujedno i argumenti
ablona funkcije.
Primer:
#include <iostream>
using namespace std;
template <class T, int N>
class Niz
{ public:
Niz() { n=-1; }
void dodaj(T dd)
{ if (n<N-1) { n++; niz[n]=dd; }}
void print()
{ for (int i=0; i<=n; i++)
cout << niz[i] << " "; }
private: T niz[N]; int n;
};
int main()
{
Niz<int,5> x;
for (int i=0; i<5; i++) x.dodaj(i);
x.print();
return 0;
}

implementacija)

#include <iostream>
using namespace std;
template <class T, int N>
class Niz
{ public: Niz();
void dodaj(T dd);
void print();
private: T niz[N]; int n;
};
template <class T, int N>
Niz<T,N>::Niz() { n=-1; }
template <class T, int N>
void Niz<T,N>::dodaj(T dd)
{ if (n<N-1) { n++; niz[n]=dd; }}
template <class T, int N>
void Niz<T,N>::print()
{ for (int i=0; i<=n; i++)
cout << niz[i] << " ";

int main()
{
Niz<int,5> x;
for (int i=0; i<5; i++) x.dodaj(i);
x.print();
return 0;

Generisanje funkcija lanica

Primer:
#include <iostream>
using namespace std;
template <class T>
class Stek
{
public:
Stek(int=10);
~Stek();
int push(T&);
int pop(T&);
int prazan() const;
int pun() const;
private:
int max;
int vrh;
T *stekPtr;
};
template <class T>
Stek<T>::Stek(int m)
{
max=(m>0 && m<100)?m:0;
vrh = -1;
stekPtr = new T[max];
}

template <class T>

Stek<T>::~Stek()
{
delete [] stekPtr;
}
template <class T>
int Stek<T>::push(T &el)
{
if (!pun())
{
stekPtr[++vrh] = el;
return 1;
}
return 0;
}
template <class T>
int Stek<T>::pop(T &el)
{
if (!prazan())
{
el = stekPtr[vrh--];
return 1;
}
return 0;
}

template <class T>

int Stek<T>::prazan() const
{ return vrh==-1; }
template <class X>
int Stek<X>::pun() const
{ return vrh==max-1; }
int main()
{
Stek<int> stek(5);
int x=1;
cout << "Punjenje: ";
while (stek.push(x))
cout << x++ << " ";
cout << "\nStek je pun!";
cout << " Ne moze: " << x;
cout << "\nPraznjenje: ";
while (stek.pop(x))
cout << x << " ";
cout << "\nIspraznjeno!";
return 0;
}

Punjenje: 1 2 3 4 5
Stek je pun! Ne moze: 6
Praznjenje: 5 4 3 2 1
Ispraznjeno!

abloni i prijatelji
Prijateljstvo moe biti uspostavljeno izmeu ablona
klase i:
1.

neke globalne funkcije,

2.

neke funkcije lanice druge klase,

neke funkcije lanice drugog ablona klase.

Ako imamo ablon klase:
Ako imamo ablon funkcije
3.

template <class T> class X

{ friend void f1(); };
f1() je prijatelj svake klase generisane
iz X.
Ako imamo ablon klase:
template <class T> class X
{ friend class Y; };

template <class T>

void f2(X<T> &x);
i ako imamo ablon klase:
template <class T> class X
{ friend void f2<>(X &); };
f2() je prijatelj svake klase generisane
iz X.

Y je prijatelj svake klase generisane iz

X.
Ako imamo ablon klase:
template <class T> class X
{ friend class Y<T>; };
ablonska klasa generisana iz ablona
Y za tip T je prijatelj ablonske klase
generisane iz ablona X za tip T.

Ako imamo ablon klase:

template <class T> class X
{ friend void Y::f3(); };
Funkcija lanica f3() klase Y je prijatelj
svake ablonske klase generisane iz X.

abloni i prijatelji
Primer:
#include <iostream>
using namespace std;
template <class T> class X;
void f()
{ cout << "Prijatelj!" << endl; }
template <class T>
void read(X<T> &x)
{ cout << "data? "; cin >> x.data; }
template <class T>
void print(X<T> &x)
{ cout << "data: " << x.data; }
template <class T>
void set(X<T> &x, T dd)
{ x.data = dd; }
template <class T>
T get(X<T> &x)
{ return x.data; }

template <class T>

class X
{
friend void f();
friend void read<>(X &x);
friend void print<>(X &x);
friend void set<>(X &x, T dd);
friend T get<>(X &x);
private:
T data;
};
int main()
{
X<int> x;
f();
set(x,100);
cout << get(x) << endl;
read(x); print(x);
return 0;
}

Alternative za deklaraciju
prijatelja u klasi:
friend T get <T> (X &x)
friend T get <T> (X<T> &x)
friend T get <> (X<T> &x)

Prijatelj!
100
data? 50
data: 50

abloni i prijatelji
Primer:
#include <iostream>
using namespace std;
template <class T> class X;
template <class T>
ostream &operator<<(ostream &out, X<T> &x)
{ return out << x.data << endl; }
template <class T>
class X
{
friend ostream &operator<< <>(ostream &, X &);
friend istream &operator>>(istream &in, X &x)
{ return in >> x.data; }
private:
T data;
};
int main()
{
X<int> x;
cout << "Unesite x: "; cin >> x;
cout << "Uneli ste: " << x;
return 0;
}

Unesite x: 5
Uneli ste: 5

abloni i nasleivanje
ablonska klasa moe da bude osnovna klasa i da se
iz nje izvede neka druga konkretna neablonska
#include <iostream>
klasa.
class SedmicnaTemp : public Red<int,7>
using namespace std;
{
template <class T, int N>
public:
class Red
double prosjecna()
{
{
public:
double d=0;
Red() { n=0; }
for (int i=1; i<=n; i++) d+=data[i];
int dodaj(T dd)
return d/n;
{
}
if (n>=N) return 0;
void print()
data[++n]=dd; return 1;
{
}
cout << "Temperature: ";
Red<int,7>::print();
virtual void print()
cout << "\nProsek: " << prosjecna();
{
}
for (int i=1; i<=n; i++)
};
cout << data[i] << " ";
int main()
}
{
protected: T data[N+1]; int n;
int t[7] = { 14, 12, 17, 6, -2, 0, -1 };
};
SedmicnaTemp temp;
for (int i=0; i<7; i++) temp.dodaj(t[i]);
Temperature: 14 12 17 6 -2 0 -1
Red<int,7> *r=&temp; r->print();
Prosek: 6.57143
return 0;
}
Primer:

abloni i nasleivanje
Primer:
#include <iostream>
#include <cstring>
using namespace std;
class Ime
{ public:
Ime(const char *t) : s(0)
{
if (t != 0)
{
s = new char[strlen(t)+1];
strcpy(s,t);
}
}
~Ime() { delete [] s; }
protected: char *s;
};

BCD = {2}
BCD = {2,0,1,3,4}

int main()
{
Skup<int,5> x("BCD");
x.dodaj(2); x.print();
for (int i=0; i<10; i++)
if (!x.dodaj(i)) break;
x.print();
return 0;
}

ablon moe da se izvede

iz neke neablonske i/ili ablonske klase.
template <class T, int N>
class Skup : public Ime
{
public:
Skup(const char *c) : Ime(c),n(-1) {}
int dodaj(T dd)
{
if (n>=N-1) return 0;
for (int i=0; i<=n; i++)
if (data[i]==dd) return -1;
data[++n]=dd;
return 1;
}
void print()
{
cout << s << " = {";
for (int i=0; i<n; i++)
cout << data[i] << ",";
cout << data[n] << "}\n";
}
protected: T data[N]; int n;
};

abloni i nasleivanje
ablon moe da se izvede
iz drugog ablona.

Primer:

#include <iostream>
using namespace std;
int main()
{
template <class T, int N> class Niz
Red<int,4> x;
{ public:
cout << "Punjenje reda: ";
Niz() { n=-1; }
for (int i=0; i<10; i++)
int dodaj(T dd)
if (x.dodaj(i)) cout << i << " ";
{ if (n>=N-1) return 0;
else
niz[++n]=dd; return 1; }
{ cout << "\nRed je pun!"; break; }
void print()
int data;
{ for (int i=0; i<=n; i++)
while (x.uzmi(data))
cout << niz[i] << " "; }
{
protected: T niz[N]; int n;
cout << "\nPraznjenje: " << data;
};
cout << " Ostalo: "; x.print();
}
template <class T, int N>
return 0;
class Red : public Niz<T,N>
}
{ public:
int uzmi(T &data)
{ if (this->n<0) return 0;
Punjenje reda: 0 1 2 3
data = this->niz[0];
Red je pun!
for (int i=0; i<this->n; i++)
Praznjenje: 0 Ostalo: 1 2 3
this->niz[i]=this->niz[i+1];
Praznjenje: 1 Ostalo: 2 3
this->n--;
return 1;
Praznjenje: 2 Ostalo: 3
}
Praznjenje: 3 Ostalo:
Pristup nasleenim lanovima
};

treba preko this-> ili

abloni i nasleivanje
Primer:
#include <iostream>
using namespace std;
template <class T> class Niz
{ public:
Niz() { n=0; data = new T[1]; }
void dodaj(T dd)
{ if (n == 0) data[n++] = dd;
else
{ T *temp = new T[++n];
for (int i=0; i<n-1; i++)
temp[i] = data[i];
temp[n-1]=dd;
delete [] data;
data = temp; }
}
virtual void print()
{
for (int i=0; i<n; i++)
cout << data[i] << " ";
}
~Niz() { delete [] data; }
protected: T *data; int n;
};

Red: 2 4 8 16 32 64
Pocetni: 2
Krajnji: 64

ablon moe viestruko da se izvede iz vie

ablona.

template <class T>

class Pristup
{
public:
virtual T pocetni() = 0;
virtual T krajnji() = 0;
};

template <class T>

class Red : public Niz<T>, public Pristup<T>
{
public:
T pocetni()
{ return this->data[0]; }
T krajnji()
{ return this->data[this->n-1]; }
};
int main()
{
Red<int> red;
for (int i=2; i<100; i*=2) red.dodaj(i);
cout << "Red: "; red.print();
cout << "\nPocetni: " << red.pocetni();
cout << "\nKrajnji: " << red.krajnji();
return 0;
}

Kontejnerski abloni i iteratori

glava

rep

Primer: (Jednostruko povezana lista)

#include <iostream>
using namespace std;
template<class T>
class Lista
{
struct Cvor
{
T data;
Cvor *next;
Cvor(T &t)
{ data=t; next=0; }
} *glava, *rep;

data

next

void print()
{
Cvor *tmp = glava;
if (tmp)
cout << "Lista: ";
while (tmp)
{
cout << tmp->data
<< " ";
tmp = tmp->next;
}
}

public:
Lista() : glava(0), rep(0) {}
~Lista()
Lista& plus(T t)
{
{
while (glava)
if (glava==0)
{
glava = rep = new Cvor(t);
Cvor *tmp =
else
glava->next;
{
delete glava;
rep->next = new Cvor(t);
glava = tmp;
rep = rep->next;
}
}
}
return *this;
};
}

data

next

data

next

int main()
{
Lista<int> li;
for (int i=1; i<5; i++)
li.plus(100+i);
li.print(); cout << endl;
Lista<string> ls;
ls.plus("BL").
plus("BG").
print();
return 0;
}

Lista: 101 102 103 104

Lista: BL BG

Kontejnerski abloni i iteratori

Primer: (Lista sa iteratorom)
#include <iostream>
using namespace std;
template <class T> struct X
{ T data; X *next;
X(T &t):data(t),next(0){}
};
template <class T> class Iterator;
template <class T> class Lista
{ friend class Iterator<T>;
public:
Lista():glava(0),rep(0){}
Lista& dodaj(T t)
{
if (glava==0)
glava=rep=new X<T>(t);
else
{ rep->next=new X<T>(t);
rep=rep->next; }
return *this;
}
~Lista()
{ while(glava)
{ X<T> *t=glava->next;
delete glava; glava=t; }
}
private: X<T> *glava, *rep;
};

Iterator je svojevrstan "spoljni pokaziva", koji

omoguava da se pristupi nekom elementu
kontejnera i da se pree na drugi element.
int main()
template <class T>
{
class Iterator
Lista<int> li;
{
for (int i=1; i<5; i+
private:
+)
Lista<T> &ref; X<T> *x;
li.dodaj(100+i);
public:
Iterator(Lista<T>
Iterator<int> it1(li);
&l):ref(l)
cout << "Original: ";
{ x = ref.glava; }
do
int operator++()
it1.print();
{
while
(++it1);
if (x->next==0)
return 0;
it1=50;
x=x->next;
Iterator<int> it2(li);
return 1;
cout << "\nNova: ";
}
do
Iterator &operator=(T t)
it2.print();
{ x->data = t;
while (++it2);
return *this; }
return 0;
void print()
}
{
Original: 101 102 103
cout << x->data
<< " ";
104
}
Nova: 101 102 103 50
};

STL: <vector>
Primer 1: Kreiranje vektora

Primer 2: Dodavanje elemenata u vektor

#include <iostream>
#include <vector>
using namespace std;
template<class T>
void print(const vector<T> &v)
{
for (int i=0; i<v.size(); i++)
cout << v[i] << " ";
cout << endl;
}

#include <iostream>
#include <vector>
#include <string>
using namespace std;
template<class T>
void print(const vector<T> &v)
{
cout << "niz: ";
for (int i=0; i<v.size(); i++)
cout << v[i] << " ";
cout << endl;
}
int main()
{
vector<string> niz;
niz.push_back("BL");
niz.push_back("BG"); print(niz);
niz.insert(niz.begin(),"SK"); print(niz);
niz.insert(niz.begin(),2,"A"); print(niz);
niz.insert(niz.end(),"0"); print(niz);
return 0;
}

int main()
{
vector<int> niz1;
cout << "niz1: " << niz1.size();
cout << " elemenata\n";
vector<double> niz2(5);
cout << "niz2: " << niz2.size();
cout << " elemenata\n";
vector<char> niz3(5, 'A');
cout << "niz3: ";
print(niz3);
return 0;
}

niz1: 0 elemenata
niz2: 5 elemenata
niz3: A A A A A

niz:
niz:
niz:
niz:

BL BG
SK BL BG
A A SK BL BG
A A SK BL BG 0

STL: <vector>
Primer 3: Brisanje elemenata iz vektora
#include <iostream>
#include <vector>
using namespace std;
template<class T>
void print(const vector<T> &v)
{
cout << "Niz: ";
for (int i=0; i<v.size(); i++)
cout << v[i] << " ";
cout << endl;
}

Niz: 10 11 12 13 14 15
Brisanje s kraja: 15
Niz: 10 11 12 13 14
Brisanje s pocetka: 10
Niz: 11 12 13 14
Brisanje prva dva elementa
Niz: 13 14

int main()
{
vector<int> niz;
for (int i=10; i<16; i++)
niz.push_back(i);
print(niz);
cout << "\nBrisanje s kraja: " << niz.back() << endl;
niz.pop_back(); print(niz);
cout << "\nBrisanje s pocetka: " << niz.front() << endl;
niz.erase(niz.begin()); print(niz);
cout << "\nBrisanje prva dva elementa\n";
niz.erase(niz.begin(),niz.begin()+2); print(niz);
return 0;
}

STL: <vector>
Primer 4: Elementarni iteratori
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
vector<int> niz;
for (int i=10; i<16; i++)
niz.push_back(i);
vector<int>::iterator i;
cout << "Niz: ";
for (i=niz.begin(); i<niz.end(); i++)
cout << *i << " ";
cout << endl;
reverse(niz.begin()+1,niz.end()-1);
cout << "Naopako: ";
for (i=niz.begin(); i<niz.end(); i++)
cout << *i << " ";
cout << endl;
return 0;
}

Niz: 10 11 12 13 14 15
Naopako: 10 14 13 12 11 15

STL: <vector>
Primer 5: U/I iteratori
#include <iostream>
#include <vector>
#include <iterator>
using namespace std;
int main()
{
vector<int> niz;
cout << "Unesite podatke: ";
istream_iterator<int> in(cin);
istream_iterator<int> eos; // end-of-stream iterator
while (in!=eos)
{
niz.push_back(*in);
in++;
}
cout << "\nHorizontalni ispis:\n";
ostream_iterator<int> out1(cout," ");
copy(niz.begin(),niz.end(),out1);
cout << "\n\nVertikalni ispis:\n";
ostream_iterator<int> out2(cout,"\n");
copy(niz.begin(),niz.end(),out2);
return 0;
}

Unesite podatke: 23 1 456 321 56 a

Horizontalni ispis:
23 1 456 321 56
Vertikalni ispis:
23
1
456
321
56