Odczyt z pliku.
Umiemy już zapisać dane do pliku tekstowego więc przyszedł czas na odczyt danych tych danych. Skoro przed chwilą napisaliśmy program do zapisu danych to pewnie wystarczy trochę go tylko zmodyfikować/przerobić na odczyt danych. Odpowiedź brzmi tak i właśnie taką modyfikację zaraz zrobimy. Przypomnienie listingu dotyczącego zapisu danych do pliku.

Listing

#include <iostream>
#include <fstream>

using namespace std;

string slowkoen, slowkopl;

int main()
{
    fstream moj_plik;
    moj_plik.open("zwierzeta.txt",ios::out | ios::app);

    cout << "Slowko angielskie: ";
    cin >> slowkoen;
    cout << "Polskie tlumaczenie: ";
    cin >> slowkopl;

    moj_plik << slowkoen << endl;
    moj_plik << slowkopl << endl;
    cout << "Slowka zapisane" << endl;

    moj_plik.close();

    return 0;
}

Zaczniemy od zmodyfikowania linii która mówi w jakim trybie otwieramy nasz plik, czy do zapisu czy do odczytu? Skoro atrybut ios::out funkcji open() mówił o tym, że otwieramy plik do zapisu to wystarczy go zmodyfikować na postać ios::in. Atrybut ios::app w ogóle usuwamy bo do naszego zadania nie jest on w ogóle potrzebny. Czyli linia dotycząca dostępu do pliku będzie wyglądała tak.

moj_plik.open( "zwierzeta.txt" , ios::in );

Dobrą praktyką jest sprawdzenie, czy z plikiem jest wszystko w porządku czy nie jest np. uszkodzony? Jeżeli będziemy chcieli odczytać jakieś dane z uszkodzonego pliku, nasz program zakończy się błędem. Do tego celu służy funkcja good(). A sprawdzenie będzie wyglądało tak.

Listing

    if(moj_plik.good()==false)
    {
        cout << "Plik jest uszkodzony!" << endl; // funkcja good() zwrocila falsz
    }
    else
    {
        cout << "Plik jest poprawny!" << endl; // funkcja good() zwrocila prawde
    } 

Funkcja good() zwróci nam wartość fałsz jeżeli plik będzie uszkodzony lub wartość prawda jeżeli z plikiem będzie wszystko OK. Jakby się tak zastanowić to w przypadku poprawnego pliku nie ma potrzeby informowania o tym fakcie użytkownika. Zamiast komunikatu o poprawnym pliku w części else{} będziemy umieszczać kod, który powie komputerowi co ma zrobić w przypadku kiedy z plikiem jest wszystko w porządku.
Skoro z plik jest OK to teraz zamiast zapisywać dane do pliku musimy je odczytać. Do tego celu służy funkcja getline(). Dla tej funkcji podajemy dwa parametry. Pierwszy to do którego pliku chcemy się odwołać (zmienna plikowa), a w drugim (po przecinku) określamy gdzie chcemy zapisać odczytane dane z pliku. Żeby mieć gdzie zapisywać dane z pliku musimy utworzyć zmienną do której będziemy je zapisywali. Stworzymy więc sobie wcześniej zmienną string linia; o typu string (pomiędzy using namespace … funkcją main() ).

string linia;

a następnie w części else{} naszego if-a wrzucimy kod z funkcją getline().

getline(moj_plik, linia);

W tym momencie nasz kod wygląda tak.

Listing

#include <iostream>
#include <fstream>

using namespace std;

string slowkoen, slowkopl;
string linia;

int main()
{
    fstream moj_plik;
    moj_plik.open("zwierzeta.txt",ios::in);

    if(moj_plik.good()==false)
    {
        // funkcja good() zwrocila falsz, blad odczytu
        cout << "Blad odczytu pliku!";
    }
    else
    {
        // funkcja good() zwrocila prawde, czyli z plikiem wszysto OK
        getline(moj_plik,linia);
        cout << linia << endl;
    }

    moj_plik.close();

    return 0;
}

