Choose jour language!

---

|

PETLJE U PROGRAMSKOM JEZIKU C++

Petlje su jedan od osnovnih građevinskih elemenata svakog programskog jezika, uključujući C++. Njihova ključna uloga je da omoguće ponavljanje određenih akcija dok se zadati uslov ne ispuni, što ih čini neizostavnim alatom u rešavanju raznovrsnih problema u programiranju.
Zamislite da želite da ispišete sve brojeve od 1 do 100 na ekranu. Bez petlji, morali biste ručno napisati 100 linija koda. Međutim, uz pomoć petlje, ovaj zadatak se svodi na nekoliko linija koda koje automatizuju proces.
Petlje nisu korisne samo za jednostavne zadatke poput ponavljanja, već se koriste i u složenijim scenarijima, kao što su:

• Obrada velikih količina podataka.
• Pronalaženje rešenja iterativnim pristupom, kao što je sortiranje ili pretraživanje.
• Upravljanje unosom korisnika dok ne unesu ispravan podatak.

Korišćenjem petlji, programeri štede vreme, smanjuju broj grešaka u kodu i poboljšavaju efikasnost svojih aplikacija. Na ovoj stranici ćete naučiti kako da koristite različite tipove petlji u C++, uključujući for, while i do-while petlje, kroz jasna objašnjenja i praktične primere.

Često je  u programiranju potrebno jednu naredbu ili više naredbi ponoviti odrećen broj puta. Zamislimo sada kada bi morali da određene naredbe ispisujemo 100, 1000 ili 10000 puta. To bi bio težak, gotovo nemoguć posao. Posao bi bio olakšan kada bi ove naredbe, koje želimo da ponavljamo napisali samo jednom, a pomoću neke druge naredbe vršili ponavljanje. 

Te naredbe, kojima omogućavamo kontrolisano ponavljanje, nazivamo ciklusima. U C++ jeziku se za to koriste for, while i do-while naredba.
 
Npr. Zamislite da želimo da ispišemo neki znak 20 puta.
To možemo uraditi komandom cout koju treba ponoviti 20 puta, dakle:

cout << "*" << endl;
cout << "*" << endl;
cout << "*" << endl;
. . .

Umesto toga za ponavljanje ćemo koristiti naredbu for. Sintaksa bi izgledala nešto slično ovome:

    for (int i = 0; i < 20; i++) {
      

        cout<< "*" <<  endl; 

      
    }
  

Izrazi u maloj zagradi služe da obezbede odgovarajući broj ponavljanja, u ovom slučaju 20.

Prvi izraz služi da se uvede neka promenljiva kojoj se zada neka početna vrednost i čija će se vrednost menjati tokom ciklusa.
Drugi izraz je zapravo uslov petlje od koga zavisi da li se ide u sledeći ciklus ili ne. To je zapravo logički izraz čija je vrednost logički podatak tipa bool, dakle može imati vrednost true, ako je vrednost izraza tačna, ili false, ako je netačna. U slučaju da je vrednost true, izvršiće se naredni ciklus.
Npr. ako smo uveli promenljivu " i " i zadali joj početnu vrednost nula u prvom izrazu, a drugi izraz glasi i < 20, to znači da će se ispisivanje ponavljati sve dok taj izraz bude tačan. Ako se vrednost promenljive "i" ne bi menjala tokom ciklusa, to bi značilo da će taj uslov uvek biti zadovoljen, što znači da će biti beskonačno ciklusa(program se neprekidno izvršava).
Za promenu promenljive je zadužen treći izraz. Tu se definiše za koliko se menja promenljiva koja je uvedena u prvom izrazu. U našem primeru i++ znači promenu za 1 i to povećanje. 
Dakle ako je početno i = 0, korak povećanja 1, a uslov petlje i < 20, to znači da će ovaj uslov biti zadovoljen sve dok vrednost promenljive " i " ne dostigne vrednost 20. Dakle 20< 20 više nije tačno i ciklus se prekida.

Izraz tri je mogao da bude napisan i kao i=i+1. Ovo znači da se memoriji označenoj sa i dodeljuje vrednost koja je prethodno bila u toj memoriji uvećanoj za 1.

​U opštem slučaju sintaksa for naredbe bi bila

