Ebben a tananyagrészben arról lesz szó, hogy egy ciklusban hogyan tudjuk a ciklus egy adott lépését kihagyni,vagy egy adott feltétel teljesülése esetén hogy tudunk a ciklusból kilépni.

Előző tananyagrész: do-while ciklus, input ellenőrzés
Következő tananyagrész: kétdimenziós tömbök

continue utasítás

Ha azt szeretnénk, hogy egy általunk megadott feltétel teljesülése esetén a ciklusmag hátralévő utasításait hagyja ki a ciklus annál a lépésnél, ahol éppen tart (de utána folytatódjon tovább a következő lépéssel), akkor a continue; utasítást használhatjuk.
Ez például akkor lehet hasznos, ha például egy tömb elemeinek feldolgozásánál bizonyos típusú elemeket, vagy akár egy bizonyos elemet ki szeretnénk hagyni.

Szemléltető példa:

for (int i = 0; i < arr_size; ++i ) {
  //statements
  if ( /* condition */ ) {
    continue;
  }
  //statements executed if the condition is false
}

Ebben az esetben nem kell a feltételtől függő utasításokat else ágba foglalni, hiszen a continue utasítás rögtön a ciklus következő lépéséhez ugrik, anélkül, hogy a ciklus blokkjában lévő hátralévő utasítások végrehajtódnának.

Utasítások végrehajtása, vagy nem végrehajtása mindig a ciklus egy adott lépésében értendő. Például lehetséges, hogy a feltétel igaz a ciklus harmadik lépésében (mondjuk amikor i értéke 2), így a ciklusmagban hátralévő utasítások nem hajtódnak végre a ciklus harmadik lépésében. Viszont mondjuk a ciklus negyedik lépésében a feltétel hamis, így ekkor a ciklusmag hátralévő utasításai végrehajtódnak.

1. continue példa: egy bizonyos elem kihagyása (index alapján)

Ha ki szeretnénk hagyni egy tömb egyik elemét, például mondjuk egy tömb tizenharmadik elemet, akkor a feltétel: i == 12.

for (int i = 0; i < arr_size; i++) {
  if (i == 12) {
    continue;
  }
  //statements executed if i != 12
}

2. continue példa: nem 0 értékű számok összeszorzása

Ez a rövidke példaprogram összeszorozza egy adott tömbben található nem 0 értékű számokat. Ha a for ciklusban egy 0 értékű szám a soron következő elem, akkor a ciklus azon lépésében nem lesz elvégezve a szorzás művelet. Mivel a tizedestörtek között -0.0 is előfordulhat, így a teljesség kedvéért ez is szerepel a feltételben.
Ügyeljünk arra, hogy az eredmény változó kezdőértéke 1 és ne 0 legyen.
Ebben a példában az egyszerűség kedvéért nem a felhasználótól kérjük be a tömb elemeit, de természetesen azt is megtehetnénk.

#include <iostream>

int main () {
  float numbers[] = {2, 0, 2.4, 3.6, 0, 9, 2, -2.3, 0, 1};
  const int arr_size = sizeof(numbers)/sizeof(numbers[0]);
  
  float result = 1.0;

  for (int i = 0; i < arr_size; i++) {
    if (numbers[i] == 0 || numbers[i] == -0.0 ) {
      continue;
    }
    result *= numbers[i];
  }
  std::cout << "Product of elements with not 0 value: " << result << '\n';
}

break utasítás

Ha pedig azt szeretnénk, hogy a ciklus egy bizonyos feltétel teljesülése esetén ne folytatódjon tovább (tehát ne hajtódjanak végre a ciklus jelenlegi lépésében hátralévő (a break utasítást követő) utasítások, és a ciklus következő lépései sem), akkor a break utasítást használhatjuk.

Általában megvetendőnek tartják, ha a ciklusból való kilépést a break utasítással érjük el. Ezzel kapcsolatban 3 dolgot érdemes tudni:

• ciklusok esetén a break használata kiváltható azzal, ha módosítjuk a ciklus feltételét
• ranged for ciklusból elfogadottnak tartják a break utasítással való kilépést
• ha függvényeket használunk, akkor a return utasítás kiváltja a break utasítást

