4,9 — Wartości logiczne

W prawdziwym życiu często zadaje się pytania lub ktoś im zadaje pytania, na które można odpowiedzieć „tak” lub „nie”. „Czy jabłko jest owocem?” Tak. „Czy lubisz szparagi?” Nie.

Rozważmy teraz podobne stwierdzenie, na które można odpowiedzieć „prawda” lub „fałsz”: „Jabłka są owocem”. To oczywiście prawda. A może „Lubię szparagi”. Całkowicie fałszywe (fuj!).

Tego rodzaju zdania, które mają tylko dwa możliwe wyniki: tak/prawda lub nie/fałsz, są tak powszechne, że wiele języków programowania zawiera specjalny typ do radzenia sobie z nimi. Typ ten nazywany jest typem Boolean (uwaga: w języku angielskim wartość Boolean jest poprawnie pisana wielką literą, ponieważ nazwa pochodzi od jej wynalazcy, George'a Boole'a).

Zmienne logiczne

Zmienne logiczne to zmienne, które mogą mieć tylko dwie możliwe wartości: true, I false.

Aby zadeklarować zmienną boolowską, używamy słowo kluczowe bool.

bool b;

Aby zainicjować lub przypisać true lub false wartość do zmiennej logicznej, używamy słów kluczowych true i false.

bool b1 { true };
bool b2 { false };
b1 = false;
bool b3 {}; // default initialize to false

Tak jak jednoargumentowy operator minus (-) może zostać użyty do utworzenia liczby całkowitej ujemnej, operator logiczny NOT (!) może zostać użyty do odwrócenia wartości logicznej od true Do false lub false Do true:

bool b1 { !true }; // b1 will be initialized with the value false
bool b2 { !false }; // b2 will be initialized with the value true

Wartości logiczne nie są w rzeczywistości przechowywane w zmiennych boolowskich, ponieważ słowa „true” lub „fałszywe”. Zamiast tego są one zapisywane jako wartości całkowite: true jest zapisywane jako liczba całkowita 1, I false jest zapisywane jako liczba całkowita 0. Podobnie, gdy oceniane są wartości logiczne, w rzeczywistości nie są one oceniane jako „prawda” lub „fałsz”. Oceniają liczby całkowite 0 (fałsz) lub 1 (prawda). Ponieważ wartości logiczne przechowują wartości całkowite, są one uważane za typ całkowity.

Drukowanie wartości logicznych

Kiedy drukujemy wartości logiczne, std::cout wypisuje 0 for false, I 1 for true:

#include <iostream>

int main()
{
    std::cout << true << '\n'; // true evaluates to 1
    std::cout << !true << '\n'; // !true evaluates to 0

    bool b {false};
    std::cout << b << '\n'; // b is false, which evaluates to 0
    std::cout << !b << '\n'; // !b is true, which evaluates to 1
    return 0;
}

Wyjścia:

1
0
0
1

Użyj std::boolalpha print true lub false

Jeśli chcesz std::cout print true lub false zamiast 0 lub 1, możesz wydrukować std::boolalpha. Nie generuje to niczego, ale manipuluje sposobem std::cout wyprowadzaniem bool wartości.

Oto przykład:

#include <iostream>

int main()
{
    std::cout << true << '\n';
    std::cout << false << '\n';

    std::cout << std::boolalpha; // print bools as true or false

    std::cout << true << '\n';
    std::cout << false << '\n';
    return 0;
}

Wypisuje:

1
0
true
false

Możesz użyć std::noboolalpha aby to ponownie wyłączyć.

Konwersja liczby całkowitej na wartość logiczną

W przypadku korzystania z inicjalizacji jednolitej możesz zainicjować zmienną za pomocą liczby całkowitej literały 0 (dla false) i 1 (dla true) (ale naprawdę powinieneś używać zamiast tego false i true ). Inne literały całkowite powodują błędy kompilacji:

#include <iostream>

int main()
{
	bool bFalse { 0 }; // okay: initialized to false
	bool bTrue  { 1 }; // okay: initialized to true
	bool bNo    { 2 }; // error: narrowing conversions disallowed

	std::cout << bFalse << bTrue << bNo << '\n';
	
	return 0;
}

Jednak w każdym kontekście, w którym liczba całkowita może zostać przekonwertowana na wartość logiczną, liczba całkowita 0 jest konwertowana na false, a każda inna liczba całkowita jest konwertowana na true.

#include <iostream>

int main()
{
	std::cout << std::boolalpha; // print bools as true or false

	bool b1 = 4 ; // copy initialization allows implicit conversion from int to bool
	std::cout << b1 << '\n';

	bool b2 = 0 ; // copy initialization allows implicit conversion from int to bool
	std::cout << b2 << '\n';

	return 0;
}

