W języku C++ istnieją dwie wartości logiczne:

Są to predefiniowane stałe, którymi możemy się posługiwać w wyrażeniach logicznych:

Przez wyrażenie logiczne rozumiemy wyrażenie, które jest albo prawdziwe (sprowadza się do wartości true lub jest różne od zera) albo fałszywe (sprowadza się do wartości false lub do zera). Na przykład wyrażenie:  a > 10 jest typowym wyrażeniem logicznym. Wartość logiczna (true lub false) tego wrażenia zależy od bieżącej zawartości zmiennej a. Jeśli a rzeczywiście zawiera wartość większą od 10, to wyrażenie ma wartość logiczną true (1). W przeciwnym razie wartość logiczna wyrażenia to false (0). Poniższy przykład programowy obrazuje te zależności:

// Wartości logiczne
// (C)2020 mgr Jerzy Wałaszek
// I LO w Tarnowie

#include <iostream>

using namespace std;

int main( ) 
{ 
    int a;

    a = 25; cout << ( a > 10 ) << endl;
    a =  5; cout << ( a > 10 ) << endl;

    return 0;
}

Wynika z tego, iż w języku C++ wartości logiczne są traktowane jak zwykłe liczby. Takie podejście znacznie ułatwia programowanie. Umówmy się na przyszłość, iż wyrażenie jest prawdziwe, jeśli ma wartość różną od zera i fałszywe w przypadku przeciwnym.

Wyrażenia logiczne powstają często przy pomocy operatorów porównań:

Logika w języku C++ ściśle opiera się na Algebrze Boole'a. Poniżej przedstawiamy dostępne w C++ operatory logiczne odpowiadające bezpośrednio funkcjom logicznym Algebry Boole'a:

Przy obliczaniu wartości wyrażenia logicznego w języku C++ obowiązuje tzw. zasada zwarcia (ang. boolean short circuit). Polega ona na tym, iż wyrażenie jest obliczane tylko do momentu, gdy znana jest już jego wartość końcowa. Ma to głęboki sens. Na przykład:

W tym wyrażeniu pierwszy człon ( i < 10 ) sprawdza zapewne wartość indeksu tablicy. Być może tablica a [ ] posiada tylko 10 elementów a [ 0 ], a [ 1 ], ..., a [ 9 ]. Jeśli pierwsze wyrażenie jest fałszywe (czyli indeks wskazuje element nie należący do tablicy), to bez względu na wartość drugiego wyrażenia wynik jest również fałszywy (porównaj tabelkę dla operatora && z pierwszym argumentem równym false). Zatem nie ma sensu wyznaczać wartości drugiego członu ( a [ i ] == 12 ). Dlatego to wyrażenie nie będzie już obliczane (z drugiej strony nie można go nawet poprawnie obliczyć, skoro i  indeksuje element leżący poza tablicą) – nastąpi "zwarcie" po wyliczeniu pierwszego wyrażenia.

W języku C++ wyrażenia logiczne można stosować w poniższych sytuacjach:

wyrażenie logiczne ? wartość1 : wartość2

Operator ? wylicza wartość wyrażenia logicznego. Jeśli jest ono prawdziwe, to wynikiem całości jest wartość₁. W przeciwnym razie wynikiem jest wartość₂. Na przykład wyrażenie:

(( a > 5 ) && ( a < 10 )) ? a : - a

daje w wyniku wartość zmiennej a, jeśli a wpada w przedział otwarty ( 5,10 ) i - a w przypadku przeciwnym. Oto proste aplikacje operatora ?:

if( wyrażenie logiczne ) instrukcja1; else instrukcja2;

Instrukcja if (jeśli) jest tzw. instrukcją warunkową, która umożliwia tworzenie rozgałęzień w programie. Dzięki niej komputer może podejmować decyzje, a zatem postępować inteligentnie i dopasowywać swoje działania do aktualnej sytuacji. Instrukcja if jako argument przyjmuje wyrażenie logiczne. Jeśli wyrażenie to ma wartość prawdy (true lub większą od zera), to wykonana zostanie instrukcja₁. Jeśli wyrażenie jest fałszywe (ma wartość false lub jest równe zeru), to wykonana zostanie instrukcja₂. Zatem w zależności od wyniku wyrażenia logicznego wykonujemy różne instrukcje.