for u c++ jeziku

for(izraz_1; izraz_2; izraz_3)
{

NAREDBE

}

Ovde vidimo da su naredbe obuhvaćene vitičastim zagradama. U slučaju da je u pitanju samo jedna naredba zagrade mogu da se izostave.

Primer 1: Niz brojeva deljivih sa 3

Zadatak: Ispisati niz brojeva od -100 do 100 koji su deljivi sa 3

Za ispisivanje 1 broja upotrebićemo naredbu cout . Koristićemo for ciklus da bi ponovili naredbu. Promenljivu koju unutar for uvodimo da bi ostvarili potreban broj ciklusa, označićemo sa a i iskoristiti je da bi prikazali vrednosti brojeva u nizu.

for(int a=-100; a<100; a++)
{

cin << a << endl;

}

Ovo bi odštampalo sve brojeve između - 100 i +100. Da bi program štampao samo one brojeve koji su deljivi sa 3, uradićemo sledeće.

• ​Pomerićemo početnu vrednost broja a na prvi sledeći broj koji je deljiv sa 3, tj. na -99
• Korak promene promenljive a staviti na 3, jer svaki treći broj, počev od -99 je takođe deljiv sa 3, dakle a=a+3

Tako da rešenje zadatka sada izgleda:

for(int a=-99; a<100; а=а+3)
{

cout<<a<<" ";

}

Posle pokretanja, na ekranu će se ispisati:
-99,-96,-93, ....0,3,6,........99

for petlja se često koristi za obradu nizova podataka. Pročitajte više o nizovima na web lokaciji:
Nizovi u jeziku C i C++

Primer 2: Sabrati niz prirodnih brojeva od 1 do 10

I ovaj zadatak bi mogao da se reši naredbom:

int zbir=1+2+3+4+5+6+7+8+9+10;
printf( "zbir=%d",zbir );

Ili u C++ programskom jeziku:

int zbir = 1+2+3+4+5+6+7+8+9+10;
cout<< "zbir=%d" << zbir << endl;

