Jak czytać do EOF z cin w C ++

Koduję program, który czyta dane bezpośrednio z danych wejściowych użytkownika i zastanawiałem się, jak mogę (bez pętli) odczytać wszystkie dane do EOF ze standardowego wejścia. Rozważałem użycie, cin.get( input, '\0' )ale '\0'tak naprawdę nie jest to znak EOF, który czyta tylko do EOF lub '\0', cokolwiek nastąpi wcześniej.

A może używanie pętli jest jedynym sposobem na to? Jeśli tak, to jaki jest najlepszy sposób?

Jedynym sposobem, w jaki możesz odczytać zmienną ilość danych, stdinjest użycie pętli. Zawsze uważałem, że std::getline()funkcja działa bardzo dobrze:

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

Domyślnie getline()czyta aż do nowej linii. Możesz określić alternatywny znak zakończenia, ale EOF sam w sobie nie jest znakiem, więc nie możesz po prostu wykonać jednego wywołania getline().

Korzystanie z pętli:

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

ratunek

Możesz to zrobić bez jawnych pętli, używając iteratorów strumienia. Jestem pewien, że wewnętrznie używa jakiejś pętli.

#include <string>
#include <iostream>
#include <istream>
#include <ostream>
#include <iterator>

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<char> it(std::cin);
  std::istream_iterator<char> end;
  std::string results(it, end);

  std::cout << results;
}

Po zbadaniu rozwiązania KeithB przy użyciu std::istream_iterator, odkryłem std:istreambuf_iterator.

Przetestuj program, aby wczytywał wszystkie dane wejściowe potokiem do łańcucha, a następnie wypisz go ponownie:

#include <iostream>
#include <iterator>
#include <string>

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

Prawdopodobnie najprostszy i ogólnie skuteczny:

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

W razie potrzeby użyj tutaj strumienia innych typów, takich std::ostringstreamjak bufor zamiast standardowego strumienia wyjściowego.

Możesz użyć funkcji std :: istream :: getline () (lub najlepiej wersji, która działa na std :: string ), aby uzyskać cały wiersz. Obie mają wersje, które umożliwiają określenie separatora (znak końca wiersza). Wartość domyślna dla wersji ciągu to „\ n”.

Smutna uwaga: zdecydowałem się użyć C ++ IO, aby być spójnym z kodem opartym na boost. Z odpowiedzi na to pytanie wybrałemwhile (std::getline(std::cin, line)) . Używając g ++ w wersji 4.5.3 (-O3) w Cygwin (Mintty) uzyskałem przepustowość 2 MB / s. Microsoft Visual C ++ 2010 (/ O2) zrobił 40 MB / s dla tego samego kodu.

Po przepisaniu IO do czystego C while (fgets(buf, 100, stdin))przepustowość wzrosła do 90 MB / sw obu testowanych kompilatorach. To robi różnicę w przypadku każdego wejścia większego niż 10 MB ...

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

Czekaj, czy dobrze cię rozumiem? Używasz cin do wprowadzania danych z klawiatury i chcesz przestać czytać dane wejściowe, gdy użytkownik wprowadzi znak EOF? Dlaczego użytkownik miałby kiedykolwiek wpisywać znak EOF? A może chodziło Ci o to, że chcesz przestać czytać z pliku w EOF?

Jeśli faktycznie próbujesz użyć funkcji cin do odczytania znaku EOF, to dlaczego nie określić po prostu EOF jako separatora?

// Needed headers: iostream

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

Jeśli zamierzasz przestać czytać z pliku w EOF, po prostu użyj getline i jeszcze raz określ EOF jako separator.

// Needed headers: iostream, string, and fstream

string buffer;

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

        fin.close();
    }

Jedną z opcji jest użycie pojemnika, np

std::vector<char> data;

i przekieruj wszystkie dane wejściowe do tej kolekcji, dopóki nie EOFzostaną odebrane, tj

std::copy(std::istream_iterator<char>(std::cin),
    std::istream_iterator<char>(),
    std::back_inserter(data));

Jednak używany kontener może wymagać zbyt częstego ponownego przydzielania pamięci lub zakończy się std::bad_allocwyjątkiem, gdy w systemie zabraknie pamięci. Aby rozwiązać te problemy, można zarezerwować określoną liczbę Nelementów i przetworzyć te ilości oddzielnie, tj

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

    /* process data */

    data.clear();
}