Objašnjenja početniku

[holodoc]

Ima li uopšte nekoga da prati ovu temu ili ja to onako čisto bezveze punim sadržajem Ima li bar nekoga da čita ovo moje čudo?

[bobi]

holodoc kaže:

Ima li uopšte nekoga da prati ovu temu ili ja to onako čisto bezveze punim sadržajem Ima li bar nekoga da čita ovo moje čudo?

Ne.

[3dM@niak]

a citam i uzivam puni dalje

[Nemesis]

Pratimo, pratimo.

Nego, ne znam koliko je pregledno praviti tutorijale preko foruma. Da sam na mestu nekog pocetnika ne znam koliko bi mi ovaj pristup odgovarao ali respect za ono sto radis.

Ja sam davno radio tutorijale (za pascal dok se jos ucio na fakultetu) pa ako ti treba pomoc (ne u smislu da si nesposoban vec za fizikaliju) mozes da me cimnes.

[holodoc]

Pa meni je u suštini to možda nekih sat vremena za tastaturom a onima koji ovde počinju može da bude par dana manje lupanja glave. Ovo nije ni namenjeno za neko detaljisanje. To ne bi tek moglo da se izvede

Osnovna ideja mi je da svi koji već koriste neku knjigu iz C++-a imaju mesto gde će moći da pogledaju par "insider" trikova koji mogu da im olakšaju učenje. A pošto sam ovde najčešće korišćenu knjigu "Teach yourself C++ in 21 days" (bar sudeći po privatnim porukama koje dobijam) "prežvakao" bar jedno 20 puta, tačno znam na kojim mestima bi bilo dobro pojasniti neke stvari.

@Nemesis
Što se tiče pomoći imaću te u vidu ako nešto zatreba. Naravno pod uslovom da si sa Pascal-a prešao na C++ ili bar C.

[Nemesis]

holodoc kaže:

...Naravno pod uslovom da si sa Pascal-a prešao na C++ ili bar C.

Hmmm. Pa znam po neku naredbu.

[Andross]

Aaa pratimo mi.Samo ti pisi. Sto se tice greske u povratnom tipu to se desilo jer sam bio taj dan smoren zbog OpenGL-a pa nisam obracao paznju Inace dobro sto si primetio

[holodoc]

Dobro. Ako je tako ovo ima bar i malo smisla. Ako mene ne mrzi da pišem što vas da mrzi da čitate Okej, dosta small-talka!

Pre nego li započnem celu priču naravno ide kod.

/*********************************************
Naziv: Tablica mnozenja

File: TablicaMnozenja.cpp

Author: holodoc

Date: 18.08.2006.

Opis: Demonstracija upotrebe ugnjezdenih for-next petlji na primeru ispisa tablice
mnozenja.
************************************************/
#include <iostream> // ovo vec i vrapci znaju cemu sluzi
using namespace std; // a tek ovo :)

int main(){
    int broj_redova, broj_kolona, red, kolona; // deklarisanje promenjljivih 
    broj_redova = broj_kolona = 10; // postavljanje pocetnih vrednosti
    
    for(red = 1; red < broj_redova; red++){
        cout << "------------------------------------------------------------------" << endl;
        for (kolona = 1; kolona < broj_kolona; kolona++){
            cout << kolona * red << "\t";      
        }
        cout << "\n";
    }  
    fflush(stdin); // ovo smo naucili sta znaci prosli put
    cout << "ENTER za izlaz iz programa...." << endl;
    cin.get();
    return EXIT_SUCCESS; // vracanje povratne vrednosti o uspesno izvrsenom programu
}

[holodoc]

Sledi priča o nečemu što se stvarno često koristi u programiranju a naziva se “ugnježdavanje” petlji. Znam da zvuči kao neki pojam koji bi možda više odgovarao Frojdu ili nekom iz njegove branše ali nije tako. Ugnježdavanje podrazumeva postavljanje bloka kontrole toka istog tipa jedan u okviru drugog. Znam da ovo zvuči malo konfuzno ali bi objašnjenje otprilike glasilo da ugnježdavanje podrazumeva da recimo neki “for” blok u sebi sadrži “for” blok. Primera radi u C-u i C++-u bi to bio ovakav raspored za recimo par “for” petlji mada se ugnježdavanje često radi i sa “if” i ostalim blokovima za kontrolu toka.

