close

Enter

Log in using OpenID

2. Promjenljive i ulazni tok

embedDownload
2. Promjenljive i ulazni tok
Programi koji su demonstrirani u prethodnom poglavlju su potpuno beskorisni, jer uvijek ispisuju
jedan te isti tekst na ekran. Da bismo od programa imali ikakve koristi, oni moraju biti u stanju da
prihvataju podatke od korisnika, da ih obrađuju, i da prezentiraju korisniku rezultate obrade. Za
ostvarivanje ovih zadataka, programski jezik C++ poput mnogih drugih programskih jezika koristi
posebne objekte koji se nazivaju promjenljive ili varijable.
Posmatrano na fizičkom nivou, promjenljive možemo shvatiti kao određene dijelove radne memorije
zadužene za čuvanje vrijednosti podataka koji se obrađuju u programu. Svaka promjenljiva se u memoriji
čuva na određenoj adresi (adresa je najčešće neki broj koji određuje tačno mjesto u memoriji gdje se
promjenljiva čuva). Kako bi rukovanje sa promjenljivim zasnovano na upotrebi adresa bilo veoma mučno,
promjenljivim se dodjeljuju imena, koja služe za pristup njihovom sadržaju. Na taj način je programer
oslobođen potrebe da razmišlja o adresama. Stoga, na logičkom nivou, promjenljive možemo posmatrati
kao imena kojima su predstavljeni podaci koji se obrađuju. Sljedeća slika ilustrira ovaj koncept na
primjeru tri promjenljive nazvane redom “x”, “starost” i “slovo”, koje sadrže redom vrijednosti
“5.12”, “21“ i “A“ (posljednji primjer jasno ukazuje da vrijednost promjenljive ne mora nužno da bude
broj):
x
5.12
starost
21
slovo
A
U nekim programskim jezicima ime promjenljive u potpunosti određuje promjenljivu. U jeziku C++,
svaka promjenljiva pored imena mora imati i svoj tip. Tip promjenljive određuje vrstu podataka koji se
mogu čuvati u promjenljivoj, kao i operacije koje se mogu obavljati nad tim podacima. Na primjer,
ukoliko je neka promjenljiva cjelobrojnog tipa, u njoj se mogu čuvati samo cijeli brojevi, i nad njenim
sadržajem se mogu obavljati samo operacije definirane za cijele brojeve.
U jeziku C++ se svaka promjenljiva mora najaviti (deklarirati) prije nego što se prvi put upotrijebi u
programu. Primjer deklaracije promjenljive izgleda ovako:
Tip promjenljive
Ime promjenljive (identifikator)
int broj;
Ovim deklariramo promjenljivu nazvanu “broj“ koja može sadržavati samo cjelobrojne (engl.
integer) vrijednosti, što je određeno tipom promjenljive (u ovom slučaju “int”). C++ spada u jezike tzv.
stroge tipizacije, što znači da svaka promjenljiva mora imati svoj tip, koji striktno određuje skup mogućih
vrijednosti (tzv. domen promjenljive) koje se mogu čuvati u toj promjenljivoj. Za početak ćemo koristiti
samo promjenljive cjelobrojnog tipa, dok ćemo se kroz kasnija poglavlja upoznavati i sa drugim tipovima.
Vidjećemo također da programer može definirati i svoje vlastite tipove podataka.
Imena promjenljivih i funkcija su specijalan slučaj tzv. identifikatora. Identifikatori smiju sadržavati
samo alfanumeričke znakove (tj. slova i brojke), pri čemu prvi znak mora biti slovo. Pored toga,
dozvoljena su samo slova engleskog alfabeta, tako da naša slova (“č”, “ć” itd.) nisu dozvoljena u
identifikatorima. Tako su imena “a”, “Sarajevo”, “carsija”, “a123”, “U2” i “x2y7” legalna, dok
imena “čaršija”, “2Pac” i “7b” nisu (dakle, “burek” je legalno, ali “ćevapi” nije legalno ime
promjenljive). Dalje, razmaci u identifikatorima takođe nisu dozvoljeni. Prema tome, “moj broj” nije
legalno ime promjenljive. Umjesto toga, možemo koristiti ime “mojbroj” ili, još bolje, ime “MojBroj”
(neki udžbenici preporučuju korištenje imena poput "mojBroj", tako da je početno slovo uvijek malo
slovo).
Veoma je važno naglasiti da je C++ tzv. “case sensitive” jezik, što znači da pravi striktnu razliku
između malih i velikih slova. Tako su “mojbroj”, “MOJBROJ” i “MojBroj” tri legalna, ali posve različita
identifikatora. Dakle, mogu postojati tri potpuno različite promjenljive sa gore pomenutim imenima (što
je, naravno, loša praksa). Kao generalno pravilo, imena svih ugrađenih naredbi, funkcija i objekata jezika
C++ sadrže isključivo mala slova, dok imena mnogih konstanti (koje ćemo uskoro upoznati) definiranih u
standardnim blibliotekama jezika C++ često sadrže samo velika slova.
Pored slova i cifri, identifikatori mogu sadržavati i donju crticu “_” (engl. underscore), tako da je
“moj_broj” također legalan identifikator. Ovu crticu treba razlikovati od obične crtice “-“ (engl.
hyphen), tako da ime “moj-broj” nije legalno. Principijelno, donja crtica je ravnopravna sa slovima, tako
da identifikatori mogu čak i početi donjom crticom. Drugim riječima, imena poput “_xyz” pa čak i
“_____” predstavljaju potpuno legalna imena. Suvišno je i reći da je upotreba ovakvih identifikatora
veoma loša praksa.
Postoje izvjesne riječi koje, mada formalno ispunjavaju sve gore postavljene uvjete, ne mogu biti
identifikatori zbog toga što je njihovo značenje precizno utvrđeno pravilima jezika C++ i ne mogu se
koristiti ni za šta drugo. Takve riječi nazivaju se rezervirane ili ključne riječi. Standard jezika C++
predviđa sljedeće ključne riječi:
and
bitand
case
compl
default
dynamic_cast
extern
friend
int
new
or
public
short
static_cast
this
typedef
unsigned
volatile
and_eq
bitor
catch
const
delete
else
false
goto
long
not
or_eq
register
signed
struct
throw
typeid
using
wchar_t
asm
bool
char
const_cast
do
enum
float
if
mutable
not_eq
private
reinterpret_cast
sizeof
switch
true
typename
virtual
xor
auto
break
class
continue
double
explicit
for
inline
namespace
operator
protected
return
static
template
try
union
void
xor_eq
Radi lakšeg uočavanja rezervirane riječi se u programima obično prikazuju podebljano, što je
učinjeno i u dosadašnjim primjerima, i što će biti ubuduće primjenjivano u svim primjerima koji slijede
(mnogi programerski editori za jezik C++ automatski podebljavaju svaku uočenu rezerviranu riječ).
Dakle, nije moguće imati promjenljivu koja se zove npr. “friend”, s obzirom da je to rezervirana riječ.
Postoji mogućnost da neki kompajleri koriste još neke rezervirane riječi, mada se to smatra ozbiljnim
kršenjem standarda od strane kompajlera. Obično se takvim “nestandardnim” rezerviranim riječima daju
neobična imena (npr. imena koja počinju znakom “_”) da se smanji mogućnost konflikta sa programima
koji bi mogli slučajno nesvjesno upotrijebiti takvu riječ kao identifikator. Tako, na primjer, Borland C++
Builder uvodi rezervirane riječi poput “__property”, “__closure”, itd. Jedan od najsigurnijih načina
da izbjegnete konflikte sa rezerviranim riječima je da koristite identifikatore bazirane na riječima iz
bosanskog jezika, s obzirom da su sve rezervirane riječi izvedene iz engleskog jezika (tako da možete biti
sigurni da “baklava” nije ključna riječ).
Upotrebu promjenljivih ćemo ilustrirati na primjeru programa koji će prosto ponoviti na ekranu broj
koji unesemo sa tastature:
#include <iostream>
using namespace std;
int main() {
int broj;
cin >> broj;
cout << broj;
return 0;
}
Ovdje trebamo posebno obratiti pažnju na naredbu koja glasi
cin >> broj;
“cin“ (skraćenica od engl. console in) predstavlja objekat tzv. ulaznog toka podataka (engl. input
stream), koji je povezan sa standardnim uređajem za unos. Standardni uređaj za unos je tipično tastatura,
mada ne mora biti (C++ uopće ne podrazumijeva da računar na kojem se program izvršava mora
posjedovati tastaturu, jer postoje i drugi načini za unos podataka). Znak “>>” predstavlja operator
izdvajanja (engl. extraction) iz ulaznog toka, koji pojednostavljeno možemo čitati kao “šalji u”. Njegov
smisao je suprotan u odnosu na smisao operatora umetanja “<<” koji se koristi uz objekat izlaznog toka
“cout”. Razmotrimo preciznije šta se zapravo dešava. Uz pretpostavku da je standardni ulazni uređaj
zaista tastatura, po nailasku na prethodnu naredbu koja zahtijeva izdvajanje promjenljive “broj“ iz
ulaznog toka “cin“ program privremeno prekida rad i omogućava nam da unesemo neki niz znakova sa
tastature, sve dok ne pritisnemo tipku ENTER. Uneseni niz znakova se pri tome čuva negdje u memoriji.
Operator “>>” iz unesenog niza znakova izdvaja sve znake do prvog razmaka (ili do kraja unesenog niza),
nakon čega izdvojene znakove interpretira kao cijeli broj koji smješta u promjenljivu “broj“ čije ime se
nalazi desno od operatora “>>” (interpretacija niza znakova kao cijelog broja uvjetovana je činjenicom da
je “broj“ promjenljiva cjelobrojnog tipa). Dakle, prethodna naredba može se interpretirati na sljedeći
način:
Pošalji unos sa tastature interpretiran kao cijeli broj u promjenljivu nazvanu "broj".
Kada pokrenemo ovaj program, ne možemo odmah znati šta će se prikazati na ekranu, jer će ispis
zavisiti od toga šta unesemo sa tastature. Zbog toga ćemo, u ovom i sličnim primjerima, pretpostavljene
vrijednosti unosa sa tastature prikazivati sivim nakošenim slovima. Tako, možemo prikazati sljedeću sliku:
10(ENTER)
10
Dakle, program je prihvatio unos sa tastature (u gornjem primjeru “10”) i prosto ga ponovio.
Primijetimo veliku razliku između na prvi pogled sličnih naredbi
cout << "broj";
i
cout << broj;
Prva naredba ispisuje bukvalno tekst "broj" na ekran. Druga naredba ispisuje sadržaj (tj. vrijednost)
promjenljive koja se zove “broj”. Pored toga, bitno je naglasiti da se sa desne strane operatora izdvajanja
“>>” smije nalaziti samo ime promjenljive (koja mora biti prethodno deklarirana) i ništa drugo. Tako je, na
primjer, sljedeća naredba potpuno besmislena:
cin >> "broj";
Strogo rečeno, kao desni operand operatora izdvajanja “>>” pored imena promjenljivih mogu se nalaziti i
svi ostali objekti koji spadaju u kategoriju tzv. l-vrijednosti (engl. l-values), o kojima ćemo govoriti u
sljedećem poglavlju. Međutim, za sada su jedine l-vrijednosti koje smo upoznali upravo imena
promjenljivih, tako da nećemo mnogo pogriješiti ako kažemo da desni operand operatora “>>” mora biti
ime promjenljive.
Interesantno je primijetiti da “cout“ i “cin“ nisu rezervirane riječi. U načelu, ukoliko ne koristimo
biblioteku “iostream“ nigdje u programu (što nije mnogo vjerovatno), sasvim je legalno koristiti riječi
“cout“ odnosno “cin“ kao imena promjenljivih (kasnije ćemo vidjeti da “cout“ i “cin“ zapravo i jesu
promjenljive, samo vrlo specifičnog tipa). U slučaju da koristimo biblioteku “iostream”, “cout“ i “cin“
su već deklarirane unutar nje, tako da ne smijemo koristiti njihova imena kao identifikatore, s obzirom da
C++ ne dozvoljava da se isti identifikator deklarira više puta unutar istog programa za više različitih
namjena. Riječi poput “cin“ i “cout“ koje u jeziku C++ posjeduju unaprijed definirano značenje, ali čije
je značenje u principu moguće potpuno promijeniti i koristiti ih za nešto posve drugo, nazivaju se
predefinirane riječi.
Zavisno od kompajlera sa kojim radite, i u ovom primjeru će se vjerovatno desiti da će nakon
završetka programa konzolni prozor zatvoriti, tako da nećete biti u stanju da vidite šta je program ispisao
nakon unosa broja. Ubacivanje naredbe “cin.get();“ koja je korištena u prethodnom primjeru kao
“polurješenje” u ovom primjeru neće pomoći, jer se njeno korištenje zasniva na pretpostavci da se ulazni
tok neće koristiti (što ovdje očigledno nije tačno). Stoga nam je potrebno univerzalnije rješenje, koje će
odložiti završetak programa sve dok recimo korisnik ne pritisne bilo koju tipku. Standard jezika C++
uopće ne predviđa nikakav način da se ovo riješi (vjerovatno zbog toga što ne predviđa da računar na
kojem se program izvršava mora posjedovati tipke), tako da se moramo poslužiti nestandardnim
rješenjima. Mada su ovakva rješenja ovisna od upotrijebljenog kompajlera i operativnog sistema, većina
raspoloživih kompajlera dolazi sa nestandardnom bibliotekom “conio.h“ (od engl. console input/output)
koja sadrži skupinu nestandardnih funkcija za rad sa tastaturom (a ne bilo kojim ulaznim tokom) i
ekranom (a ne bilo kojim izlaznim tokom), dakle sa onim uređajima za koje C++ ne garantira da moraju
postojati. U ovoj biblioteci nalazi se i veoma korisna funkcija “getch()“ koja, između ostalog,
privremeno zaustavlja izvođenje programa sve dok korisnik ne pritisne bilo koju tipku, a to je upravo ono
što nam treba. Dakle, jedno nestandardno rješenje ovog problema može se demonstrirati kroz sljedeći
program:
#include <iostream>
#include <conio.h>
// Nestandardno!
using namespace std;
int main() {
int broj;
cin >> broj;
cout << broj;
getch();
return 0;
}
// Nestandardno!
Napomenimo da su zagrade iza “getch“ bitne, tako da naredba “getch;“ (bez zagrada) neće izazvati
željeni efekat, mada kompajler neće prikazati nikakvu grešku (kasnije ćemo vidjeti da par zagrada
predstavlja operaciju poziva funkcije, tako da u slučaju da izostavimo ove zagrade, funkcija “getch“ bi
bila samo referencirana odnosno prozvana ali ne i pozvana). U primjerima koji slijede nećemo koristiti
biblioteku “conio.h“ niti naredbu “getch();“ da ne bismo listing programa nepotrebno opterećivali
detaljima koji nisu bitni za razumijevanje samog programa, i koji su pri tome nestandardni. Međutim, ako
želite da sami isprobate neke od kasnijih programa, vjerovatno ćete trebati ubaciti opisane modifikacije da
bi efekat programa bio jednak očekivanom.
Već smo rekli da razmaci u programu u principu nisu bitni, osim unutar stringova i šiljastih zagrada.
Međutim, to ne znači da smijemo izostaviti one razmake koji razdvajaju jednu riječ od druge. Tako je
sljedeći program neispravan:
#include <iostream>
using namespacestd;
// Greška: riječ "namespacestd" nema smisla
intmain() {
intbroj;
cin>>broj;
cout<<broj;
}
//
//
//
//
Greška: riječ "intmain" nema smisla
Greška: riječ "intbroj" nema smisla
Nije greška: ">>" razdvaja "cin" i "broj"
Nije greška: "<<" razdvaja "cout" i "broj"
Do sada razmotreni primjeri programa iz ovog poglavlja su “ružni” u smislu da korisnik programa
nakon njihovog pokretanja uopće ne zna šta se od njega očekuje. Svaki dobro napisani program trebao bi
da bude takav da korisnik programa u svakom trenutku zna šta se od njega očekuje, i šta predstavlja ispis
koji se eventualno javlja kao rezultat rada programa (programer koji je pisao program to sigurno zna, ali
programer i korisnik programa često nisu ista osoba). Drugim riječima, program bi trebao biti “ljubazan
prema korisniku” (engl. user friendly). Stoga se programi mogu učiniti “ljepšim” ako svaku naredbu ulaza
propratimo odgovarajućom naredbom izlaza koja će na ekranu ispisati upute šta se od nas očekuje da
unesemo. Sljedeći primjer ilustrira takav “ljubazniji” program:
#include <iostream>
using namespace std;
int main() {
int broj;
cout << "Unesi neki broj: "
cin >> broj;
cout << "Unijeli ste broj " << broj << endl;
return 0;
}
Jedan mogući scenario izvršavanja ovog programa je sljedeći:
Unesi neki broj: 7(ENTER)
Unijeli ste broj 7
Naravno, ovakav program je još uvijek posve beskoristan, ali barem posjeduje izvjesnu dozu
komunikacije sa korisnikom programa.
Kao što je već rečeno, operator “>>” izdvaja znakove iz ulaznog toka samo do prvog razmaka, što
ilustrira sljedeći primjer izvršavanja “neljubazne” verzije ovog programa:
10 20 30(ENTER)
10
Također, ukoliko se prilikom izdvajanja brojčanih podataka iz ulaznog toka naiđe na znak koji nije
sastavni dio broja (npr. na slovo), izdvajanje prestaje na tom znaku, kao u sljedećem scenariju:
10ab20(ENTER)
10
U oba primjera, samo broj “10” je izdvojen iz ulaznog toka. Međutim, preostali unijeti podaci (niz
znakova “20 30” odnosno “ab20”) i dalje su pohranjeni u memoriji i predstavljaju dio ulaznog toka.
Stoga će eventualna sljedeća upotreba operatora izdvajanja nastaviti izdvajanje iz niza znakova
zapamćenog u memoriji (kažemo da se nastavlja izdvajanje iz ulaznog toka). Tek kada se ulazni tok
isprazni, odnosno kada se istroše svi znakovi pohranjeni u memoriji biće zatražen novi unos sa ulaznog
uređaja. Neka, na primjer, imamo sljedeći program:
#include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a;
cin >> b;
cin >> c;
cout << a << endl << b << endl << c << endl;
return 0;
}
Primijetimo prvo da smo u ovom programu deklarirali tri cjelobrojne promjenljive a, b i c odjednom
pomoću deklaracije
int a, b, c;
Potpuno isti efekat postigli bismo sa tri odvojene deklaracije:
int a;
int b;
int c;
Prikažimo dva moguća “scenarija” pri izvršavanju ovog programa, koji ilustriraju način na koji djeluje
operator izdvajanja nad ulaznim tokom:
10 20 30(ENTER)
10
20
30
10 20(ENTER)
30(ENTER)
10
20
30
Operator “>>” se također može nadovezivati odnosno ulančavati poput operatora “<<”, tako da smo
isti program mogli napisati i kraće, na sljedeći način:
#include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << a << endl << b << endl << c << endl;
return 0;
}
Međutim, ovdje treba obratiti pažnju na jednu veoma čestu početničku grešku. Ukoliko umjesto naredbe
cin >> a >> b >> c;
slučajno napišemo naredbu poput
cin >> a, b, c;
kompajler neće prijaviti nikakvu grešku, s obzirom da je gornja konstrukcija sintaksno ispravna u jeziku
C++. Međutim, ova konstrukcija ne radi ono što bi korisnik mogao očekivati. Posebno, ona će dovesti do
izdvajanja samo promjenljive “a” iz ulaznog toka, dok će promjenljive “b” i “c” biti prosto ignorirane.
Zašto je tako, shvatićemo kasnije kada upoznamo značenje tzv. zarez-operatora (engl. comma operator).
U ovom trenutku je samo potrebno zapamtiti da ova konstrukcija ne vrši izdvajanje promjenljivih “a”, “b”
i “c” iz ulaznog toka. Ovakvih naizgled ispravnih konstrukcija koje ne rade ono što bi na prvi pogled
trebalo da rade treba se naročito čuvati, jer nas na njih kompajler ne može upozoriti (one su u načelu
sintaksno ispravne). U žargonu se takve konstrukcije obično nazivaju zamke (engl. pitfalls).
Ako uneseni niz znakova nije sadržavao niti jednu cifru, a očekivana je cifra (npr. zbog toga što
zahtijevamo unos cjelobrojne promjenljive), ulazni tok će dospjeti u tzv. neispravno stanje, i svaki sljedeći
pokušaj izdvajanja iz ulaznog toka biće ignoriran, sve dok tok ne vratimo ponovo u ispravno stanje
pomoću naredbe “cin.clear()”. O ovome ćemo detaljno govoriti kasnije, kada naučimo kako možemo
utvrditi da li je ulazni tok u neispravnom stanju, i na taj način preduzeti određenu akciju (npr. obavijestiti
korisnika da je unio pogrešne podatke).
Veoma je važno napomenuti da deklaracija neke promjenljive samo obavješatava kompajler da
imenovana promjenljiva postoji, ali ne i kolika joj je vrijednost. Na primjer, deklaracijom “int a;”
kompajler će biti obaviješten o postojanju promjenljive “a”, čime će zauzeti mjesto u memoriji gdje će se
čuvati njena vrijednost. Međutim, njena početna vrijednost će biti posve slučajna, preciznije njena
početna vrijednost će zavisiti od onoga što se u tom trenutku od ranije nalazilo u memoriji na
dodijeljenom mjestu. Ta vrijednost je često nula, ali ne uvijek. Stoga će sljedeći program, kada ga
pokrenemo, vjerovatno ispisati neku potpuno nepredvidljivu i besmislenu vrijednost:
#include <iostream>
using namespace std;
int main() {
int a;
cout << a << endl;
return 0;
}
Navedeni program predstavlja tipični primjer programa koji je sintaksno ispravan, tj. napisan je
potpuno u skladu sa “pravopisnim” i “gramatičkim” pravilima jezika C++, ali sadrži suštinsku grešku
logičke odnosno semantičke prirode. Ovakvih grešaka se treba dobro čuvati, jer nas kompajler može
upozoriti samo na sintaksne greške (poneki kompajleri mogu prepoznati ovakve situacije i eventualno
uputiti upozorenje, ali ne i grešku). Dakle, prilikom prevođenja prethodnog programa, kompajler neće
javiti postojanje ikakve greške.
Svaka promjenljiva koja je deklarirana imaće besmislenu vrijednost sve dok joj se eksplicitno ne
dodijeli neka konkretna vrijednost. Jedan način dodjele vrijednosti smo već upoznali: izdvajanje
vrijednosti iz ulaznog toka. U tom slučaju, promjenljiva dobija vrijednost na osnovu podataka u ulaznom
toku (tipično podataka unijetih sa tastature). U narednom poglavlju ćemo upoznati i drugi način dodjele
vrijednosti promjenljivim, korištenjem tzv. operatora dodjele “=”. Napomenimo da je korištenje
promjenljivih kojima nije dodijeljena vrijednost jedna od najčešćih programerskih grešaka (tipično u
većim programima), koja obično dovodi do programa koji, zavisno od slučaja, nekad rade ispravno, a
nekada ne rade (jer rezultat njihovog rada praktično zavisi od slučajne početne vrijednosti promjenljive).
Postoji mogućnost da se promjenljivoj prilikom deklaracije zada i njena početna vrijednost, tako da će
njen sadržaj odmah biti dobro definiran. To se postiže tako što se iza imena promjenljive njena početna
vrijednost navede unutar zagrada. Tako će se sljedeći program ponašati posve predvidljivo (ispisivaće
uvijek vrijednost “5”), s obzirom da je definirano da je početna vrijednost promjenljive “a” jednaka “5”.
Kažemo da je promjenljiva “a” inicijalizirana na vrijednost “5”.
#include <iostream>
using namespace std;
int main() {
int a(5);
cout << a << endl;
return 0;
}
Napomenimo da je mogućnost zadavanja početne vrijednosti promjenljive u zagradama uvedena u
novijim standardima jezika C++, tako da neki vrlo stari prevodioci za C++ (koje ionako više ne bi trebalo
koristiti) ne podržavaju ovu sintaksu. U takvim slučajevima, inicijalizacija promjenljivih se može izvršiti
na nešto drugačiji način (naslijeđen iz jezika C), koji će biti opisan u sljedećem poglavlju.
Za promjenljive čija se početna vrijednost ne navodi prilikom deklaracije kažemo da su
neinicijalizirane. Zbog problema koji mogu nastati zbog upotrebe neinicijaliziranih promjenljivih,
preporučuje se da se sve promjenljive koje će se koristiti u programu obavezno inicijaliziraju, osim u
slučaju kada neposredno iza same deklaracije slijedi izdvajanje te promjenljive iz ulaznog toka, nakon
čega će ona definitivno dobiti sasvim određenu vrijednost.
Author
Document
Category
Uncategorized
Views
0
File Size
1 468 KB
Tags
1/--pages
Report inappropriate content