1.5 — Wprowadzenie do iostream: cout, cin i endl

W tej lekcji porozmawiamy więcej o std::cout, którego użyliśmy w naszym Witaj świecie! program do wysyłania tekstu Witaj świecie! do konsoli. Zbadamy również, jak uzyskać informacje od użytkownika, które wykorzystamy, aby uczynić nasze programy bardziej interaktywnymi.

Biblioteka wejść/wyjść

Klasa biblioteka wejść/wyjść (biblioteka io) jest częścią standardowej biblioteki C++, która zajmuje się podstawowymi wejściami i wyjściami. Będziemy korzystać z funkcji tej biblioteki, aby pobierać dane wejściowe z klawiatury i wysyłać dane do konsoli. The io część iostream oznacza wejście/wyjście.

Aby skorzystać z funkcjonalności zdefiniowanej w pliku iostream bibliotekę, musimy dołączyć bibliotekę iostream nagłówek u góry dowolnego pliku kodu, który wykorzystuje treść zdefiniowaną w iostream, na przykład:

#include <iostream>

// rest of code that uses iostream functionality here

std::cout

Klasa iostream Biblioteka zawiera kilka predefiniowanych zmiennych, których możemy użyć. Jednym z najbardziej przydatnych jest std::cout, co pozwala nam wysłać dane do konsoli w celu wydrukowania jako tekst. cout oznacza „wyjście znakowe”.

Dla przypomnienia, oto nasza Witaj świecie program:

#include <iostream> // for std::cout

int main()
{
    std::cout << "Hello world!"; // print Hello world! to console

    return 0;
}

W tym programie uwzględniliśmy iostream abyśmy mieli dostęp std::cout. Wewnątrz naszego głównego funkcję, używamy std::cout, wraz z operator wstawiania (<<), aby wysłać tekst Witaj świecie! do konsoli w celu wydrukowania.

std::cout może nie tylko drukować tekst, może także drukować liczby:

#include <iostream> // for std::cout

int main()
{
    std::cout << 4; // print 4 to console

    return 0;
}

Daje to wynik:

4

Można go również użyć do wydrukowania wartości zmiennych:

#include <iostream> // for std::cout

int main()
{
    int x{ 5 }; // define integer variable x, initialized with value 5
    std::cout << x; // print value of x (5) to console
    return 0;
}

Daje to wynik:

5

Aby wydrukować więcej niż jedną rzecz w tym samym wierszu, operator wstawiania (<<) można użyć wielokrotnie w jednej instrukcji w celu połączenia (połączenia) wielu fragmentów danych wyjściowych. Na przykład:

#include <iostream> // for std::cout

int main()
{
    std::cout << "Hello" << " world!";
    return 0;
}

To wykorzystuje << operator dwa razy, pierwszy na wyjściu Hello a następnie do wyjścia world.

W ten sposób program wypisuje:

Hello world!

Oto kolejny przykład, w którym drukujemy zarówno tekst, jak i wartość zmiennej w tej samej instrukcji:

#include <iostream> // for std::cout

int main()
{
    int x{ 5 };
    std::cout << "x is equal to: " << x;
    return 0;
}

Ten program wypisuje:

x is equal to: 5

Użycie std::endl aby wyprowadzić znak nowej linii

Czego spodziewałbyś się, że ten program wydrukuje?

#include <iostream> // for std::cout

int main()
{
    std::cout << "Hi!";
    std::cout << "My name is Alex.";
    return 0;
}

Wynik może Cię zaskoczyć:

Hi!My name is Alex.

Oddzielne instrukcje wyjściowe nie powodują oddzielnych linii wyjściowych na konsoli.

Jeśli chcemy wypisać na konsolę osobne linie wyników, musimy powiedzieć konsoli, aby przeniosła kursor do następnej linii. Możemy to zrobić, wypisując znak nowej linii. A nowa linia to znak lub sekwencja znaków charakterystyczna dla systemu operacyjnego, która przesuwa kursor na początek następnego wiersza.