for(..;..;..){
     for(...;....;...){
          ......
     }
}

Neko bi se sada logično zapitao čemu sve ovo. E pa postoji razlog i to debeo a on leži u činjenici da se „ugnježdavanje“ veoma često koristi u game-devu prilikom takozvanog matričnog računa. O tome šta su matrice (u najosnovnijem mogućem obliku) i matrične transformacije najverovatnije u sledećoj „lekciji“ Za sada treba samo zapamtiti da se „ugnježdavanje“ koristi izuzetno često kod matrica gde svaka dodatna „ugnježdena“ petlja predstavlja jednu dodatnu dimenziju. Ako ste mislili da je po toj logici onda za 3D engine potrebno napraviti trostruko „ugnježdenu“ petlju onda ste se prevarili jer je za pravu 3D transformaciju potrebno četiri dimenzije Izgleda smešno ali tako je. O tome kada na to dođe red. Nadam se

Da se vratim na ugnježdene petlje. Krenimo redom.

Prvih par redova stvarno ne bi trebalo više uopšte da objašnjavam tako da ću ovaj put da ih preskočim.

Sledeći kod služi za definisanje par potrebnih promenjljivih.

int broj_redova, broj_kolona, red, kolona; // deklarisanje promenjljivih 
broj_redova = broj_kolona = 10; // postavljanje pocetnih vrednosti

Ovde namerno nisam iskoristio „#define“ pretprocesorsku direktivu za definisanje vrednosti broja redova i kolona iako bi to u ovakvom programu bilo malo logičnije. To nisam uradio iz jednog banalnog razloga a to je da bih demostrirao još jednu „specijalku“ C-a i C++-a. To je tzv. višestruka dodela vrednosti u okviru jednog izraza.

[holodoc]

Naime sigurno vam je zapao za oko sledeći red.

broj_redova = broj_kolona = 10;

O čemu se ovde uopšte radi i kako to uopšte funkcioniše. C++ ima tu osobinu da se dodeljivanje vrednosti promenjljivama u okviru izraza dodeljivanja (ovo je u stvari naziv za jednako operaciju „=“) vrši sa desne na levu stranu. Znači, kada kompajler krene sa interpretacijom ovog reda gore on ga posmatra ovako: „aha, 10 je jednako promenjljivoj ’broj_kolona’ a sve to je jednako promenljivoj ’broj_redova’“. To opet treba da znači da bi ovaj izraz bio identičan kao izraz: broj_redova = (broj_kolona = 10). Ko poznaje bar malo matematiku zna šta znače ove zagrade a ko ne saznaće upravo sada. Zagrada treba da označi da se „ograđeni“ deo treba posmatrati kao celina prilikom izračunavanja. U ovom konkretnom slučaju nije teško prozreti šta je namera izraza ali se u slučajevima kada su izrazi kompleksniji zagrade obavezno treba koristiti bez obzira što vam neki mladi matematičar Pitagora u blizini možda pričao kako ih nije potrebno koristiti u datom slučaju. Osnovni razlog za to je što nemaju sve operacije isti prioritet pa je potrebno voditi računa o tome koja operacija je prioritetnija u slučaju da se zagrade ne koriste. Ovo posebno važi za one koji i dalje misle da je „144 / 12 + 5 * 3 = 27“

Zato ja kažem, koristite zagrade uvek jer će vam olakšati život.

Sledećih par redova odrađuju lavovski deo posla u ovom primeru.

for(red = 1; red < broj_redova; red++){
        cout << "------------------------------------------------------------------" << endl;
        for (kolona = 1; kolona < broj_kolona; kolona++){
            cout << kolona * red << "\t";      
        }
        cout << "\n";
    }