Wypisuje:

true
false

Uwaga: bool b1 = 4; może wygenerować ostrzeżenie. Jeśli tak, będziesz musiał wyłączyć traktowanie ostrzeżeń jako błędów, aby skompilować przykład.

Wprowadzanie wartości logicznych

Wprowadzanie wartości logicznych za pomocą std::cin czasami powoduje problemy dla nowych programistów.

Rozważ następujący program:

#include <iostream>

int main()
{
	bool b{}; // default initialize to false
	std::cout << "Enter a boolean value: ";
	std::cin >> b;
	std::cout << "You entered: " << b << '\n';

	return 0;
}

Enter a Boolean value: true
You entered: 0

Czekaj, co?

Domyślnie std::cin akceptuje tylko wprowadzanie numeryczne dla wartości logicznych zmienne: 0 Jest false, I 1 Jest true. Każda inna wartość liczbowa zostanie zinterpretowana jako true i spowoduje std::cin przejście w tryb awaryjny. Każda wartość nieliczbowa zostanie zinterpretowana jako false i spowoduje std::cin wejście w tryb awaryjny.

W tym przypadku, ponieważ wprowadziliśmy true, std::cin cichą awarię i ustawiliśmy b Do false. W związku z tym, gdy std::cout drukuje wartość dla b, drukuje 0.

Aby umożliwić std::cin akceptację słów false i true jako danych wejściowych, należy najpierw wprowadzić dane do std::boolalpha:

#include <iostream>

int main()
{
	bool b{};
	std::cout << "Enter a boolean value: ";

	// Allow the user to input 'true' or 'false' for boolean values
	// This is case-sensitive, so True or TRUE will not work
	std::cin >> std::boolalpha;
	std::cin >> b;

	// Let's also output bool values as `true` or `false`
	std::cout << std::boolalpha;
	std::cout << "You entered: " << b << '\n';

	return 0;
}

Jednakże, gdy std::boolalpha jest włączone do wprowadzania danych, wartości liczbowe nie będą już akceptowane (oceniają do false i powodują przejście std::cin w tryb awarii).

Zauważ, że std::cin >> std::boolalpha; do wprowadzania wartości bool używamy jako true lub false, I std::cout << std::boolalpha; a do wyprowadzania wartości bool jako true lub false. Są to niezależne elementy sterujące, które można oddzielnie włączyć (za pomocą std::boolalpha) lub wyłączyć (za pomocą std::noboolalpha).

Zwracane wartości logiczne

Wartości logiczne są często używane jako wartości zwracane przez funkcje sprawdzające, czy coś jest prawdą, czy nie. Nazwy takich funkcji zazwyczaj rozpoczynają się od słowa Jest (np. isEqual) lub has (np. hasCommonDivisor).

Rozważ następujący przykład, który jest dość podobny do powyższego:

#include <iostream>

// returns true if x and y are equal, false otherwise
bool isEqual(int x, int y)
{
    return x == y; // operator== returns true if x equals y, and false otherwise
}

int main()
{
    std::cout << "Enter an integer: ";
    int x{};
    std::cin >> x;

    std::cout << "Enter another integer: ";
    int y{};
    std::cin >> y;

    std::cout << std::boolalpha; // print bools as true or false
    
    std::cout << x << " and " << y << " are equal? ";
    std::cout << isEqual(x, y) << '\n'; // will return true or false

    return 0;
}

Oto wynik dwóch uruchomień tego programu:

Enter an integer: 5
Enter another integer: 5
5 and 5 are equal? true

Enter an integer: 6
Enter another integer: 4
6 and 4 are equal? false

Jak to działa pracować? Najpierw wczytujemy wartości całkowite dla x i y. Następnie oceniane jest wyrażenie isEqual(x, y) . W pierwszym uruchomieniu skutkuje to wywołaniem funkcji isEqual(5, 5). Wewnątrz tej funkcji dokonywana jest ocena 5 == 5 , w wyniku której powstaje wartość true. Wartość true jest zwracana do wywołującego w celu wydrukowania przez std::cout. W drugim uruchomieniu wywołanie isEqual(6, 4) zwraca wartość false.

Wartości logiczne wymagają trochę przyzwyczajenia, ale gdy już się nimi zajmiesz, są całkiem odświeżające w swojej prostocie! Wartości logiczne również stanowią ogromną część języka — będziesz ich używać częściej niż wszystkich innych podstawowych typów razem wziętych!

Będziemy kontynuować naszą eksplorację wartości logicznych w następnej lekcji.