Ali hoćemo da pokažemo kako bi se korišćem for ciklusa dobio zbir(pogodno kada ima puno brojeva). Ideja je da se u svakom ciklusu doda po jedan prirodan broj u neku promenljivu koja predstavlja zbir. Ti prirodni brojevi bi u ciklusu bili obeleženi sa promenljivom "i" kao i u prethodnom primeru(pogodno je jer se ta promenljiva menja od 1 do 10 tokom ciklusa sa korakom 1, tako da ona kroz cikluse zapravo predstavlja te prirodne brojeve koje treba sabrati.
Prvo je potrebno uvesti promenljivu koja će predstavljati zbir:
int zbir=0;
Zatim bi trebalo u zbir dodavati jedan po jedan broj. Napisano bez ciklusa to bi izgledalo:

          zbir = zbir + 1;
          zbir = zbir + 2;
          zbir = zbir + 3;
         zbir = zbir + 4;
...
         zbir = zbir + i;
...
         zbir = zbir + 10;
​
ali umesto toga koristimo ciklus:

for(int i = 1; i <= 10; i = i + 1)
{

zbir = zbir + i;

}

Konačan zbir će biti formiran tek po završetku for ciklusa. Kompletan primer je prikazan na slici ispod:

int zbir = 0;
for(int i = 1; i <= 10; i = i + 1)
{

zbir = zbir + i;

}
cout << "zbir=" << zbir << endl; // Štampa zbir

Primer 3: Određivanje proseka

Primer: Učitati 5 celih brojeva i naći srednju vrednost

Prvo je potrebno učitati brojeve. Da bi odredili prosečnu vrednost(aritmetičku sredinu) prvo je potrebno sabrati te vrednosti, a za to može da se iskoristi prethodni primer. Zatim se dobijeni zbir podeli sa brojem tih brojeva, što je u prethodnom primeru 5. U opštem slučaju možemo uvesti broj brojeva kao neko n i prvo uneti ili zadati tu vrednost. Prosek mora biti promenljiva realnog tipa, double ili float, jer se deljem dva broja, bilo da su cela ili realna može dobiti realan broj. Takođe, da bi se dobila tačna vrednost proseka, a ne celobrojna, mora bar jedan od deljenih brojeva(zbir ili n) biti postavljen ili programski pretvoren u realan tip. Npr. ako bi zbir bio 24, a n=5, deljenjem bi se dobilo 24/5= 4.0, ako bi brojevi 24 i 5 ostali celi. Ako bi umesto 24, vrednost bila realna kao npr 24.0, onda bi se kao rezultat deljenja dobilo 24.0/5= 24.0/5.0=4.8. 
​Rešenje prethodnog primera bi bilo:

#include <iostream>
using namespace std;

int main() {

// Deklaracija promenljivih
int broj, suma = 0;
double prosek;

// Učitavanje 5 brojeva od korisnika
for (int i = 1; i <= 5; i++) {

cout << "Unesite broj " << i << ": ";
cin >> broj;
suma += broj; // Dodavanje broja na sumu

}

// Izračunavanje proseka
prosek = suma / 5.0;

// Ispis rezultata
cout << "Srednja vrednost je: " << prosek << endl;

return 0;

}

Objašnjenje:

1. Deklaracija promenljivih:
   • broj: Čuva trenutni unos korisnika.
   • suma: Zbir svih unetih brojeva, inicijalno postavljena na 0.
   • prosek: Prosečna vrednost brojeva, definisana kao double radi preciznosti.
2. Petlja za unos:
   • Korisnik unosi 5 brojeva redom.
   • Svaki uneseni broj se dodaje na suma.
3. Izračunavanje proseka:
   • Prosek se dobija deljenjem sume sa 5.0 (koristi se decimalna vrednost kako bi rezultat bio double).
4. Ispis rezultata:
   • Prosek se prikazuje korisniku koristeći cout.

Posle pokretanja prikazaće se konzolni prozor aplikacije u kojem treba unositi brojeve. Primer izvršenja aplikacije može se videti na slici broj 2:

Slika 1: Primer iz for petlji-prosek brojeva-izvršenje

U pokazanom primeru se za unete brojeve 4, 5, 5, 5, 5 dobija prosek 4.8, što predstavlja tačnu vrednost. U kodu u liniji 16, treba uočiti da je izvršeno kastovanje podatka "zbir", koji je deklarisan kao int podatak. Kastovanjem se taj podatak pretvara u double, broj n će automatski da se konveruje u double, tako da se deljenjem dobija rezultat tipa double, i zato je dobijena tačna vrednost. U suprotnom bi se za rezultat dobio samo celobrojni deo, tj. 4.0.

---

Izrada simulacija pomoću ciklusa

Posmatrajmo sledeći problem:
Želimo da simuliramo promenu položaja s[m] pri ravnomernom kretanju za promenu vremena.Ovde se neće praviti vizuelna simulacija, nego samo ispisivanje trenutnih vrednosti položaja tela za svaku promenu vremena za interval dt.

Posmatraćemo promene položaja za svaki mali porast vremena od dt[s]
Uzmimo da je ta promena za dt=0.05s ​

Uvod u cikluse-simulacija ravnomernog kretanja​

Neka se vreme menja tokom 1s 20 promena po 0.05s   =  1s
Početne vrednosti su s=0; t=0; v unosi korisnik

Dakle 20 puta bi ponavljali sledeće naredbe:
t=t+dt;                        //promena vremena za 0.05s
s=s+v*dt;                   //promena položaja za 0.05s
cout<< “s=“<<s<<endl;    //Ispisivanje vrednosti pređenog puta.  Više o naredbi cout pogledajte u lekciji stringovi

Ovakav kod nije dobar:

t=t+dt;                        //promena vremena za 0.05s
s=s+v*dt;                   //promena položaja za 0.05s
cout<< “s=“<<s<<endl;  

t=t+dt;                        //promena vremena za 0.05s
s=s+v*dt;                   //promena položaja za 0.05s
cout<< “s=“<<s<<endl;  

t=t+dt;                        //promena vremena za 0.05s
s=s+v*dt;                   //promena položaja za 0.05s
cout<< “s=“<<s<<endl;  
...​

 Vidimo da se 3 naredbe ponavljaju 20 puta. Umesto toga treba napisati 3 naredbe jedan put a onda koristiti neku drugu naredbu koja će ih ciklično ponoviti onoliko puta koliko mi želimo.

To su naredbe koje zovemo ciklusi(petlje):

•  for
• while
• do-while

Petlje (ciklusi)u JAVI imaju vrlo sličnu sintaksu pisanja naredbi. Više o tome pročitajte u lekciji: Petlje u programskom jeziku JAVA

for ciklus

Sada bi prethodnu simulaciju rešili na sledeći način:

for(int i=0; i<20; i++)
{
 t=t+dt; //promena vremena za 0.05s
 s=s+v*dt; //promena položaja za 0.05s
 cout<< "s=" << s << endl;
}

Sledeće tri slike objašnjavaju kako funkcioniše for petlja na prikazanom primeru simulacije slobodnog pada čestice.

Slika 2: Primena for petlje za simulacije u c++- objašnjenje 1

Slika 3: Primena for petlje za simulacije u c++, objašnjenje kontrolnih izraza

Slika 4: Primena for petlje za simulacije u c++, objašnjenje kontrolnih izraza

for ciklus se koristi kada unapred znamo broj ciklusa.
Ako ne znamo unapred broj ciklusa?
Tada broj ciklusa zavisi od nekog uslova i onda koristimo
while naredbu ili,
do-while

while ciklus

Ova naredba se za razliku od for naredbe koristi kad ne znamo unapred broj ciklusa.
​ Primetimo da u maloj zagradi samo imamo jedan izraz logičkog tipa ili logičku promenljivu tipa bool. Naredbe u telu while naredbe će se ponavljati sve dok je taj izraz tačan tj. dok ima vrednost true. Pošto se uslov nalazi na početku while petlje, on se ispituje pre izvršenja naredbi. Može se desiti slučaj da u prvom ispitivanju vrednost bool izraza bude false, to znači da se u tom slučaju naredbe ne bi izvršile ni jedan put.
Ukoliko nam je iz bilo kog razloga važno da se naredbe izvrše bar jedan put, onda je pogodnije da uslov bude na kraju, što je slučaj kod do-while naredbe.

while,  sintaksa

Ponavljanje naredbi dok je zadovoljen uslov u zagradi
while( true )
{

NAREDBE

}

While algoritam

Na slici broj 3 je predstavljen algoritam izvršavanja while petlje. Naredbe u petlji će se ponavljati sve dok postavljen uslov bude imao vrenost true.

Slika 5. Algoritam while petlje

Primer 5: Uneti ceo broj N. Ukloniti mu nule sa desne strane. Npr. za uneto N=12000, na ulazu treba da bude 12

Ovaj zadatak je pogodan za primenu while ciklusa. Uklanjanje nula ćemo vršiti deljenjem sa 10 onoliko puta dokle broj koji transformišemo bude bio deljiv sa 10. Ne znamo koliko će to biti puta jer se ne zna unapred koji je unet broj. Dakle nije pogodan for, nego while ciklus kod koga će se izvršenje ciklično ponavljati sve dok bude bio zadovoljen uslov deljivosti, da ostatak deljenja N i broja 10 bude jednak nuli:

int N;
cin >> N; //Učitavanje celog broja

while(N % 10 == 0)
{

N=N/10; //Nova vrednost broja N je stara podeljena sa 10

}
cout << "N=" << N << endl;

Više o učitavanju brojeva cin naredbom pročitajte u lekciji stringovi.
Više o određivanju ostatka deljenja pročitajte u lekciji operatori.

Primer 6: Brojanje ciklusa

Ponekad je potrebno da se programski odredi broj ciklusa. Kod while petlje se obi;no ne zna unapred koliko će ciklusa biti odrađeno, već to zavisi od postavljenog uslova petlje.
Da bi program sam odredio broj ciklusa uvešćemo brojač ciklusa. To je ceo broj inicijalizovan na nulu.

int broj=0;
Pogledajmo primer koji to ilustruje:

Brojanje ciklusa u while petlji

U C++ jeziku, brojanje ciklusa u while petlji može se postići korišćenjem brojača. Brojač je promenljiva celobrojnog tipa, inicijalizovana na nulu, koja se uvećava pri svakom prolasku kroz petlju. Primer ispod ilustruje ovu tehniku.

 U ovom primeru, smanjujemo vrednost promenljive x u svakom ciklusu i pratimo ukupan broj iteracija.

#include <iostream>

using namespace std;

int main() {

// Deklaracija i inicijalizacija promenljivih
int broj = 0; // Brojač ciklusa
int x = 10; // Početna vrednost

// Petlja koja se izvršava dok je x veće od 0
while (x > 0) {

broj++; // Povećavamo brojač
x -= 2; // Smanjujemo vrednost x za 2
cout << "Vrednost x: " << x << ", Broj ciklusa: " << broj << endl;

}

// Ispis ukupnog broja ciklusa
cout << "Ukupan broj ciklusa: " << broj << endl;

return 0;

}

​Primer 7: Trening

Sportista je želeo da napravi svoj plan treninga za trčanje. Svakog dana je unosio za taj dan koliko je je pretrčao(1-5 km). Napraviti program koji pomaže sportisti da odredi posle koliko dana je pretrčao ukupno 40 km.

Rešenje: 
U ovom primeru koristimo while petlju da simuliramo dane treninga sportiste. Svakog dana korisnik unosi broj pretrčanih kilometara (u opsegu od 1 do 5). Petlja se izvršava dok ukupan broj pretrčanih kilometara ne dostigne ili premaši vrednost od 40. Ovo je idealan slučaj za while petlju, jer unapred nije poznat tačan broj iteracija (dana treninga). Kod uključuje proveru validnosti unosa kako bi se obezbedila korektnost rezultata. Na kraju, program ispisuje broj dana potrebnih da se pretrči 40 kilometara.

        #include <iostream> 
        using namespace std; 

        int main() {
            

                int ukupno = 0; 
                int dan = 0; 
                int km; 

                while (ukupno < 40) { 
                    

                        cout << "Unesite kilometre pretrčane za dan " << dan + 1 << " (1-5): ";
                        cin >> km;

                        if (km >= 1 && km <= 5) { 
                            ukupno += km; 
                            dan++; 
                        } else {
                            cout << "Neispravan unos! Unesite broj od 1 do 5." << endl;
                        }
                    
                }

                cout << "Sportista je dostigao 40 km posle " << dan << " dana." << endl;

                return 0;
            
        }
    

Objašnjenje koda:

1. Deklaracija promenljivih:
   • ukupno: Čuva zbir pretrčanih kilometara, inicijalizovan na 0.
   • dan: Brojač dana, povećava se za 1 nakon svakog validnog unosa.
   • km: Čuva broj pretrčanih kilometara za trenutni dan.
2. while petlja:
   • Radi sve dok zbir (ukupno) ne dostigne 40 kilometara.
   • Traži unos broja kilometara za svaki dan i validira ga.
3. Validacija unosa:
   • Ako unos nije u opsegu [1, 5], ispisuje se poruka o grešci i traži se novi unos.
4. Ispis rezultata:
   • Kada zbir pretrčanih kilometara dostigne 40, ispisuje se ukupan broj dana potrebnih da se postigne cilj.

---

Primer 8: Simulacija slobodnog pada

Tekst: Uneti početnu visinu tela i napraviti simulaciju slobodnog pada tako što se na svakih 0.05s ispisuju vreme, trenutna brzina i trenutna visina

Slika 6. Upotreba for petlje u simulaciji slobodnog pada lopte kreiranoj u programu EJS(Easy Java Simulation).

Na slici vidimo različite položaje tela posle svakih dt=0.05s.
Za to vremene promeni se visina h kao i brzina v.

• Vreme se promeni za dt: t=t+dt;
• Visina za v*dt+g*dt*dt/2. Dakle h=h-(v*dt+g*dt*dt/2)
  
• Brzina za g*dt.  Dakle,    v=v+g*dt

​U prethodnom primeru: Simulacija slobodnog pada pogodnije je da se koristi while petlja. U svakom ciklusu dolazi do promene vremena, trenutne visine tela i trenutne brzine tela. Ciklus se ponavlja sve dok visina bude veća od nule, tj. dok telo ne padne na zemlju.

double h;
cin >> h;
while(h>=0)
{

t=t+dt; //promena vremena za 0.05s

h=h-v*dt-g*dt*dt/2; //promena položaja u toku 0.05s

v=v+g*dt; //promena brzine u toku 0.05s

cout << "h=" << h << "m" << endl;

}

do-while ciklus

Koristimo umesto while ciklusa kada se naredbe moraju bar jednom odraditi, a onda, ako je uslov zadovoljen naredbe se ponavljaju, sve dok je uslov petlje zadovoljen, tj. ima vrednost true.

Prethodni primer bi se mogao odraditi i sa do-while ukoliko bi znali početne uslove pre nego što uđemo u ciklus, npr.
ako znamo da je sigurno h0>0 i
Početni uslovi:
h=h0; t=0;
tada bi kod izgledao:

Ponavljanje naredbi dok je zadovoljen uslov u zagradi
do
{

t=t+dt; //promena vremena za 0.05s

h=h-v*dt-g*dt*dt/2; //promena položaja u toku 0.05s

v=v+g*dt; //promena brzine u toku 0.05s

cout << "h=" << h << "m" << endl;

}
while(h>=0);

Ako bi početno h bilo jednako nuli, onda ovaj način nema smisla jer bi se odradila iteracija koja ne treba da se izvrši, pošto je telo već na zemlji.
Ako znamo da je sigurno h0>0
Tada se uslov postavlja na krajui zato koristimo do-while naredbu.

do - while , sintaksa

Ponavljanje naredbi dok je zadovoljen uslov u zagradi
do
{

NAREDBE

}
while( uslov);

Algoritam do-while petlje

Na slici broj 5 je predstavljen algoritam izvršavanja do-while petlje. Naredbe u petlji će se ponavljati sve dok postavljen uslov bude imao vrenost true. Za razliku od while petlje, gde se može dogoditi da uslov, na koga se nailazi odmah na početku naredbe, ne bude ispunjen ni prvi put, pa se naredbe neće odraditi ni jedan put, kod do-while petlje je uslov postavljen na kraju, pa naredbe moraju da se izvrše bar jedan put.

Slika 7. Algoritam do-while petlje

Primeri sa upotrebom do-while naredbe

Primer 9: Unos brojeva dok korisnik ne unese 0

Opis zadatka: Napišite program koji traži od korisnika da unese brojeve. Program treba da nastavi sa unosom dok korisnik ne unese broj 0. Nakon toga, program treba da ispiše zbir svih unesenih brojeva (osim nule).
Rešenje:

    #include <iostream> 
    // Uključivanje biblioteke za standardne I/O funkcije
    
    int main() {
      

        int broj, zbir = 0; 
        // Deklaracija promenljivih broj (unos korisnika) i zbir (inicijalizovan na 0)
        
        do { 
          

            cout << "Unesite broj (0 za kraj): "; 
            // Poruka korisniku da unese broj. Unos 0 završava petlju
            
            cin >> broj; 
            // Učitavanje broja unetog sa tastature
            
            zbir += broj; 
            // Dodavanje unetog broja u zbir
          
        } while (broj != 0); 
        // Petlja se ponavlja dok korisnik ne unese 0
        
        cout << "Zbir unesenih brojeva je: " << zbir << endl; 
        // Ispisivanje konačnog rezultata
        
        return 0; 
        // Završavanje programa
      
    }
  

Objašnjenje:

• do-while petlja omogućava da korisnik unese brojeve, a unosi se ponavljaju sve dok se ne unese broj 0.
• S obzirom na to da je 0 signal za kraj, program dodaje unesene brojeve u zbir i nastavlja unos dok se ne unese nula.
• Kada korisnik unese 0, petlja se završava i program ispisuje zbir brojeva.

Primer 10: Ispis brojeva od 1 do n, gde n unosi korisnik

Opis zadatka: Napišite program koji od korisnika traži da unese broj n. Program treba da ispiše sve brojeve od 1 do n. Program treba da se ponovo pokrene ako korisnik unese broj manji od 1.

​Rešenje:

    #include <iostream> /* Uključivanje biblioteke za standardne I/O funkcije */

    int n, i; /* Deklaracija promenljivih n (broj koji unosimo) i i (brojač u petlji) */

    do { /* Početak do-while petlje koja se ponavlja dok broj n nije veći od 0 */
      

        cout << "Unesite broj n (veći od 0): "; /* Ispisivanje poruke korisniku da unese broj n */
        cin >> n; /* Unos broja n sa tastature */

        if (n <= 0) { /* Provera da li je broj manji ili jednak 0 */
          

            cout << "Broj mora biti veći od 0. Pokušajte ponovo.\n"; /* Ako broj nije veći od 0, ispisuje se poruka greške */
          
        }
      
    } while (n <= 0); /* Petlja se ponavlja dok broj n nije veći od 0 */

    cout << "Brojevi od 1 do " << n << ":\n"; /* Ispisivanje poruke sa vrednošću n, koja označava koliko brojeva treba ispisati */

    for (i = 1; i <= n; i++) { /* For petlja za ispis brojeva od 1 do n */
      

        cout << i << " "; /* Ispisivanje broja i u svakom prolazu petlje */
      
    }
    cout << "\n"; /* Novi red nakon ispisa svih brojeva */

    return 0; /* Završavanje programa i vraćanje vrednosti 0 kao uspešan izlaz */
  

Objašnjenje:

• do-while petlja osigurava da korisnik unese broj veći od 0.
• Ako korisnik unese broj manji ili jednak nuli, program će ponovo tražiti unos.
• Kada je unos validan, program koristi petlju za ispis brojeva od 1 do n.

Primer 11: Provera validnosti unosa lozinke

Opis zadatka: Napišite program koji od korisnika zahteva da unese lozinku u obliku broja. Ako je lozinka netačna (npr. "1234"), program treba da traži ponovni unos sve dok korisnik ne unese tačnu lozinku. Tačna lozinka je broj "1234".​
Rešenje:

    #include <iostream> 

    using namespace std; 

    int lozinka; 

    do { 
      

        cout << "Unesite lozinku (broj): "; 
        cin >> lozinka; 

        if (lozinka != 1234) { 
          

            cout << "Pogrešna lozinka. Pokušajte ponovo.\n"; 
          
        }
      
    } while (lozinka != 1234); 

    cout << "Lozinka je tačna!\n"; 

    return 0; 
  

Objašnjenje:

• Program koristi do-while petlju da bi omogućio korisniku unos lozinke u obliku broja.
• Ako korisnik unese netačnu lozinku, program traži ponovni unos.
• Kada korisnik unese tačnu lozinku (u ovom slučaju broj "1234"), petlja se završava i ispisuje se poruka o uspešnom unosu lozinke.

Beskonačne Petlje u C++

Beskonačne petlje su petlje koje nikada ne prestaju sa izvršavanjem. One se obično dešavaju kada je uslov petlje uvek true, što može biti rezultat greške u kodu ili namernog dizajna za specifične zadatke.

Primer Beskonačne Petlje

            while (true) { 
                std::cout << "Ovo je beskonačna petlja!" << std::endl;
            }
        

Uobičajeni Uzroci

• Pogrešan ili nedostajući uslov za izlazak.
• Promenljive koje kontrolišu petlju se ne ažuriraju pravilno.
• Korišćenje konstante true u uslovu petlje bez mehanizma za izlazak.

Kako Izbeći Beskonačne Petlje

Postoji nekoliko koraka za izbegavanje beskonačnih petlji:

1. Uvek proverite uslov petlje da li može postati false.
2. Obezbedite da se promenljive koje kontrolišu petlju ispravno ažuriraju.
3. Dodajte logiku za prekidanje petlje pomoću break ukoliko je to potrebno.

Primer Korektne Petlje

            int i = 0;
            while (i < 5) {
                std::cout << "i = " << i << std::endl;
                i++;
            }
        

Kada su Beskonačne Petlje Korisne?

Iako se beskonačne petlje često javljaju kao greška, postoje situacije kada su one korisne i čak neophodne:

• U server aplikacijama koje kontinuirano obrađuju zahteve.
• U igrama gde glavna petlja kontroliše tok igre.
• Za kreiranje menija koji traje dok korisnik ne odabere opciju za izlaz.

Primeri Beskonačnih Petlji

Evo nekoliko primera kako se beskonačne petlje koriste u praksi:

            for (;;) { 
                std::cout << "Ova petlja traje zauvek!" << std::endl;
            }
        

            while (true) { 
                std::string input;
                std::cout << "Unesite 'exit' za izlaz: ";
                std::cin >> input;
                if (input == "exit") {
                    break;
                }
            }
        

Kako Izbeći Beskonačne Petlje

Postoji nekoliko koraka za izbegavanje beskonačnih petlji:

1. Uvek proverite uslov petlje da li može postati false.
2. Obezbedite da se promenljive koje kontrolišu petlju ispravno ažuriraju.
3. Dodajte logiku za prekidanje petlje pomoću break ukoliko je to potrebno.

Primer Korektne Petlje

            int i = 0;
            while (i < 5) {
                std::cout << "i = " << i << std::endl;
                i++;
            }
        

Primer Beskonačne Petlje Koristeći for

        for (int i = 0; true; i++) { 
            std::cout << "Ovo je for beskonačna petlja, i = " << i << std::endl;
        }
    

Primer Beskonačne Petlje Koristeći do-while

        int brojac = 0;
        do { 
            std::cout << "Ovo je do-while beskonačna petlja, brojac = " << brojac << std::endl;
            brojac++;
        } while (true);
    

​Naredbe break i continue

Korišćenje Naredbe break u Petljama

U programiranju, naredba break se koristi za trenutni izlazak iz petlje, bez obzira na to da li je uslov petlje još uvek zadovoljen. Ovo može biti korisno kada želite da prekinete izvršavanje petlje nakon što se postigne određeni uslov.

Primer Korišćenja break u for Petlji

        for (int i = 0; i < 10; i++) {
            std::cout << "i = " << i << std::endl;
            if (i == 5) {
                break; // Izlazak iz petlje kada i dostigne 5
            }
        }
    

Primer Korišćenja break u while Petlji

        int broj = 0;
        while (true) {
            std::cout << "Unesite broj (unesite -1 za izlaz): ";
            std::cin >> broj;
            if (broj == -1) {
                break; // Izlazak iz petlje kada korisnik unese -1
            }
            std::cout << "Uneli ste broj: " << broj << std::endl;
        }
    

Kao što se vidi u ovim primerima, naredba break je moćan alat koji omogućava kontrolisano prekidanje toka izvršavanja petlji.

Upotreba continue u Ciklusima

Naredba continue koristi se u petljama da preskoči preostali deo trenutne iteracije i pređe na sledeću iteraciju. Ovo je korisno kada želite da ignorišete određene uslove tokom izvršavanja petlje, ali da ne prekinete celu petlju.

Primer Korišćenja continue u for Petlji

        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                continue; // Preskoči ispis ako je i paran broj
            }
            std::cout << "i = " << i << std::endl;
        }
    