Naime, u ovom konkretnom primeru promenjljive „broj_redova“ i „broj_kolona“ sadrže vrednosti broja redova odnosno kolona do kojih će se vršiti ispis tablice množenja. U ovom konkretnom primeru treba obratiti pažnju da se proizvod množenja dva činioca dobija u preseku odgovarajuće kolone i reda, osim broja jedan koji je ostavljen zasebno kao broj koji množi samog sebe. Promenjljive „red“ i „kolona“ sadrže trenutnu vrednost reda i kolone u tablici množenja odnosno pozicije koja se trenutno izračunava i ispisuje.

[holodoc]

Kako ovo sve uopšte radi? Prva „for“ petlja se koristi da bi vršila brojanje od 1 sve do trenutka kada promenjljiva „red“ dostigne vrednost „10“. Znači u suštini ovaj deo bi se izvršio tačno 9 puta jer „deseti“ već ne bi ispunjavao uslov „<10“. E sada caka je u tome šta se dešava kada u okviru te prve „for“ petlje program naiđe na još jednu „for“ petlju. U tom slučaju ta druga petlja će se „vrteti“ sve dok ne ispuni svoj uslov odnosno broj kolona ne bude jednak broju „10“. U tom slučaju se druga „for“ petlja završava i kreće odbrojavanje reda prve for petlje i tako u krug sve dok se ne izbroji ukupno „red*kolona“ vrednosti. Znači, sadržaj promenljivih „red“ i „kolona“ u toku izvršavanja je seldeći:

1,1
1,2
1,3
...
1,9
2,1
2,2
...
2,9
3,1
....
9,8
9,9.

A zašto bi nam ovako nešto uopšte trebalo? Pa iz jednostavnog razloga što smo već rekli u postavci zadatka da se rezultat množenja za određen red i kolonu dobija množenjem trenutnog reda i trenutne kolone. Pa to znači da je proizvod prvog reda i devete kolone 9 odnosno proizvod trećeg reda i sedme kolone 27. Upravo deo

cout << kolona * red << "\t";

je zadužen da ispiše vrednost množenja trenutnog reda i kolone.

Sve ostalo u zadatku je samo šminka koja je postavljena na pravo mesto da bi se dočarali neki elementi.

Recimo deo koda

cout << "------------------------------------------------------------------" << endl;

je zadužen da kada se završi ispisivanje u okviru reda uradi ispis po jedne ovakve linije koja će odvajati redove.

Ostatak od ovog ostataka je opisan juče. Konkretno mislim na deo sa „fflush-om“.

Nadam se da nisam bio preterano konfuzan u vezi ovih petlji ali treba shvatiti da je ovo jedan veoma važan deo u C++-u. Ako ima pitanja slobodno ih postavite.

Toliko za sada.

Poz.

[Andross]