1. break példa: nagyon egyszerű keresés

A példában definiálunk egy 1000 elemű tömböt, amit feltöltünk véletlenszerűen generált egész számokkal (1 és 100 között), és megkeressük benne a felhasználó által megadott szám első előfordulásának helyét. Ha van ilyen érték, akkor kiíratjuk a tömb adott elemének indexénél egyel nagyobb számot, ha nincs, akkor pedig egy erre vonatkozó üzenetet.
Ha a felhasználó nem 1 és 100 közötti számot ad meg, a program (az egyszerűség kevéért) leáll. Később arra is nézünk példát, hogyan oldhatjuk meg, hogy újra meg újra bekérjük az értéket, egészen addig, amíg a felhasználó nem 1 és 100 közötti értéket ad meg (vagy a program bezárásra nem kerül).

Véletlenszerű számok generálásához például a standard library cstdlib header fájljában található rand() függvényt használhatjuk. Ebben a tananyagban az emögött álló matematikai háttér ismertetésébe nem megyünk bele, hanem csak néhány példát nézünk át, melyek alapján intuícióval kikövetkeztethető ezen utasítás működése:
int b;
b = rand() % 100; //b értéke egy 0 és 99 közötti egész szám lesz
b = rand() % 100 + 1; //b értéke egy 1 és 100 közötti egész szám lesz
b = rand() % 31 + 1987; //b értéke egy 1987 és 2017 közötti egész szám lesz

A break utasítást ebben a példában arra használjuk, hogyha a keresett számot a program megtalálta, akkor a ciklusnak már fölösleges tovább futnia (legalábbis e példa szerint). Persze akár az összes előfordulását is kiírathatnánk a keresett számnak (annak megvalósításához nem lenne szükség break utasításra).

#include <iostream>
#include <random>

int main() {

  std::random_device rnd_device;
  std::mt19937 rnd_generator(rnd_device());
  std::uniform_int_distribution<int> int_dist(1,100);

  const int arr_size = 1000;
  int random_numbers[arr_size];

  for (int& element : random_numbers) {
    element = int_dist(rnd_generator);
  }

  std::cout << "Please enter a number between 1 and 100" << '\n';
  int find_number;
  std::cin >> find_number;

  if (find_number > 100 || find_number < 1) {
  std::cout << "Error: input number is not between 1 and 100" << '\n';
    return 0;
  }

  bool found = false;
  for (int i = 0; i < arr_size; ++i) {
    if (random_numbers[i] == find_number) {
      found = true;
      std::cout << "Index of searched number: " << i+1 << '\n';
      break;
    }
  }
  if (!found) {
    std::cout << "The input number is not in the array"  << '\n';
  }
}

2. break példa: ciklus befejezése egy adott elemnél

Természetesen a break utasítás esetén is megtehetjük, hogy a feltételben egy konkrét tömbindexet adunk meg, hasonlóan, mint a continue utasítás esetén.
Ebben a nagyon egyszerű példában ha a felhasználó egy 1 és 10 közötti számot ad meg, akkor a program 1-től írja ki az egész számokat a felhasználó által megadott számmal bezárólag, egyébként pedig 1-től tízig.

//end loop at a specified element
#include <iostream>

int main() {
  std::cout << "Please enter a number between 1 and 10" << '\n';
  int input_number;
  std::cin >> input_number;

  if (input_number < 1 || input_number > 10) {
    std::cout << "The input number is not between 1 and 10\n";
    return 0;
  }

  for (int i=0; i < 10; i++ ) {
    if ( i == input_number) {
      break; 
    }
    std::cout << i+1 << '\n';
  }
}

Ehelyett a megoldás helyett a break utasítás elágazásában lévő feltételt érdemes inkább összefűzni a for ciklus feltételével, ennél a példánál i < 10 && i != input_number.

A continue és break utasítások nem csak for cikluson belül használhatóak.

Előző tananyagrész: do-while ciklus, input ellenőrzés
Következő tananyagrész: kétdimenziós tömbök