Strumienie danych to podstawowy mechanizm używany w języku C++ do obsługi wejścia i wyjścia. Pozwalają na płynną wymianę danych między programem a użytkownikiem oraz innymi urządzeniami, takimi jak pliki czy sieci. W tej lekcji omówimy szczegółowo, jak działają standardowe strumienie wejścia (stdin), wyjścia (stdout) i strumienie błędów (stderr), a także jak używać ich efektywnie w różnych sytuacjach programistycznych.

Co to są strumienie danych?

Strumienie danych to abstrakcje, które umożliwiają sekwencyjne przesyłanie danych do i z programu. Strumienie w C++ mogą działać w dwóch głównych trybach:

• Wejście (input): Odczyt danych, na przykład od użytkownika za pomocą klawiatury lub z pliku.
• Wyjście (output): Wysyłanie danych, na przykład wyświetlanie na ekranie lub zapis do pliku.

W języku C++ standardowe strumienie są zarządzane przez bibliotekę <iostream>, która udostępnia klasy cin, cout i cerr do obsługi operacji wejścia i wyjścia.

Standardowe wejście: cin

Strumień cin jest używany do odczytu danych wejściowych od użytkownika. Działa poprzez odczytywanie danych z wejścia standardowego, czyli najczęściej z klawiatury. Możemy używać cin w połączeniu z operatorem >> do odczytu różnych typów danych, takich jak liczby całkowite, zmiennoprzecinkowe, ciągi znaków i inne.

Przykład odczytu danych od użytkownika

#include <iostream>

int main() {
    int liczba;
    std::cout << "Podaj liczbę: ";
    std::cin >> liczba; // Odczyt liczby całkowitej od użytkownika
    std::cout << "Wprowadziłeś: " << liczba << std::endl;
    return 0;
}

W powyższym przykładzie używamy std::cin do odczytu liczby całkowitej, a następnie wyświetlamy ją za pomocą std::cout. Operator >> odczytuje dane do zmiennej liczba i automatycznie pomija białe znaki, takie jak spacje, tabulatory czy znaki nowej linii.

Standardowe wyjście: cout

Strumień cout jest używany do wysyłania danych wyjściowych na ekran. Działa w połączeniu z operatorem <<, który wypisuje dane w sekwencyjny sposób. Możemy używać cout do wyświetlania tekstu, liczb oraz innych danych, formatując je w czytelny sposób.

Przykład wyświetlania danych

#include <iostream>

int main() {
    std::cout << "Witaj w świecie C++!" << std::endl;
    std::cout << "To jest przykład użycia strumienia cout." << std::endl;
    return 0;
}

W powyższym przykładzie używamy std::cout do wyświetlania tekstu na ekranie. Operator << wysyła dane do strumienia, a std::endl dodaje znak nowej linii i opróżnia bufor, co oznacza, że dane są natychmiast wyświetlane.

Standardowy strumień błędów: cerr

Strumień cerr służy do wyświetlania komunikatów o błędach. Działa podobnie jak cout, ale jest używany specjalnie do obsługi błędów. cerr jest domyślnie niebuforowany, co oznacza, że dane są wyświetlane natychmiast po wysłaniu, bez oczekiwania na opróżnienie bufora.

Przykład użycia cerr

#include <iostream>

int main() {
    std::cerr << "Wystąpił błąd podczas działania programu." << std::endl;
    return 0;
}

W powyższym przykładzie używamy std::cerr do wyświetlenia komunikatu o błędzie. Dzięki temu użytkownik może natychmiast zobaczyć problem, co jest szczególnie przydatne podczas debugowania.

Formatowanie wyjścia

C++ oferuje wiele sposobów formatowania danych wyjściowych, aby były bardziej czytelne. Możemy używać manipulatorów, takich jak std::setw, std::setprecision, std::fixed i innych, które są dostępne w bibliotece <iomanip>.

Przykład formatowania danych wyjściowych

#include <iostream>
#include <iomanip>

int main() {
    double liczba = 123.456789;
    std::cout << "Liczba bez formatowania: " << liczba << std::endl;
    std::cout << "Liczba z dwoma miejscami po przecinku: " 
              << std::fixed << std::setprecision(2) << liczba << std::endl;
    return 0;
}

W powyższym przykładzie używamy manipulatorów std::fixed i std::setprecision, aby wyświetlić liczbę z dwoma miejscami po przecinku. To ułatwia prezentację danych w czytelny sposób, na przykład w raportach finansowych czy naukowych.

Buforowanie strumieni

Strumienie w C++ są domyślnie buforowane, co oznacza, że dane są przechowywane w buforze, zanim zostaną faktycznie wyświetlone lub zapisane. To zwiększa wydajność, ponieważ zmniejsza liczbę operacji wejścia/wyjścia. Jednak w niektórych sytuacjach możemy chcieć ręcznie opróżnić bufor, używając std::flush lub std::endl.

Przykład opróżniania bufora

#include <iostream>

int main() {
    std::cout << "Dane w buforze..." << std::flush; // Opróżnienie bufora
    // Dane są teraz wyświetlone natychmiast
    return 0;
}

W tym przykładzie używamy std::flush, aby natychmiast opróżnić bufor i wyświetlić dane. Jest to przydatne, gdy chcemy mieć pewność, że dane zostaną natychmiast wysłane, na przykład podczas logowania ważnych informacji o stanie programu.

Przekierowanie strumieni

W C++ możemy przekierować standardowe strumienie do plików lub innych urządzeń. To pozwala na zapis wyników programu do pliku zamiast wyświetlania ich na ekranie, co jest użyteczne w przypadku generowania raportów lub przechowywania danych wyjściowych do późniejszej analizy.

Przykład przekierowania strumienia wyjściowego

#include <fstream>
#include <iostream>

int main() {
    std::ofstream plik("wyniki.txt");
    if (!plik) {
        std::cerr << "Nie można otworzyć pliku!" << std::endl;
        return 1;
    }
    std::cout.rdbuf(plik.rdbuf()); // Przekierowanie cout do pliku

    std::cout << "To jest zapisane w pliku wyniki.txt" << std::endl;
    plik.close();
    return 0;
}

W powyższym przykładzie przekierowujemy std::cout do pliku wyniki.txt, używając metody rdbuf(). Dzięki temu dane wyjściowe są zapisywane w pliku zamiast na ekranie.

Podsumowanie

Strumienie danych w C++ są niezwykle wszechstronne i umożliwiają efektywną obsługę wejścia i wyjścia. Używanie cin, cout i cerr pozwala na płynną interakcję z użytkownikiem oraz obsługę błędów. Zrozumienie, jak działa buforowanie i formatowanie danych wyjściowych, a także umiejętność przekierowania strumieni, są kluczowe dla tworzenia zaawansowanych i elastycznych aplikacji. Dzięki tej wiedzy będziesz w stanie projektować programy, które są wydajne, czytelne i łatwe w obsłudze.

Następna lekcja ==> Zaawansowane techniki programistyczne