Cómo leer hasta EOF desde cin en C++

Question

Estoy codificando un programa que lee datos directamente de la entrada del usuario y me preguntaba cómo podría (sin bucles) leer todos los datos hasta EOF desde la entrada estándar. Estaba considerando usar cin.get(input, '\0') pero '\0' no es realmente el carácter EOF, que solo lee hasta EOF o '\0', lo que ocurra primero.

¿O está utilizando los bucles la única manera de hacerlo? Si es así, ¿cuál es la mejor manera?

Answer 1

Puede usar la función std::istream::getline() (o preferiblemente la version that works on std::string) para obtener una línea completa. Ambos tienen versiones que le permiten especificar el delimitador (carácter de fin de línea). El valor predeterminado para la versión de cadena es '\ n'.

Answer 2

La única forma en que puede leer una cantidad variable de datos desde stdin es utilizando bucles. Siempre he encontrado que la función std::getline() funciona muy bien:

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

Por defecto getline() lee hasta que una nueva línea. Puede especificar un carácter de terminación alternativo, pero EOF no es en sí mismo un carácter, por lo que no puede simplemente hacer una llamada a getline().

Answer 3

Puede hacerlo sin bucles explícitos mediante el uso de iteradores de flujo. Estoy seguro de que utiliza algún tipo de bucle internamente.

#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; 
} 

Answer 4

mediante bucles:

#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)) 
{ 
    ... 
} 

resource

Answer 5

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

Answer 6

triste nota: yo decidimos utilizar C++ IO para ser coherente con el código basado impulso. De las respuestas a esta pregunta elegí while (std::getline(std::cin, line)). Usando g ++ versión 4.5.3 (-O3) en cygwin (mintty) obtuve 2 MB/s de rendimiento. Microsoft Visual C++ 2010 (/ O2) lo convirtió en 40 MB/s para el mismo código.

Después de volver a escribir la IO a C puro while (fgets(buf, 100, stdin)) el rendimiento saltó a 90 MB/s en ambos compiladores ensayadas. Eso hace una diferencia para cualquier entrada de más de 10 MB ...

Answer 7

Espera, ¿te entiendo correctamente? ¿Estás utilizando cin para ingresar el teclado, y quieres dejar de leer la entrada cuando el usuario ingresa el carácter EOF? ¿Por qué el usuario alguna vez ingrese el carácter EOF? ¿O quiso decir que quiere dejar de leer un archivo en el EOF?

Si realmente está tratando de usar cin para leer un carácter EOF, ¿por qué no simplemente especifica el EOF como el delimitador?

// Needed headers: iostream 

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

Si se refiere a dejar de leer desde un archivo en el EOF, a continuación, sólo tiene que utilizar getline y una vez más especificar el EOF como delimitador.

// Needed headers: iostream, string, and fstream 

string buffer; 

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

     fin.close(); 
    } 

Answer 8

Una opción es utilizar un contenedor, p.

std::vector<char> data; 

y redirigir todas las entradas en esta colección hasta EOF se recibe, es decir,

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

Sin embargo, el recipiente usado puede ser que necesite para reasignar la memoria con demasiada frecuencia, o puede acabar con una excepción std::bad_alloc cuando el sistema se pone fuera de la memoria. Con el fin de resolver estos problemas, se podría reserva una cantidad fija N de elementos y procesar estos cantidad de elementos en forma aislada, es decir

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(); 
} 

Answer 9

más simple estimado y generalmente eficiente:

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

Si es necesario , utilice la secuencia de otros tipos como std::ostringstream como búfer en lugar de flujo de salida estándar aquí.

Answer 10

Después de investigar la solución de KeithB usando std::istream_iterator, descubrí el std:istreambuf_iterator.

Programa de prueba para leer todas las entradas por tubería en una cadena, a continuación, escriba de nuevo:

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

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