Primer Korišćenja continue u while Petlji

        int broj = 0;
        while (broj < 10) {
            broj++;
            if (broj == 5) {
                continue; // Preskoči ispis kada je broj jednak 5
            }
            std::cout << "broj = " << broj << std::endl;
        }
    

Naredba continue omogućava veću fleksibilnost u kontrolisanju toka izvršavanja unutar petlji, posebno kada treba da ignorišete određene uslove bez prekidanja celokupnog procesa iteracije.

Dodatni resursi za vežbanje petlji u C++

• Petlje u C++ - primeri
  Detaljni primeri petlji sa objašnjenjima za C++.
• LearnCpp.com - Uvod u petlje
  Sveobuhvatan vodič za petlje u C++ sa praktičnim primerima.
• Priprema za okružna takmičenja
  Zadaci i primeri za napredno vežbanje algoritama.
• Dodatni primeri iz petlji
  Dodatni primeri i zadaci koji pokrivaju razne vrste petlji.
• GeeksforGeeks - Petlje u C++
  Detaljan članak sa raznovrsnim primerima petlji u C++.

Za dodatna pitanja i objašnjenja, kontaktirajte nas putem formi za kontakt.

---

Prethodno
​|< Grananje u programu u C/C++

​Sledeće
​​Ugnježdene petlje u C++ >|

Srodni članci

Petlje u c/c++ programskom jeziku-primeri
Petlje u programskom jeziku JAVA
Nizovi-primeri
Fibonačijev niz
Podaci u C/C++ jeziku