Jednym ze sposobów wyprowadzenia znaku nowej linii jest wyjście std::endl (co oznacza „linię końcową”):

#include <iostream> // for std::cout and std::endl

int main()
{
    std::cout << "Hi!" << std::endl; // std::endl will cause the cursor to move to the next line
    std::cout << "My name is Alex." << std::endl;

    return 0;
}

Wypisuje:

Hi!
My name is Alex.

std::cout jest buforowany

Rozważ przejażdżkę kolejką górską w swoim ulubionym parku rozrywki. Pasażerowie pojawiają się (według zmiennej stawki) i ustawiają się w kolejce. Okresowo przyjeżdża pociąg i wsiada pasażerów (do maksymalnej pojemności pociągu). Gdy pociąg się zapełni lub upłynie wystarczająca ilość czasu, pociąg odjeżdża z grupą pasażerów i rozpoczyna się podróż. Pasażerowie, którzy nie mogą wsiąść do bieżącego pociągu, czekają na następny.

Ta analogia jest podobna do sposobu, w jaki dane wyjściowe wysyłane do std::cout są zwykle przetwarzane w C++. Instrukcje w naszym programie żądają wysłania danych wyjściowych do konsoli. Jednak te dane wyjściowe zazwyczaj nie są natychmiast wysyłane do konsoli. Zamiast tego żądane dane wyjściowe „uchodzą do kolejki” i są przechowywane w obszarze pamięci przeznaczonym do gromadzenia takich żądań (zwanym a bufor). Okresowo bufor jest opróżniany, co oznacza, że ​​wszystkie dane zgromadzone w buforze są przesyłane do miejsca docelowego (w tym przypadku do konsoli).

Oznacza to również, że jeśli program ulegnie awarii, przerwie działanie lub zostanie wstrzymany (np. w celu debugowania) przed opróżnieniem bufora, żadne dane wyjściowe nadal oczekujące w buforze nie będą wyświetlane.

std::endl vs \n

Użycie std::endl jest często nieefektywne, ponieważ w rzeczywistości wykonuje dwa zadania: wyprowadza znak nowej linii (przenosząc kursor do następnej linii konsoli) i opróżnia bufor (co jest powolne). Jeśli wyślemy wiele wierszy tekstu kończących się na std::endl, otrzymamy wielokrotne opróżnianie, co jest powolne i prawdopodobnie niepotrzebne.

Podczas wysyłania tekstu do konsoli zazwyczaj nie musimy sami jawnie opróżniać bufora. System wyjściowy C++ jest zaprojektowany tak, aby okresowo się samoczynnie opróżniał, a prostsze i wydajniejsze jest pozwolić mu na samoczynne opróżnienie.

Aby wypisać znak nowej linii bez opróżniania bufora wyjściowego, używamy \n (w cudzysłowie pojedynczym lub podwójnym), który jest specjalnym symbolem, który kompilator interpretuje jako znak nowej linii. \n przesuwa kursor do następnej linii konsoli bez powodowania opróżniania, więc zazwyczaj będzie działać lepiej. \n Jest także bardziej zwięzły w pisaniu i można go osadzić w istniejącym tekście w podwójnych cudzysłowach.

Oto przykład użycia \n na kilka różnych sposobów:

#include <iostream> // for std::cout

int main()
{
    int x{ 5 };
    std::cout << "x is equal to: " << x << '\n'; // single quoted (by itself) (conventional)
    std::cout << "Yep." << "\n";                 // double quoted (by itself) (unconventional but okay)
    std::cout << "And that's all, folks!\n";     // between double quotes in existing text (conventional)
    return 0;
}

Wypisuje:

x is equal to: 5
Yep.
And that's all, folks!

Po wywołaniu \n nie jest osadzany w istniejącej linii tekstu w podwójnych cudzysłowach (np. "hello\n"), jest zwykle umieszczany w pojedynczym cudzysłowie ('\n').

Co oznacza „\n”, omówimy bardziej szczegółowo, kiedy przejdziemy do lekcji o znakach (4.11 -- Znaki).

