Cum se citește până la EOF de la cin în C ++

Singurul mod în care puteți citi o cantitate variabilă de date de la stdin utilizează bucle. Întotdeauna am găsit că std :: getline() funcția funcționează foarte bine:

std::string line;
while (std::getline(std::cin, line))
{
    std::cout << line << std::endl;
}

În mod implicit, getline() citește până la o linie nouă. Puteți specifica un caracter alternativ de terminare, dar EOF nu este el însuși un caracter, astfel încât să nu puteți face un simplu apel la getline ().

Puteți face acest lucru fără bucle explicite prin utilizarea iteratorilor de fluxuri. Sunt sigur că foloseste un fel de buclă intern.

#include 
#include 
#include 
#include 
#include 

int main()
{
// don't skip the whitespace while reading
  std::cin >> std::noskipws;

// use stream iterators to copy the stream to a string
  std::istream_iterator it(std::cin);
  std::istream_iterator end;
  std::string results(it, end);

  std::cout << results;
}

Utilizând bucle:

#include 
using namespace std;
...
// numbers
int n;
while (cin >> n)
{
   ...
}
// lines
string line;
while (getline(cin, line))
{
   ...
}
// characters
char c;
while (cin.get(c))
{
   ...
}

resursă

După ce am cercetat soluția lui KeithB folosind std :: istream_iterator , am descoperit < code> std: istreambuf_iterator .

Testați programul pentru a citi toate intrările de conducte într-un șir, apoi scrie-l din nou:

#include 
#include 
#include 

int main()
{
  std::istreambuf_iterator begin(std::cin), end;
  std::string s(begin, end);
  std::cout << s;
}

Probabil cel mai simplu și în general eficient:

#include 
int main()
{
    std::cout << std::cin.rdbuf();
}

Dacă este necesar, utilizați fluxul de alte tipuri ca std :: ostringstream ca tampon în loc de fluxul de ieșire standard aici.

Puteți folosi std :: istream :: getline() ( sau, de preferință, versiunea care funcționează pe std :: string ) pentru a obține o întreagă linie . Ambele au versiuni care vă permit să specificați delimitatorul (caracterul final al liniei). Valoarea implicită pentru versiunea șirului este '\ n'.

Nota trista: am decis sa folosesc C ++ IO pentru a fi in concordanta cu codul bazat pe boost. Din răspunsurile la această întrebare am ales în timp ce (std :: getline (std :: cin, line)) . Folosind g ++ versiunea 4.5.3 (-O3) în cygwin (mintty) am 2 MB/s de transfer. Microsoft Visual C ++ 2010 (/ O2) a făcut 40 MB/s pentru același cod.

După rescrierea IO la C pur în timp ce (fgets (buf, 100, stdin)) , transferul a crescut la 90 MB/s în ambele compilatoare testate. Asta face diferenta pentru orice intrare mai mare de 10 MB ...

while(std::cin) {
//do something
}

O opțiune este folosirea unui container, de ex.

std::vector data;

și redirecționați toate datele introduse în această colecție până la primirea EOF , adică

std::copy(std::istream_iterator(std::cin),
    std::istream_iterator(),
    std::back_inserter(data));

Cu toate acestea, containerul utilizat ar putea avea nevoie să reallocalizeze memoria prea des sau veți termina cu o excepție std :: bad_alloc atunci când sistemul dvs. va ieși din memorie. Pentru a rezolva aceste probleme, puteți rezerva o sumă fixă ​​ N a elementelor și puteți procesa aceste cantități de elemente în mod izolat, adică

data.reserve(N);    
while (/*some condition is met*/)
{
    std::copy_n(std::istream_iterator(std::cin),
        N,
        std::back_inserter(data));

    /* process data */

    data.clear();
}

Așteaptă, te înțeleg corect? Folosiți cin pentru introducerea tastaturii și doriți să opriți citirea intrărilor când utilizatorul introduce caracterul EOF? De ce ar introduce utilizatorul vreodată caracterul EOF? Sau vrei să spui că vrei să nu mai citești dintr-un dosar la EOF?

Dacă de fapt încercați să utilizați cin pentru a citi un caracter EOF, atunci de ce nu specificați doar EOF ca delimiter?

// Needed headers: iostream

char buffer[256];
cin.get( buffer, '\x1A' );

Dacă intenționați să opriți citirea dintr-un fișier de la EOF, atunci folosiți linia getline și, din nou, specificați EOF ca delimiter.

// Needed headers: iostream, string, and fstream

string buffer;

    ifstream fin;
    fin.open("test.txt");
    if(fin.is_open()) {
        getline(fin,buffer,'\x1A');

        fin.close();
    }