Eh taman ja hteo da blebecem o petljama Sad posto si pokrio jednu petlju pa cu ja da o svima kazem ponesto.Znaci imamo tri petlje(imamo i cetvrtu al' se ona skoro nikad ne koristi):
1:
while(uslov)
{
iskazi;
}

2:
do
{
iskazi;
}while(uslovi);

3:
for(broj; inkrement broja; uslov)
{
iskazi;
}

Sada prva petlja while radi nesto sve dok je uslov ispunjen.Na primer:

int i = 0;
while(i < 10)
{
    std::cout << "Zdravo!\n";
    i++;
}

Znaci ova petlja ce ispisivati zdravo sve dok je i manje od deset.Ono i++ moramo dodati jer ce u suprotnom petlja biti vecna tj. i ce uvek biti 0.Eh uvek postoji stari dobri while(true) (u duhu C++-a) tj. while(1) (u duhu C-a).To su beskonacne petlje.Njih mozemo prekinuti samo sa break.(i verovatno sa jos necim sto ja nisam izvalio ).
Ajmo sad na drugi tip.do...while je prakticno isto sr***e ko i while samo sto ce se uvek ali uvek jednom izvrsiti.Znaci ako je i 10 a uslov je i < 10 petlja se opet jednom izvrsava.
Treci tip je pomenuo holodoc.To je for petlja.Posto je holodoc vec objasnjavao o toj petlji necu da vas smaram sa njom.Samo da pomenem da postoji for(;; ) sto je isto ko i while(true).Vi mozete bilo koji deo petlje for izostaviti(i napisati ; )!
Cetvrti i najvise ukleti je goto.O njemu necu da pricam jer je toliko uklet i uopste nije dobar da nije vredan paznje. Ta petlja je prokletsto za programere(moje licno misljenje), kao i makroi(bolje kosristiti sablone tj. template i opet moje licno misljenje).Eto to je sve od mene.Ako nesto nije jasno samo me cimnite.

/edit od brzine nisam pravilno formulisao deo o do...while Znaci gde kaze: "uvek ali uvek jednom izvrsiti" treba bar jednom izvrsiti.Znaci do...while ce se bar jednom izvrsiti.

[voodoo_]

ANDROSS kaže:

Sada prva petlja while radi nesto sve dok je uslov ispunjen.Na primer:

int i = 0;
while(i < 10)
{
    std::cout << "Zdravo!\n";
    i++;
}

A ovo se kraće može napisati i kao

int i=0;
while ((i++) < 10) std::cout << "Zdravo!\n";

blagodareći C-ovskoj mogućnosti da izraz ima i bočne efekte

[Andross]

E da da malo pojasnim inkrement.Inkrement uvecava datu varijablu za jedan.Oznaka je varijabla++.Sada imamo da tipa inkrementa.Prefiks-inkrement i postfiks-inkrement.
Prvi je sa prefiksom znaci ++varijabla.Ovo je veoma vazno!Pre inkrement prvo uveca vrednost varijable pa je onda dodeljuje.Primer:

int var1 = 0;
int var2 = 0;
var2 = ++var1;

Sada var1 i var2 ce posle inkrementa imati vrednost 1(var2 smo dodelili inkrementiranu var1).Nadam se da je to bilo jasno.
Drugi tip je sa postfiksom.Znaci vec pomenuti var1++.Ovo je drugacije od prvog.Postfiks inkrement prvo vraca vrednost varijable pa je onda inkrementira!Sta to znaci.Na primer:

int var1 = 0;
int var2 = 0;
var2 = ++var1;
var2 = var1++;

Znaci prvo su varijable postavljene na 0.Posle prvog(prefiks)inkrementa imaju vrednost 1.Posle drugog(postfiks) var1 ima vrednost 2 a var2 ima vrednost 1.To je zato sto(kao sto sam vec rekao) postfiks inkrement prvo vraca vrednost pa je tek onda inkrementira.Ako nekome nesto nije jasno neka me cimne.
Pozz.

[voodoo_]

Zapravo, to je ono što se zove "bočni efekat", s tim što se u slučaju A++, prvo iskoristi vrednost promenljive A u izrazu u kome se nalazi pa se tek onda poveća, dok se kod ++A, prvo poveća pa onda iskoristi. Znači u onom gore slučaju, ((i++) < 10) prvo pita da li je trenutna vrednost "i" manja od 10 pa je onda poveća.

[holodoc]

Ovoga puta sledi nešto što je malo opipljivije i bliže svetu igara. U pitanju je simulator Loto-a koji vam omogućava da simulirate izvlačenje loto kuglica pri čemu imate kontrolu nad brojem kuglica koje sačinjavaju jednu kombinaciju. Program takođe prikazuje neke od osnovnih koncepata programiranja u okviru Windows okruženja kao što je „Mađarska notacija“. Takođe, demonstriran je na praktičnom primeru jedan od najčešće korišćenih algoritama za sortiranje jednodimenzionih nizova koji se bazira na tzv. „Nassi-Schneidermann” (Nasi-Šnajderman) algoritmu i njihovim dijagramima.

Pošto je kod malo podugačak možete ga skinuti kompletno u obliku .zip arhive koja se nalazi prikačena za ovaj post koja pored glavnom fajla “Loto.cpp” sadrži i DevC++-ov workspace za isti.

Pre samog početka jedna mala korisna napomena. Naučite se da koristite pravilne i precizne nazive onoga što koristite. Znači, kako napredujete sa učenjem C++-a pokušajte da se potrudite da ne mešate izraze kao što su „deklaracija“ i „definicija“, „pretprocesorksa direktiva“ i „konstanta“ ili još gore „promenjljiva“ itd. Veoma je bitno da naučite kako se šta zove u bilo kom programskom jeziku a kamoli C++-u koji obiluje terminima. Sada to još uvek ne mora da predstavlja neki preterani problem ali kada u celu priču uđu termini kao što su „klase“, „konstruktori“, „destruktori“ i slični može da dođe do velike zbrke. Takođe ne bi bilo loše ovde pomenuti da će vam ovo bitno pomoći u slučajevima kada budete radili sa ljudima u timu jer u takvom slučaju sigurno neće biti vremena da vam kolege objašnjavaju razliku između „definicije“ i „deklaracije“

Pa da krenemo.

#include <iostream> // ovo nam je vec poznato
#include <ctime> // ovo zaglavlje treba za postavljanje semena srand funckije
#define UKUPNO_BROJEVA 39 // ukupan broj kuglica (brojeva u igri)

Ovaj deo koda bi trebao da bude već “čitljiv” i početnicima ili bar onima koji su pratili ovaj kurs. Jedino bih trebao da naglasim da je od standardnih zaglavlja uključeno i zaglavlje “ctime” koje sadrži funkciju “time()” a koja će se u programu koristiti za postavljanje tzv. “semena” generatora slučajnih brojeva.
Pretprocesorska direktiva “#define” definiše “konstantu” “UKUPNO_BROJEVA” koja sadrži ukupan broj kuglica iz kojih se izvlači kombinacija. Pošto mislim da naš “Loto” koristi kombinaciju “7 od 39” ovde je u pitanju taj sistem. Možda grešim jer odavno nisam igrao loto ali u svakom slučaju oba parametra možete menjati u kodu tako da ne bi trebalo da bude problema.

[holodoc]

Pre nego što pređem na preostali deo koda sledi upoznavanje sa jednim od najvažnijih pravila prilikom programiranja u C++-u u Windows-u. Naime, u jednoj firmi koja zapošljava hiljade radnika, kao što je Microsoft veoma brzo se javio problem objedinjavanja projekata u jednu celinu na kojima radi ogroman broj ljudi. Shvativši da nešto mora da se uradi povodom tog problema čelnici Microsoft-a daju kao zadatak jednom od svojih radnika Charles-u Simonyi-u (Čarls Simonji) da napravi skup pravila i konvencija o obeležavanju svih važnijih delova koda i načinu njihovog pisanja. Pošto je Simonji bio mađar otuda i naziv “mađarska notacija”. Napominjem na ovom mestu da ne treba mešati mađarsku i poljsku notaciju pošto prva predstavlja konvenciju o pisanju koda u Windows-u dok druga služi za predstavljanje matematičkih operacija.

Mađarska notacija inače definiše načine na koje se obeležavaju promenjljive, funkcije, tipovi, konstante, klase i parametri. Neka od najvažnijih pravila je da se tip promenjljive obeležava malim slovom (ili grupom slova) i to recimo za cele brojeve se koristi “n”,”i”, za stringove “s” ili “str”, za bool promenjljive “b” itd. Znači, u sledećem kodu

int iKombinacija[7]; // niz sa celim brojevima koji ce da sadrzi kombinaciju izvlacenja
int iBrojKuglica = 7; // pocetni broj kuglica u igri

promenjljiva “iKombinacija” predstavlja integer odnosno preciznije niz od 7 elemenata koji sadrži integere. Što se tiče funkcija važi jedno veoma važno pravilo a to je da se prilikom imenovanja ne smeju koristiti “donje” crte “_” i da ne smeju da postoje space-ovi između reči. Svaka reč koja sačinjava naziv funkcije mora da počinje velikim slovom. Primera radi sledeći naziv je po mađarskoj notaciji

void SortiranjeNiza();

dok sledeći nije

void sortiranje_niza();

Kada smo već kod ovih promenjljivih važno je napomenuti još jednu stavku na kojoj smo bitno zasnivali kod u ovom programu. U pitanju su tzv. globalne promenljive. Naime, sve promenjljive koje se deklarišu u okviru neke funkcije se nazivaju privatnim tj. postoje samo u okviru date funkcije. Primera radi, iako se u skoro svakoj funkciji koda pojavljuje promenjljiva “iBrojac” one međusobno nemaju apsolutno nikakve veze jer svaka postoji u okviru svoje funkcije. Ovo je jedna veoma bitna stavka. Pa opet, ovde smo iskoristili tzv. globalne promenljive koje su vidljive celom programu tj. svim funkcijama. To su promenljive koje su pomenute gore. Znači, da bi promenljiva bila vidljiva svim funkcijama u programu mora se definisati van funkcija (čak i main-a).

[holodoc]

Iako je u ovom programu korišćenje globalnih promenjljivih dobro došlo njih ipak treba zaobilaziti kad god je to moguće jer se u većim projektima veoma često može desiti da slučajno dođe do zamene neke promenjljive koja je definisana kao globalna i to čak ako se njena promena vrši u nekoj funkciji u kojoj je deklarisana lokalana promenljiva. Zato je u običnom C-u ponekada malo teže zaobići korišćenje globalnih promenjljivih dok je u C++-u potreba za ovako nečim potpuno eliminisana uvođenjem par klasa. Ali to je već malo naprednija priča.

Sledeći kod definiše tzv. prototipove.

// deklarianje prototipova funkcija
void PromenaNrKuglica(); 
void Izvlacenje();
void SortiranjeNiza();
void IspisKombinacije();

Na njima se neću dugo zadržavati ali ću samo napomenuti da su prototipovi više namenjeni pronalaženju grešaka u kodu nego bilo čemu drugom. Drugim rečima, može se reći da su prototipovi “deklaracije funkcija” koje imaju za cilj da ne dozvole kasnije greške prilikom prosleđivanja argumenata. Ono što je važno za prototipove je to da ako funkcija sadrži argumente u prototipu te funkcije nije neophodno navesti nazive argumenata već samo njihov tip. Primera radi kod tipa

Void PromenaNrKuglica (int, int);

je sasvim OK.

Sledi par funkcija koje će kasnije biti pozivane iz “main” funkcije. Naravno i kratak opis svake.

[holodoc]

void PromenaNrKuglica(){
    //sipisivanje uvodnog teksta
    cout << "\nTrenutni broj aktivnih kuglica je " << iBrojKuglica << ".\n";
    cout << "Unesite nov broj kuglica pri izvlacenju: ";
    cin >> iBrojKuglica; //unos novog broja kuglica
    cout << "Sva sledeca izvlacenja sadrzace " << iBrojKuglica << " kuglica!\n";
    cout << "\nENTER za povratak u glavni meni....\n\n";
    fflush(stdin); //brisanje buffer-a stdin-a
    cin.get(); //ajd neka neko cukne nesto na tastaturi
    
}

Služi za promenu broja kuglica koje se koriste prilikom izvlačenja. Pošto je promenjljiva globalna jedino što treba da uradimo je da upitamo korisnika koliko kuglica želi tokom izvlačenja i da se njegova unešena vrednost snimi u promenjljivu “iBrojKuglica”.

Sledeća funkcija služi za simulaciju "izvlačenja" brojeva.

void Izvlacenje(){
    int iBrojac, iTragac; // deklarisanje promenjljivih za brojanje u for petljama
    bool bNovBroj; //sluzi za indikaciju da li je izvuceni broj jedinstven u kombinaciji
    srand((unsigned)time(NULL)); // postavljanje semena generatora slucajnih brojeva
    
    for(iBrojac = 0; iBrojac < iBrojKuglica; iBrojac++){ //glavna petlja izvlacenja
        do{
            iKombinacija[iBrojac] = rand() % UKUPNO_BROJEVA + 1;
            bNovBroj = true; // resetovanje promenjljive unikatnosti :)
            for (iTragac = 0; iTragac < iBrojac; iTragac++){
                // provera da li je izvucen broj vec u kombinaciji
               if(iKombinacija[iBrojac] == iKombinacija[iTragac]){
                   bNovBroj = false; //ukoliko je izvuceni broj duplikat bNovBroj obija vrednost false
                }    
            }
        } while (!bNovBroj); //petlja se vrti sve dok izvuceni broj nije jedinstven
    }
}

Ovde postoji par interesantnih stvari. Prvo je korišćenje funkcije “srand()” koja služi za tzv. postavljanje “semena” (seed) generatora slučajnih brojeva. Drugim rečima ova funkcija ima za cilj da pripremi generator (šta je to u konkretnom slučaju nije važno) da generiše slučajne brojeve tako što će da definiše njegovu početnu vrednost. Najčešće korišćeno seme za “srand()” je trenutno vreme a implementacija tako nečega vidi se iz gornjeg koda.
Od ostalih stvari veoma je važno zapamtiti deo koda koji je u okviru “for” petlje (zajedno sa njom). Treba upamtiti da je ovo jedan od najpoznatijih algoritama za generisanje brojeva u slučaju da mora biti ispunjen uslov da ne sme da se pojave duplikati u kombinaciji. Treba ga zapamtiti. Čisto onako vežbe radi pokušajte da provalite kako funkcioniše. A da, izrazi tipa “!bNovBroj” su sasvim normalni u C++-u jer svaka vredbost izraza u zagradi kod while-a koja je različita od broja “0” ili ima vrednost “true” automatski se smatra kao ispunjen uslov. Primera radi petlja “while(1){};“ vrtela bi se beskonačno.

[holodoc]

Sledeća funkcija služi za sortiranje niza da bi preglednost „ispljunutih“ brojeva bila veća.

// Funkcija koja sortira izvucenu kombinaciju
void SortiranjeNiza(){
    int iNajmanjiIndeks; // pormenjljiva sadr\i vrednost trenutno najmanjeg indeksa
    for(int i = 0; i < (iBrojKuglica - 1); i++){ //pocetak petlje sortiranja
        int iNajmanjiIndeks = i; //dodela vrednosti brojacu i kao najmanjem indeksu
        for(int j = i + 1; j < iBrojKuglica; j++){ //uporedjivanje vrednosti sa njemu desnim
            if (iKombinacija[j] < iKombinacija[iNajmanjiIndeks]){
                iNajmanjiIndeks = j; //definisanje nove najmanje vrednosti ako je broj manji
            }
        }
        if (iNajmanjiIndeks > i)
        {
            // zamena mesta u nizu jednostavnim koriscenjem pomocne promenjljive
            int iTemp; //deklarisanje pomocne promenjljive
            iTemp = iKombinacija[i]; // [1] -> iTemp 
            iKombinacija[i] = iKombinacija[iNajmanjiIndeks]; //[1] -> [2]
            iKombinacija[iNajmanjiIndeks] = iTemp; 
        }
    }
}

Ovo je takođe jedan poznat algoritam i naziva se „Nassi-Schneidermann (Nasi-Šnajderman) algoritam sortiranja sa inkrementiranjem“. Osnovni princip funkcionisanja ovog algoritma je da se porede vrednosti dva susedna polja u nizu. Ukoliko je „desni“ veći vrši se rotacija odnosno zamena mesta ta dva člana i tako sve do kraja niza ukoliko je ispunjen uslov da je „levi“ član veći od „desnog“. U suštini ne treba biti mnogo glavu oko ovoga jer i u samom C++-u postoji funkcija „qsort()“ za sortiranje nizova ali nije na odmet pogledati kako bi se to radilo peške.

Sledeća funkcija jednostavno ispisuje datu kombinaciju.

void IspisKombinacije(){
    int iBrojac; //jednostavan brojac
    cout << "\nDobitna kombinacija glasi:\n\n";
    for(iBrojac = 0; iBrojac < iBrojKuglica; iBrojac++){
      cout << "[" << iKombinacija[iBrojac] << "]";  
    }
    cout << "\n\nCestitamo (ne)srecnim dobitnicima :)\n\n";
    cout << "ENTER za povratak u glavni meni....\n";
    fflush(stdin);
    cin.get(); 
}

Ništa specijalno kod ovoga.