Człon else można pominąć - wtedy instrukcja₁ będzie wykonywana warunkowo tylko wtedy, gdy wyrażenie logiczne będzie prawdziwe:

if( wyrażenie logiczne) instrukcja1

Jeśli wyrażenie logiczne jest fałszywe, to komputer po prostu przejdzie do następnej instrukcji w programie.

Poniższy program wczytuje trzy liczby a, b i c, a następnie wyznacza największą z nich.

// max ( a,b,c )
// (C)2020 mgr Jerzy Wałaszek
// I LO w Tarnowie

#include <iostream>

using namespace std;

int main( )
{ 
    int a,b,c,max;

    cin >> a >> b >> c;

    max = a;

    if( b > max ) max = b;

    if( c > max ) max = c;

    cout << max << endl;

    return 0;
}

Jeśli zamiast pojedynczej instrukcji chcemy wykonać więcej różnych operacji, to zastępujemy ją tzw. instrukcją złożoną, czyli grupą instrukcji ujętych w klamry:

if( wyrażenie logiczne) 

{

    instrukcja1;

    instrukcja2;
    ...

    instrukcjan;
 }
else
{ 

    ...
}

Zwróć uwagę, iż po klamerce zamykającej w instrukcji złożonej nie stosuje się już średnika.

while( wyrażenie logiczne ) instrukcja;

Instrukcja while (dopóki) służy do tworzenia tzw. pętli warunkowych. Pętla jest to powtarzanie wybranej instrukcji (lub grupy instrukcji) w programie. Jeśli powtarzanie jest uzależnione od jakiegoś warunku, mamy do czynienia z pętlą warunkową. Instrukcja while wylicza wyrażenie logiczne. Jeśli jest ono prawdziwe, to wykonywana jest instrukcja (jeśli instrukcji ma być wykonane więcej niż jedna, to należy zastosować instrukcję złożoną, czyli klamerki). Po wykonaniu instrukcji znów następuje wyliczenie wartości wyrażenia logicznego i jeśli jest prawdziwe, ponowne wykonanie instrukcji. Całość się powtarza dotąd, aż w końcu warunek przestanie być prawdziwy. Wtedy pętla jest przerywana i program przechodzi do wykonania następnej instrukcji poza pętlą.

Poniższy program odczytuje ze standardowego wejścia liczbę, a następnie wyświetla jej kolejne potęgi aż do momentu, gdy przekroczą one wartość 1000.

// Pętla while
// (C)2020 mgr Jerzy Wałaszek
// I LO w Tarnowie

#include <iostream>

using namespace std;

int main( ) 
{ 
    int a,p;

    cin >> a;

    cout << endl;

    p = a;

    while( p <= 1000 ) 
    { 
        cout << p << endl;

        p *= a;
}

  cout << p << endl;

  return 0;
}

Zwróć uwagę, iż pętla while może nie wykonać się ani jeden raz, jeśli wyrażenie logiczne jest już na samym początku fałszywe. Jest to konsekwencja faktu, iż wartość wyrażenia logicznego sprawdzana jest przed wykonaniem obiegu pętli.

do instrukcja; while( wyrażenie logiczne );

Instrukcja do...while (wykonuj... dopóki) jest odmianą pętli warunkowej. Instrukcja zawarta w pętli powtarzana jest, jeśli wyrażenie logiczne jest prawdziwe. Jednakże w tym przypadku warunek kontynuacji pętli sprawdzany jest na końcu, po wykonaniu obiegu. Zatem instrukcja zawsze będzie wykonana przynajmniej jeden raz. Czasami taka opcja jest bardzo pożądana.

Powyższy program w wersji do...while upraszcza się:

// Pętla typu do...while
// (C)2020 mgr Jerzy Wałaszek
// I LO w Tarnowie

#include <iostream>

using namespace std;

int main( )
{ 
    int a,p;

    cin >> a;
    
    cout << endl;

    p = 1;

    do
    { 
        p *= a;

        cout << p << endl;
    } while( p <= 1000 );

    return 0;
}