std::cin

std::cin to kolejna predefiniowana zmienna. w iostream podczas gdy std::cout wypisuje dane do konsoli (używając operatora wstawiania << w celu dostarczenia danych), std::cin (co oznacza „wprowadzanie znaków”) odczytuje dane wejściowe z klawiatury. Zwykle używamy operatora wyodrębniania >> w celu umieszczenia danych wejściowych w zmiennej (której można następnie użyć w kolejnym kroku). instrukcje).

#include <iostream>  // for std::cout and std::cin

int main()
{
    std::cout << "Enter a number: "; // ask user for a number

    int x{};       // define variable x to hold user input (and value-initialize it)
    std::cin >> x; // get number from keyboard and store it in variable x

    std::cout << "You entered " << x << '\n';
    return 0;
}

Spróbuj skompilować ten program i uruchomić go samodzielnie. Po uruchomieniu programu w wierszu 5 zostanie wyświetlony komunikat „Wprowadź liczbę: „. Kiedy kod dotrze do wiersza 8, program będzie czekać na wprowadzenie numeru. Po wprowadzeniu liczby (i naciśnięciu klawisza Enter) wprowadzony numer zostanie przypisany do zmiennej x wprowadzono.

Na przykład (wprowadzając wartość 4 jako dane wejściowe):

Enter a number: 4
You entered 4

Jest to łatwy sposób na uzyskanie danych wejściowych z klawiatury od użytkownika i będziemy go używać w wielu naszych przyszłych przykładach.

Tak jak możliwe jest wypisanie więcej niż jednego bitu tekstu w jednym wierszu, możliwe jest również wprowadzenie więcej niż jednej wartości w jednym wierszu:

#include <iostream>  // for std::cout and std::cin

int main()
{
    std::cout << "Enter two numbers separated by a space: ";

    int x{}; // define variable x to hold user input (and value-initialize it)
    int y{}; // define variable y to hold user input (and value-initialize it)
    std::cin >> x >> y; // get two numbers and store in variable x and y respectively

    std::cout << "You entered " << x << " and " << y << '\n';

    return 0;
}

To daje wynik:

Enter two numbers separated by a space: 5 6
You entered 5 and 6

Wprowadzone wartości powinny być oddzielone białymi znakami (spacjami, tabulatorami lub znakami nowej linii).

std::cin jest buforowany

W poprzedniej sekcji zauważyliśmy, że wysyłanie danych jest w rzeczywistości procesem dwuetapowym:

• Dane z każdego żądania wyjściowego są dodawane (na końcu) bufora wyjściowego.
• Później dane z bufora wyjściowego (z przodu) są przesyłane do urządzenia wyjściowego (konsoli).

Podobnie wprowadzanie danych jest również procesem dwuetapowym:

• Pojedyncze znaki wprowadzane jako dane wejściowe są dodawane na końcu bufora wejściowego (wewnątrz std::cin). Klawisz Enter (wciśnięty w celu przesłania danych) jest również przechowywany jako '\n' znakiem.
• Operator wyodrębniania „>>” usuwa znaki z przodu bufora wejściowego i konwertuje je na wartość, która jest przypisana (poprzez przypisanie kopiowania) do powiązanej zmiennej. Zmiennej tej można następnie używać w kolejnych instrukcjach.

Zademonstrujemy to za pomocą następującego programu:

#include <iostream>  // for std::cout and std::cin

int main()
{
    std::cout << "Enter two numbers: ";

    int x{};
    std::cin >> x;

    int y{};
    std::cin >> y;

    std::cout << "You entered " << x << " and " << y << '\n';

    return 0;
}

Ten program wprowadza dane do dwóch zmiennych (tym razem jako osobne instrukcje). Uruchomimy ten program dwukrotnie.

Uruchomienie nr 1: Kiedy napotkany zostanie std::cin >> x; , program będzie czekać na wprowadzenie danych. Wprowadź wartość 4. Dane wejściowe 4\n wchodzi do bufora wejściowego, a wartość 4 jest wyodrębniane do zmiennej x.

