Serwis Edukacyjny
w I-LO w Tarnowie
obrazek

Materiały dla uczniów liceum

  Wyjście       Spis treści       Wstecz       Dalej  

Autor artykułu: mgr Jerzy Wałaszek

©2020 mgr Jerzy Wałaszek
I LO w Tarnowie

Pojęcie bitu

Logika w języku C++

SPIS TREŚCI
Podrozdziały

Wyrażenia logiczne

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

false – fałsz
true – prawda

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

false = 0
true = 1

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:

C++
// 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;
}
Wynik:
1
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ń:

operator opis przykład
< mniejsze niż a < 10
<= mniejsze lub równe a <= 10
== równe a == 10
!= różne a != 10
>= większe lub równe a >= 10
> większe niż a > 10

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:

operator opis przykład opis
! negacja ! ( a < 10 ) prawdziwe, gdy a >= 10
|| alternatywa ( a == 1 ) || ( a == 2) prawdziwe, gdy a = 1 lub a = 2
&& koniunkcja ( a >= 1 ) && ( a <=2) prawdziwe, gdy a należy do przedziału [ 1, 2 ]

Tabelki tych operatorów są następujące:

negacja
a ! a
false true
true false
alternatywa
a b a || b
false false false
false true true
true false true
true true true
koniunkcja
a b a && b
false false false
false true false
true false false
true true true

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:

( i < 10 ) && ( a [ i ] == 12 )

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.

Na początek:  podrozdziału   strony 

Zastosowanie wyrażeń logicznych

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ść1. W przeciwnym razie wynikiem jest wartość2. 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 ?:

wyrażenie opis
( a > b ) ? a : b większa z dwóch liczb a i b
( a < b ) ? a : b mniejsza z dwóch liczb
( a > 0 ) ? a : - a wartość bezwzględna z a
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 instrukcja1. Jeśli wyrażenie jest fałszywe (ma wartość false lub jest równe zeru), to wykonana zostanie instrukcja2. Zatem w zależności od wyniku wyrażenia logicznego wykonujemy różne instrukcje.

Człon else można pominąć - wtedy instrukcja1 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.

C++
// 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;
}
Wynik:
5 7 3
7

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.

C++
// 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;
}
Wynik:
5

1
5
25
125
625
3125

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ę:

C++
// 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;
}
Wynik:
5

1
5
25
125
625
3125
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ą:

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.

C++
// 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;
}
Wynik:
5

1
5
25
125
625
3125

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.

C++
// 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;
}
Wynik:
1 2 3 4 5 6 7 8 9
Na początek:  podrozdziału   strony 

Zmienne logiczne

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

C++
...
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.

C++
// 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;
}
Wynik:
1

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".

C++
// 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;
}
Wynik:
   8   7   1  10   6   8  10   1   6   0   0   0   3   9   1   7   6   5   4  10   7   1   5   4   0   3   2  10   8  10
   0   7   6   5   4   7  10   1   7   0   7   6   5   6   8   3   5   5   2   6   9   7   3   8   8   6   9   5   8   6
   0   2   5   9   8   7   8   6  10   1  10   5   2   5   7   5   9   8   3   9   7   8   7   0   5   5   9   0   8   9
   2   3  10   9   3   4   6   2   6   6   8   3   0  10   8   9   7   9  10   4   6   0   6   8   6   2   7   9  10  10
   2   6   4   1   8  10   5   6   3   4   6  10   0   3   8   9   7   5   8   3   1   3   6  10   6   0   7   8   7   6
   5   9  10   5   9   1   5   0   6  10   0   9   9   5  10   0   4   4  10   1   5  10   8   5  10   5   8   9   4   7
   2   7   4  10   7   9   6   3   0   7   2  10   4   3   6   4   7   6   3  10   3   1   0   3   3   2   6   8   9  10
   9   5   5   3   7   7   3  10   0   9   8  10   7   2   8   0   9   7   5   3   3  10   6   5   5   3   1   0   8   4
   1   1   8   2   2  10   9   2   9   9   1   5   1   8   2   7   6   0   5   3   6   5   7   4   8   0   8   3   9   5
   0   5   6   4  10   3   9   1   8   8   1  10   8   4   0   5   9   0  10   7   1   1   5   1   8   7  10   2   7   6
   4   6   5   9   5   2   1   8   2   8   7   7   4   8   5   3   5   7   6   6   4   7   3   2   6   2   6  10   5   1
   7   2   2   6   3   1   1   0   8   8   0  10  10  10   9   3   0   3   8   0   9   5   7   0   4   3   7   7   2   4
   4  10   7   4   4   8   4   3   0   5   0   4   3  10   6   9  10   3   7   0   7   6   6   0  10   8   7   4   1   1
   3   1   1   1   3   1   8   7   5  10
Uwaga:

Jeśli w instrukcji warunkowej sprawdzamy zawartość zmiennej logicznej, to nie musimy jej przyrównywać do wartości false lub true :
zamiast wystarczy
if( t == true ) ... if( t ) ...
if( t == false ) ... if( ! t ) ...

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

zamiast stosuje się
a = a || b; a ||= b;
a = a && b; a &&= b;
Na początek:  podrozdziału   strony 

Zespół Przedmiotowy
Chemii-Fizyki-Informatyki

w I Liceum Ogólnokształcącym
im. Kazimierza Brodzińskiego
w Tarnowie
ul. Piłsudskiego 4
©2020 mgr Jerzy Wałaszek

Materiały tylko do użytku dydaktycznego. Ich kopiowanie i powielanie jest dozwolone
pod warunkiem podania źródła oraz niepobierania za to pieniędzy.

Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl

Serwis wykorzystuje pliki cookies. Jeśli nie chcesz ich otrzymywać, zablokuj je w swojej przeglądarce.
Informacje dodatkowe.