Home

ITA - Appunti Cpp 008 - Looping

March 2024 (2020 Words, 12 Minutes)

linux debian lmde cpp

Cicli for

Il ciclo for viene usato per eseguire un operazione ripetutamente.

Sintassi

La sintassi di un ciclo for:

for ( init_clause ; cond_expression ; iteration_expression ) loop_statement

Il ciclo si comporta come segue:

NB: in un ciclo for init_clause, cond_expression e iteration_expression sono tutte facoltative.

Esempio

Esempi d’uso dei cicli for:

#include <iostream>
#include <vector>

int main() {
    std::cout << "Esempi di cicli for:" << std::endl;

    std::cout << "\n\n1) ciclo for standard con un solo statement nel body: \n";
    for (int i = 0; i < 10; ++i)
        std::cout << i << ' ';

    std::cout << "\n\n2) ciclo for senza body, con un operazione \ninclusa nell iteration_expression :\n";
    std::cout << " - ";
    for (int i = 0; i < 10; std::cout << i << " - ", ++i );

    std::cout << "\n\n3) nel init-statement si possono inzizializzare più valori\n";
    for (int i = 0, *p = &i; i < 9; i += 2)
        std::cout << i << ':' << *p << ' ';

    std::cout << "\n\n4) la condizione pù essere dichiarativa:\n";
    char cstr[] = "Hello";
    for (int n = 0; char c = cstr[n]; ++n)
        std::cout << c;

    std::cout << "\n\n5) init-statement può usare l'operatore auto :\n";
    std::vector<int> v = {3, 1, 4, 1, 5, 9};
    for (auto iter = v.begin(); iter != v.end(); ++iter)
        std::cout << *iter << ' ';

    std::cout << "\n\n6) init-statement può essere un espressione:\n";
    int n = 0;
    for (std::cout << "Loop start\n";
         std::cout << "Loop test\n";
         std::cout << "Iteration " << ++n << '\n')
    {
        if (n > 1)
            break;
    }

    std::cout << "\n7) Costruttori e distruttori di oggetti creati - distrutti\n"
                 "nel body sono chiamati a ogni iterazione:\n";
    struct S
    {
        S(int x, int y) { std::cout << "S::S(" << x << ", " << y << "); "; }
        ~S() { std::cout << "S::~S()\n"; }
    };

    for (int i{0}, j{5}; i < j; ++i, --j)
        S s{i, j};

    std::cout << std::endl;

    return 0;
}

Cicli while

Questi cicli eseguono ripetutamente un’istruzione, finché il valore della condizione diventa falso. Il controllo avviene prima di ogni iterazione.

Sintassi

attr  while (condizione) istruzione

Esempio

#include <iostream>

int main()
{
    // ciclo while di un istruzione
    int i = 0;
    while (i < 10)
         i++;
    std::cout << i << '\n';
 
    // ciclo while 
    int j = 2;
    while (j < 9)
    {
        std::cout << j << ' ';
        j += 2;
    }
    std::cout << '\n';
 
   // ciclo while con una condizione 
   char cstr[] = "Hello";
   int k = 0;
   while (char c = cstr[k++])
       std::cout << c;
   std::cout << '\n';
}

Cicli do - while

Esegue ripetutamente un’istruzione, finché il valore di controllo diventa falso. Il check avviene dopo ogni iterazione.

Sintassi

attr do istruzione while (espressione);

NB: L’istruzione viene sempre eseguita almeno una volta, anche se l’espressione restituisce sempre false. Se in questo caso non dovesse essere eseguito, è possibile utilizzare un ciclo while o for.

Se ad un certo punto è necessario terminare l’esecuzione del ciclo, è possibile utilizzare un’istruzione break come istruzione di terminazione.

Se è necessario continuare l’esecuzione del ciclo alla fine del corpo del ciclo, è possibile utilizzare un’istruzione continue come scorciatoia.

Esempio

#include <algorithm>
#include <iostream>
#include <string>
 
int main()
{
    int j = 2;
    do // compound statement is the loop body
    {
        j += 2;
        std::cout << j << ' ';
    }
    while (j < 9);
    std::cout << '\n';
 
    // common situation where do-while loop is used
    std::string s = "aba";
    std::sort(s.begin(), s.end());
 
    do std::cout << s << '\n'; // expression statement is the loop body
    while (std::next_permutation(s.begin(), s.end()));
}

Operatori continue e break

continue

L’istruzione continue provoca un salto, come se andassi alla fine del corpo del ciclo (può apparire solo all’interno del corpo del ciclo dei cicli for, while e do-while).

#include <iostream>
 
int main()
{
    for (int i = 0; i < 10; ++i)
    {
        if (i != 5)
            continue;
        std::cout << i << ' ';      // this statement is skipped each time i != 5
    }
    std::cout << '\n';
 
    for (int j = 0; 2 != j; ++j)
        for (int k = 0; k < 5; ++k) // only this loop is affected by continue
        {
            if (k == 3)
                continue;
            // this statement is skipped each time k == 3:
            std::cout << '(' << j << ',' << k << ") ";
        }
    std::cout << '\n';
}

break

Questo operatore viene usato nel body di un ciclo (for, while do-while) o di uno switch. Dopo questa istruzione il controllo viene trasferito all’istruzione immediatamente successiva al blocco dello switch.

Come con qualsiasi uscita di blocco i valori nello scope vengono cancellate in ordine inverso di costruzione, prima dell’esecuzione della prima riga successiva.

#include <iostream>
 
int main()
{
    int i = 2;
    switch (i)
    {
        case 1: std::cout << "1";   // <---- maybe warning: fall through
        case 2: std::cout << "2";   // execution starts at this case label (+warning)
        case 3: std::cout << "3";   // <---- maybe warning: fall through
        case 4:                     // <---- maybe warning: fall through
        case 5: std::cout << "45";  //
                break;              // execution of subsequent statements is terminated
        case 6: std::cout << "6";
    }
    std::cout << '\n';
 
    for (char c = 'a'; c < 'c'; c++)
    {
        for (int i = 0; i < 5; i++)      // only this loop is affected by break
        {                                //
            if (i == 2)                  //
                break;                   //
            std::cout << c << i << ' ';  //
        }
    }
    std::cout << '\n';
}

Cicli infiniti

Ciclo for infinito

Se cond_expression viene omesso o viene sostituito con una costante intera diversa da zero, si rende il ciclo infinito:

// ciclo for infinito
for(;;)

}

Ciclo while infinito

In un cliclo while se la condizione è forzata a true o a un numero diverso da zero:

// ciclo infinito
while(true)
{
    // corpo del ciclo
}

// ciclo infinito
do 
{
    // corpo del ciclo
}
while(1);

Riferimenti

© 2024 Stefano Prina
Licenza Creative Commons
Quest'opera è distribuita con Licenza Creative Commons Attribuzione - Condividi allo stesso modo 4.0 Internazionale


Theme  Moonwalk