Po wywołaniu std::cin >> y; , program ponownie będzie czekać na wejście. Wprowadź wartość 5. Dane wejściowe 5\n wchodzi do bufora wejściowego, a wartość 5 jest wyodrębniane do zmiennej y. Na koniec program wydrukuje You entered 4 and 5.

W tym przebiegu nie powinno być nic zaskakującego.

Przebieg nr 2: Kiedy napotkany zostanie std::cin >> x , program będzie czekać na wprowadzenie danych. Wejdź 4 5. Dane wejściowe 4 5\n przechodzą do bufora wejściowego, ale tylko 4 jest wyodrębniane do zmiennej x (wyodrębnianie zatrzymuje się w spacji).

Po wywołaniu std::cin >> y napotkane, program nie czeka na wejście. Zamiast tego 5 będące nadal w buforze wejściowym są wyodrębniane do zmiennej y. Następnie program wypisuje You entered 4 and 5.

Zauważ, że w drugim uruchomieniu program nie czekał, aż użytkownik wprowadzi dodatkowe dane wejściowe podczas wyodrębniania do zmiennej y , ponieważ w buforze wejściowym znajdowały się już wcześniej dane wejściowe, które można było wykorzystać.

Podstawowy proces wyodrębniania

Oto uproszczony widok działania operatora >> dla danych wejściowych.

1. Jeśli std::cin nie jest w dobrym stanie (np. poprzednie wyodrębnianie nie powiodło się i std::cin nie zostało jeszcze wyczyszczone), nie podjęto próby wyodrębnienia i proces wyodrębniania zostaje przerwany natychmiast.
2. Początkowe białe znaki (spacje, tabulatory i znaki nowej linii na początku bufora) są usuwane z bufora wejściowego. Spowoduje to odrzucenie niewyodrębnionego znaku nowej linii pozostałego z poprzedniej linii wejściowej.
3. Jeśli bufor wejściowy jest teraz pusty, operator >> zaczeka, aż użytkownik wprowadzi więcej danych. Wszelkie początkowe spacje są usuwane z wprowadzonych danych.
4. operator >> następnie wyodrębnia tyle kolejnych znaków, ile się da, aż napotka znak nowego wiersza (reprezentujący koniec wiersza wejściowego) lub znak, który jest nieprawidłowy dla zmiennej, do której wyodrębniana jest zmienna.

Wynik procesu wyodrębniania jest następujący:

• Jeśli wyodrębnianie zostało przerwane w kroku 1, oznacza to, że nie nastąpiła żadna próba wyodrębnienia. Nic więcej się nie dzieje.
• Jeśli w kroku 4 powyżej wyodrębniono jakiekolwiek znaki, wyodrębnienie zakończyło się sukcesem. Wyodrębnione znaki są konwertowane na wartość, która jest następnie kopiowana i przypisana do zmiennej.
• Jeśli w kroku 4 powyżej nie udało się wyodrębnić żadnych znaków, wyodrębnianie nie powiodło się. Obiektowi, do którego jest wyodrębniany, przypisywana jest kopia wartości 0 (od C++ 11), a wszelkie przyszłe wyodrębnienia natychmiast zakończą się niepowodzeniem (dopóki std::cin nie zostanie wyczyszczone).

Wszelkie niewyodrębnione znaki (w tym znaki nowej linii) pozostają dostępne dla następnej próby wyodrębnienia.

Na przykład, biorąc pod uwagę następujący fragment:

int x{};
std::cin >> x;

Oto co dzieje się w trzech różnych przypadkach wprowadzania danych:

• Jeśli użytkownik wpisze 5a i wprowadzi, 5a\n zostanie dodany do bufora. 5 zostanie wyodrębniony, przekonwertowany na liczbę całkowitą i przypisany do zmiennej x. a\n zostanie pozostawiony na wejściu bufor do następnej ekstrakcji.
• Jeśli użytkownik wpisze „b” i wprowadzi, b\n zostanie dodany do bufora. Ponieważ b nie jest prawidłową liczbą całkowitą, nie można wyodrębnić żadnych znaków, więc ekstrakcja zakończyła się niepowodzeniem. Zmienna x zostanie ustawiona na 0, a przyszłe wyodrębnianie zakończy się niepowodzeniem do czasu wyczyszczenia strumienia wejściowego.
• Jeśli std::cin nie jest w dobrym stanie z powodu wcześniejszej nieudanej ekstrakcji, nic się tutaj nie dzieje. Wartość zmiennej x nie ulega zmianie.

W poniższym quizie zbadamy więcej przypadków.

operator<< vs operator>>

Nowi programiści często mylą std::cin, std::cout, operator wstawiania (<<) i operator ekstrakcji (>>). Oto prosty sposób na zapamiętanie:

• std::cin i std::cout zawsze kieruj się po lewej stronie operatora.
• std::cout służy do wyprowadzania wartości (cout = znak).
• std::cin jest używany do uzyskiwania wartości wejściowej (cin = wprowadzanie znaku).
• << jest używana z std::cout i pokazuje kierunek, w którym poruszają się dane. std::cout << 4 przemieszcza się wartość 4 do konsoli.
• >> jest używana z std::cin i pokazuje kierunek, w którym poruszają się dane. std::cin >> x przenosi wartość wprowadzoną przez użytkownika z klawiatury do zmiennej x.

O operatorach porozmawiamy więcej na lekcji 1.9 -- Wprowadzenie do literałów i operatorów.

Czas quizu

Pytanie nr 1

Rozważmy następujący program, którego użyliśmy powyżej:

#include <iostream>  // for std::cout and std::cin

int main()
{
    std::cout << "Enter a number: "; // ask user for a number
    int x{}; // define variable x to hold user input
    std::cin >> x; // get number from keyboard and store it in variable x
    std::cout << "You entered " << x << '\n';

    return 0;
}

Program oczekuje od ciebie wprowadzenia wartości całkowitej, ponieważ zmienna x w którą zostaną wprowadzone dane wejściowe użytkownika, jest zmienną całkowitą.

Uruchom ten program wiele razy i opisz wynik, który zostanie wyświetlony po wprowadzeniu następujących typów danych wejściowych:

a) Litera, np. as h.

Pokaż rozwiązanie

b) Liczba z częścią ułamkową (np. 3.2). Wypróbuj liczby z częściami ułamkowymi mniejszymi niż 0,5 i większymi niż 0,5 (np. 3.2 i 3.7).

Pokaż rozwiązanie

c) Mała ujemna liczba całkowita, taka jak -3.

Pokaż rozwiązanie

d) Słowo takie jak Hello.

Pokaż rozwiązanie

e) Naprawdę duża liczba (co najmniej 3) miliard).

Pokaż rozwiązanie

f) Mała liczba, po której następują kilka liter, np. 123abc.

Pokaż rozwiązanie

g) Kilka liter, po których następuje mała liczba, np. abc123.

Pokaż rozwiązanie

h) +5 (trzy spacje, po których następuje znak plus i znak 5).

Pokaż rozwiązanie

i) 5b6.

Pokaż rozwiązanie

Pytanie nr 2

Poproś użytkownika o wprowadzenie trzech wartości. Program powinien następnie wydrukować te wartości. Dodaj odpowiedni komentarz powyżej funkcji main().

Program powinien odpowiadać następującym wynikom (jeśli jest uruchamiany z wartościami wejściowymi 4, 5, I 6):

Enter three numbers: 4 5 6
You entered 4, 5, and 6.

Pokaż wskazówkę

Pokaż wskazówkę

Pokaż rozwiązanie

#include <iostream>

// Asks the user to enter three values and then print those values as a sentence.
int main()
{
    std::cout << "Enter three numbers: ";

    int x{};
    int y{};
    int z{};
    std::cin >> x >> y >> z;

    std::cout << "You entered " << x << ", " << y << ", and " << z << ".\n";

    return 0;
}