Jak uruchomimy nasz program to zobaczymy na ekranie słówko cat.

Dlaczego tylko słówko cat ? Otóż dlatego, że funkcja getline() pobrała (odczytała) pierwszą linię z naszego pliku i tyle, na razie niczego więcej nie oprogramowaliśmy. Więc, co zrobić żeby można było „przemieszczać” się pomiędzy poszczególnymi liniami?
Każdorazowe wywołanie funkcji getline() skutkuje odczytem aktualnej linii (zaczynając od początku pliku) i przejściem do kolejnej, czyli przy drugim wywołaniu tej funkcji odczytamy drugą linię z pliku itd. W zależności jakie dane odczytujesz, co chcesz z nimi później zrobić i czy wiesz ile plik ma linii, dobierasz metodę do odczytu pliku, ale cały czas korzystasz z funkcji getline(). Weźmy na warsztat nasz plik. Wiemy, że nasz plik przechowuje w kolejnych liniach (na przemian) słówko angielskie i jego polskie tłumaczenie. Aby odczytać dane z pliku moglibyśmy wrzucić poszczególne słówka do tablicy. Wtedy mamy sytuację, że pod indeksami parzystymi (pamiętaj numeracja tablic zaczyna się od 0 a nie od 1) będziemy mieli słówka angielskie a pod indeksami nieparzystymi będziemy mieli słówka polskie. Zawsze polskie tłumaczenie danego angielskiego słówka będzie o indeksie o jeden większym niż słówko angielskie. Oczywiście pomysłów na odczytanie jest pewnie więcej np. wrzucić słówka angielskie do jednej tablicy a polskie od drugiej, wtedy komórki o takim samym indeksie o obu tablicach będą ze sobą związane (słówko angielskie i polskie tłumaczenie). Można też wrzucić słówka do tablicy wielowymiarowej itd. Teraz zajmiemy się tym rozwiązaniem o którym mówiłem na początku, wrzucimy słówka ciągiem do jednej tablicy a później je wypiszemy na ekranie ale już będziemy je pobierać z tablicy a nie z pliku. W tablicach jest tylko jedno ograniczenie, od razu musimy podać długość tej tablicy. Oczywiście możemy to obejść obliczając przed deklaracją tablicy ilość linii w pliku ale nie jest to tematem tej lekcji więc od razu przy deklaracji tablicy wpiszemy odpowiednią jej długość. No to do dzieła.
Do naszego pliku zwierzęta.txt dopisałem jeszcze trzy pozycje, więc w tym momencie mamy już 5 zwierząt: kot, piec, małpa, mysz i koń.
Na początku deklarujemy tablicę, do której wrzucimy słówka z pliku. Zwierząt jest 5 więc słówek jest 10 i tylu elementowej tablicy będziemy potrzebować. Oczywiście tablica będzie przechowywała stringi więc musi być typu string.

string words_all[10];

Teraz standardowa procedura: deklaracja zmiennej plikowej i otwarcie pliku do odczytu.

Listing

// tworzymy zmienną plikową
    fstream file;

    // otwieramy plik do odczytu
    file.open("zwierzeta.txt",ios::in);

    // good() <- sprawdza czy plik OK
    if(file.good()==false)
    {
        // plik NIE jest OK
    }
    else
    {
        // jeżeli plik nie jest uszkodzony to tutaj piszemy dalej kod
    }

Jeżeli w ten sposób „sprawdzamy” czy z plikiem wszystko OK to dalej kod piszemy wewnątrz części else{}. Można by to było oprogramować trochę inaczej.

if(file.good()==false)
    {
        // plik NIE jest OK
       exit(0);  // ale wtedy na górze musisz dodać bibliotekę #include <cstdlib>
    }
    // wtedy nie potrzebujesz części else{}
    // i kod piszesz normalnie poza if-em

Jaką robotę robi tutaj funkcja exit()? Funkcja ta służy do zamknięcia programu (wyjścia z programu). Zwróć uwagę, że uruchamiamy ją (czyli wychodzimy z programu) w momencie kiedy coś jest nie tak z plikiem. Jeżeli np. plik jest uszkodzony nie ma sensu żeby komputer dalej przetwarzał kod i najlepiej wtedy zakończyć program. Wybór metody zależy od Ciebie.
Kod który odczytuje dane z pliku i „wrzuca” je do tablicy poniżej.

// i <- licznik do for'a
        int i=0;
        for( i = 0; i <= 9; i++ )
        {
            getline(file,line);
            words_all[i] = line;
        }

Pętlę for już znamy więc wiemy jak działa. Dlaczego w drugim parametrze w pętli for jest i<=9 ? Skoro numeracja indeksów w tablicy zaczyna się od 0 to od takiej wartości licznika i musimy rozpocząć. Wtedy drugim warunkiem musi być i<=9 bo chcemy wrzucić 10 elementów do tablicy a zaczęliśmy liczyć od 0 więc musimy skończyć na wartości 9.
Znamy już funkcję getline(); i wiemy, że pobiera ona „aktualną” linię do zmiennej line.
Teraz zaczyna się clou sprawy, czyli wrzucanie tych danych do tablicy. Spójrz na zapis.

words_all[i] = line;

Wartość zmiennej line (w danym cyklu pętli for) będziemy wrzucali do kolejnych komórek tablicy words_all[]. Licznik i posłuży nam do odwoływania się do kolejnych elementów (komórek) tablicy. Przy pierwszym cyklu pętli for zmienna i będzie miała wartość 0, czyli powyższe polecenie przyjmie postać words_all[0] =line; co oznacza, że wartość (linia) odczytaną z pliku wrzucimy do komórki o zerowym indeksie w tablicy words_all[]. Przy drugim cyklu, dzięki funkcji getline() w zmiennej line będziemy już mieli odczytaną drugą linię z pliku. Wtedy licznik i dla pętli for przybierze już wartość 1, czyli drugą linię z pliku zapiszemy do komórki o indeksie 1 w tablicy words_all[] itd. Sam widzisz, że to nie jest takie proste. Pętla wykona się 10 razy i wszystkie linie (słówka) z pliku znajdą się w naszej tablicy.
Teraz wystarczy tylko wyświetlić po kolei słówka na ekranie ale już nie z pliku tylko z tablicy, gdzie przed chwilką „wrzuciliśmy” dane z pliku.

Listing

// Odczyt slowek z tablicy
        cout << "Slowka z tablicy words_all:" << endl;
        for( i = 0; i <= 9; i++ )
        {
            cout << words_all[i] << endl;
        }

Sam widzisz, że odczyt z tablicy robimy dokładnie według tego samego schematu gdy zapisywaliśmy do niej dane z tą różnicą że tutaj wywołujemy funkcję cout i odwołujemy się (za każdym „obrotem” pętli) do kolejnych komórek tablicy words_all[].
Cały kod poniżej.

Listing

#include <iostream>
#include <fstream>
#include <cstdlib>
using namespace std;

string slowkoen, slowkopl;
string linia;

int main()
{
    // deklarujemy tablice na slowka z pliku
    string words_all[10]; 
   // zm. do zapisywania linii odczytanych w pliku
    string line;

    // tworzymy zmienna plikowa
    fstream file;
    
    // otwieramy plik do odczytu
    file.open("zwierzeta.txt",ios::in);

    // good() <- sprawdza czy plik OK
    if(file.good()==false)
    {
        cout << "Blad odczytu pliku!";
        exit(0);
    }
    else
    {
        // i <- licznik do for'a
        int i=0;
        for( i = 0; i <= 9; i++ )
        {
            getline(file,line);
            words_all[i] = line;
        }

        // Odczyt slowek z tablicy
        cout << "Slowka z tablicy words_all:" << endl;
        for( i = 0; i <= 9; i++ )
        {
            cout << words_all[i] << endl;
        }
    }
    file.close();
    return 0;
}