for( instrukcja1; wyrażenie logiczne; instrukcja2 ) instrukcja3;

Instrukcja for (dla) jest ogólną instrukcją pętli warunkowej. Skupia ona w jednym miejscu wszystkie elementy sterujące pętlą:

• instrukcja₁ jest tzw. instrukcją inicjującą, która ma za zadanie przygotowanie pętli do wykonywania się.
• wyrażenie logiczne steruje kontynuacją pętli. Pętla będzie wykonywana, jeśli wyrażenie to jest prawdziwe.
• instrukcja₂ jest instrukcją wykonywaną na samym końcu pętli. Umożliwia ona przygotowanie zakończenia danego obiegu.
• instrukcja₃ jest instrukcją powtarzaną w pętli.

Całość instrukcji for tłumaczona jest przez kompilator na następującą sekwencję poleceń języka C++:

instrukcja1;                // przygotowanie pętli
while( wyrażenie logiczne ) // pętla warunkowa
{ 
    instrukcja3;            // powtarzana instrukcja
    instrukcja2;            // przygotowanie zakończenia danego obiegu
}

Poniżej masz program wyliczający kolejne potęgi wprowadzonej liczby aż do momentu, gdy przekroczą wartość 1000.

// pętla warunkowa typu for
// (C)2020 mgr Jerzy Wałaszek
// I LO w Tarnowie

#include <iostream>

using namespace std;

int main( )
{ 
    int a,p;

    cin >> a;

    cout << endl;

    for( p = 1; p <= 1000; p *= a )
        cout << p << endl;

    cout << p << endl;

    return 0;
}

Instrukcja for służy najczęściej do tworzenia tzw. pętli iteracyjnych. Termin iteracja oznacza kolejne zliczanie. Pętla iteracyjna to pętla, w której kolejne obiegi są zliczane, czyli po prostu posiadają swoje indywidualne numery. Do zliczania obiegów potrzebujemy zmiennej licznikowej (ang. counter variable). Poniższy program wykorzystuje instrukcję for do utworzenia pętli iteracyjnej, która wykonuje obiegi o numerach od 1 do 9. Numery kolejnych obiegów są wypisywane na standardowym wyjściu.

// pętla iteracyjna typu for
// (C)2020 mgr Jerzy Wałaszek
// I LO w Tarnowie

#include <iostream>

using namespace std;

int main( ) 
{ 
    for( int i = 1; i <= 9; i++ )
        cout << i << " ";

    cout << endl;

    return 0;
}

Wartości logiczne można w języku C++ przechowywać w zmiennych logicznych, które deklarujemy na podstawie typu bool:

...
bool a,b,c;
...

Zmienna logiczna może przechowywać wartości true lub false. W pamięci komputera zajmuje 1 bajt (8 bitów). Poniższy program sprawdza rozmiar typu bool na twoim komputerze. Wynik jest podawany w bajtach.

// rozmiar typu logicznego
// (C)2020 mgr Jerzy Wałaszek
// I LO w Tarnowie

#include <iostream>

using namespace std;

int main( ) 
{ 
    cout << sizeof( bool ) << endl;

    return 0;
}

Poniższy program demonstruje przykładowe zastosowanie zmiennej logicznej. Program sprawdza, czy liczba 10 występuje nieparzystą liczbę razy w ciągu 400 liczb pseudolosowych z zakresu od 0 do 10. Jeśli tak, wypisuje napis "Nieparzysta ilość wystąpień liczby 10".

// Zmienna logiczna
// (C)2020 mgr Jerzy Wałaszek
// I LO w Tarnowie

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>

using namespace std;

int main (  )
{ 
    setlocale( LC_ALL,"" );

    srand( time( NULL ));

    bool t = false;

    for( int i = 0; i < 400; i++ )
    { 
        int x = rand( ) % 11;

        if( x == 10 ) t = !t;

        cout << setw ( 4 ) << x;
    }

    cout << endl;

    if( t ) cout << "\nNieparzysta ilość wystąpień liczby 10\n\n";

    return 0;
}

Jeśli wykorzystujemy operację logiczną do modyfikacji zmiennej, to możemy zastosować tzw. formy skrócone operacji przypisania: