Citirea și afișarea șirurilor

Pentru un tablou char s[101], cin >> s citește un cuvânt și se oprește la primul spațiu alb; cin.getline(s, 101) citește o linie întreagă de cel mult 100 de caractere. Dacă intrarea este „Ana are mere”, prima variantă produce „Ana”, iar a doua produce „Ana are mere”. Al 101-lea loc din tablou păstrează terminatorul '\0'.

Pentru un tablou char s[101], citirea cu operatorul >> ignoră spațiile de la început, copiază caracterele până la primul spațiu alb (spațiu, tab sau linie nouă) și adaugă terminatorul, deci citește un singur cuvânt. Citirea unei linii cu spații se face prin cin.getline(s, 101): încap cel mult 100 de caractere și terminatorul; restul liniei, dacă este mai lungă, nu este citit. Dacă linia precedentă a fost citită cu cin >> n, caracterul de sfârșit de linie al numărului rămâne în flux și un getline imediat ar citi o linie goală. Se elimină cu cin.get() sau cu cin.ignore(1000, '\n'), care ignoră până la 1000 de caractere sau până la prima linie nouă. Afișarea cu cout << s scrie caracterele până la terminator și nu adaugă singură un rând nou.

Exemplul 1 — un număr, apoi o linie.

#include <iostream>
using namespace std;
int main() {
    int n;
    char s[101];
    cin >> n;
    cin.get();
    cin.getline(s, 101);
    cout << n << " | " << s;
    return 0;
}

Pentru intrarea formată din liniile 3 și Ana are mere, ieșirea este 3 | Ana are mere. Instrucțiunea cin.get() consumă sfârșitul liniei lui 3. Fără ea, getline ar citi restul liniei cu numărul, adică un șir gol, iar ieșirea ar fi 3 | .

Exemplul 2 — cuvânt sau linie. Din intrarea Ana are mere, instrucțiunea cin >> s pune în s textul Ana; următoarea citire cu >> ar da are, apoi mere. Cu getline, tot textul Ana are mere ajunge în s. Dacă linia are mai mult de 100 de caractere, getline citește doar primele 100, iar fluxul intră în stare de eroare (vezi cazurile-limită de mai jos).

Exemplul 3 — citirea mai multor linii. Se citește un număr $k$ și apoi $k$ linii de text, fiecare afișată cu lungimea ei. Pentru intrarea 2, ab cd, x rezultatul este: ab cd 5 și x 1, deoarece spațiul din interiorul liniei face parte din text. Fiecare citire de linie se face după ce s-a eliminat sfârșitul liniei anterioare.

int k;
char s[101];
cin >> k;
cin.ignore(1000, '\n');
for (int i = 0; i < k; ++i) {
    cin.getline(s, 101);
    cout << s << ' ' << strlen(s) << '\n';
}

Secvența, completată cu #include <cstring>, afișează liniile ab cd 5 și x 1. Lungimea 5 numără litera a, litera b, spațiul, litera c și litera d.

Obiectul std::string se citește la fel: cin >> text ia un cuvânt, iar getline(cin, text) ia o linie întreagă, de orice lungime, fără limită fixă. Citirea unui text până la sfârșitul intrării se scrie while (getline(cin, text)), ciclu care se oprește când nu mai există linii. Pentru un tablou char, ciclul corespunzător este while (cin.getline(s, 101)).

Exemplul 4 — prelucrarea unei linii citite. Se citește linia Ana are mere și se numără spațiile din ea. Dacă cuvintele sunt separate prin câte un singur spațiu, numărul de cuvinte este numărul de spații plus 1.

char s[101];
cin.getline(s, 101);
int spatii = 0;
for (int i = 0; s[i] != '\0'; ++i)
    if (s[i] == ' ')
        ++spatii;
cout << strlen(s) << ' ' << spatii + 1;

Ciclul se oprește la terminator. Textul are 12 caractere (3 + 1 + 3 + 1 + 4), dintre care 2 sunt spații, deci se afișează 12 3. Formula nu mai este corectă dacă linia are spații multiple sau spații la margini: pentru Ana are (două spații între cuvinte) ea ar da 3 cuvinte în loc de 2. Numărarea corectă ia în calcul doar trecerile de la un spațiu la o literă.

Cazuri-limită. O linie goală este citită ca un șir vid. Dacă linia are mai multe caractere decât încap, getline copiază în tablou primele 100, iar fluxul cin intră în stare de eroare: citirile următoare nu mai extrag nimic până la apelul cin.clear(). De aceea limita declarată trebuie aleasă după cea mai lungă linie posibilă din enunț.

La citirea mixtă, urmărește ce caractere rămân în flux. După cin >> n, separatorul de linie rămâne; un getline imediat poate citi o linie goală. cout afișează exact textul și separatorii indicați și nu adaugă automat un rând nou. Când un fragment citește cu >> un cuvânt, spațiile inițiale sunt ignorate, deci intrarea Ana produce tot Ana; getline, în schimb, păstrează spațiile de la începutul liniei. Dacă după număr mai există spații pe aceeași linie, o singură instrucțiune cin.get() nu le elimină pe toate, iar cin.ignore(1000, '\n') o face. Verifică și dimensiunea declarată: un getline cu limita 101 într-un tablou char s[50] poate scrie dincolo de tablou.

Exemplu în formatul examenului. Se citesc liniile 12 și ab cd. Ce se afișează în urma executării secvenței de mai jos?

int n;
char s[100];
cin >> n;
cin.getline(s, 100);
cout << n << '|' << s << '|';

• a) 12|ab cd|
• b) 12||
• c) 12|ab|
• d) 12 ab cd

Răspunsul corect este b). Operatorul >> citește numărul 12 și se oprește înaintea sfârșitului de linie. Apelul getline citește restul acelei linii, care este gol, și se oprește la caracterul de linie nouă; linia ab cd rămâne necitită. Se afișează 12||. Varianta a) ar apărea dacă între cele două citiri s-ar elimina sfârșitul liniei cu cin.get(), iar varianta c) corespunde citirii unui singur cuvânt cu >>.

Al doilea exemplu în formatul examenului. Se citește linia ab cd. Ce se afișează?

char a[20], b[20];
cin >> a;
cin.getline(b, 20);
cout << a << '|' << b << '|';

Răspunsul este ab| cd|. Operatorul >> citește cuvântul ab și se oprește înaintea spațiului. Apelul getline citește restul liniei, inclusiv spațiul de la început, deci b conține cd, cu un spațiu în față.

Greșeli frecvente

• Greșit: cin >> s citește toată linia, inclusiv spațiile.
  Corect: citește un singur cuvânt, până la primul spațiu alb.
• Greșit: după cin >> n, un getline citește linia următoare.
  Corect: citește mai întâi restul liniei curente, de obicei un șir gol.
• Greșit: cout << s trece automat la rând nou.
  Corect: rândul nou se scrie explicit, cu '\n' sau endl.

Înainte și după