c++ - salto - usando fstream para leer cada personaje, incluyendo espacios y nueva línea

libreria fstream c++

Question

Quería usar fstream para leer un archivo txt.

Estoy usando inFile >> characterToConvert , pero el problema es que esto omite espacios y nueva línea.

Estoy escribiendo un programa de cifrado, así que necesito incluir los espacios y las nuevas líneas.

¿Cuál sería la forma correcta de lograr esto?

Answer 1

También encuentro que el método get () del objeto ifstream también puede leer todos los caracteres del archivo, que no requieren unset std::ios_base::skipws . Cita de C ++ Primer :

Varias de las operaciones sin formato tratan con una transmisión de un byte a la vez. Estas operaciones, que se describen en la Tabla 17.19, leen en lugar de ignorar espacios en blanco.

Estas operaciones se enumeran a continuación: is.get () , os.put () , is.putback () , is.unget () y is.peek () .

A continuación hay un código de trabajo mínimo

#include <iostream>
#include <fstream>
#include <string>

int main(){
    std::ifstream in_file("input.txt");

    char s;

    if (in_file.is_open()){
        int count = 0;
        while (in_file.get(s)){

            std::cout << count << ": "<< (int)s <<''/n'';
            count++;
        }

    }
    else{
        std::cout << "Unable to open input.txt./n";
    }
    in_file.close();

    return 0;
 }

El contenido del archivo de entrada ( cat input.txt ) es

ab cd
ef gh

El resultado del programa es:

0: 97
1: 98
2: 32
3: 99
4: 100
5: 10
6: 101
7: 102
8: 32
9: 103
10: 104
11: 32
12: 10

10 y 32 son representaciones decimales de carácter de nueva línea y espacio. Obviamente, todos los personajes han sido leídos.

Answer 2

Como señaló correctamente Charles Bailey, no necesita los servicios de Fstream solo para leer bytes. Así que olvida esta estupidez iostream, usa fopen / fread y termina con eso. C stdio es parte de C ++, ya sabes;)

Answer 3

El siguiente código de C ++ leerá un archivo completo ...

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

int main () 
{
  string line;
  ifstream myfile ("foo.txt");

  if (myfile.is_open()){

    while (!myfile.eof()){
      getline (myfile,line);
      cout << line << endl;
    }
    myfile.close();
  }
  return 0;
}

publica tu código y puedo darte ayuda más específica para tu problema ...

Answer 4

No he probado esto, pero creo que debes borrar la bandera de "saltar espacio en blanco":

inFile.unsetf(ios_base::skipws);

Uso la siguiente referencia para flujos de C ++: Biblioteca IOstream

Answer 5

Para el cifrado, probablemente deberías usar read () . Los algoritmos de cifrado generalmente tratan con bloques de tamaño fijo. Ah, y para abrir en modo binario (sin traducción frmo / n / r a / n), pase ios_base :: binary como el segundo parámetro a constructor o llamada abierta ().

Answer 6

Puede llamar a int fstream::get() , que leerá un solo carácter de la transmisión. También puede usar istream& fstream::read(char*, streamsize) , que realiza la misma operación que get() , justo sobre varios caracteres. Los enlaces dados incluyen ejemplos de uso de cada método.

También recomiendo leer y escribir en modo binario. Esto permite que los caracteres de control ASCII se lean y escriban correctamente en los archivos. De lo contrario, un par de operaciones de cifrado / descifrado puede dar como resultado archivos no idénticos. Para hacer esto, abre el filestream con el indicador ios::binary . Con un archivo binario, desea utilizar el método read() .

Answer 7

Una gran parte del beneficio de la capa istream es proporcionar formato básico y análisis para tipos simples ro y de una secuencia. Para los fines que describe, nada de esto es realmente importante y solo le interesa el archivo como una secuencia de bytes.

Para estos fines, es mejor que simplemente uses la interfaz basic_streambuf proporcionada por un archivo bbu. El comportamiento ''skip whitespace'' es parte de la funcionalidad de la interfaz istream que simplemente no necesita.

filebuf subyace a ifstream, pero es perfectamente válido para usarlo directamente.

std::filebuf myfile;
myfile.open( "myfile.dat", std::ios_base::in | std::ios_base::binary );

// gets next char, then moves ''get'' pointer to next char in the file
int ch = myfile.sbumpc();

// get (up to) the next n chars from the stream
std::streamsize getcount = myfile.sgetn( char_array, n );

También eche un vistazo a las funciones snextc (mueve el puntero ''get'' hacia adelante y luego regresa el carácter actual), sgetc (obtiene el carácter actual pero no mueve el puntero ''get'') y sungetc (respalda el ''obtener'' puntero por una posición si es posible).

Cuando no necesita ninguno de los operadores de inserción y extracción proporcionados por una clase istream y solo necesita una interfaz de bytes básica, a menudo la interfaz streambuf (filebuf, stringbuf) es más apropiada que una interfaz istream (ifstream, istringstream).

Answer 8

Sencillo

#include <fstream>
#include <iomanip>


ifstream ifs ("file");
ifs >> noskipws

eso es todo.

Answer 9

Para el cifrado, es mejor abrir el archivo en modo binario. Use algo como esto para poner los bytes de un archivo en un vector:

std::ifstream ifs("foobar.txt", std::ios::binary);

ifs.seekg(0, std::ios::end);
std::ifstream::pos_type filesize = ifs.tellg();
ifs.seekg(0, std::ios::beg);

std::vector<char> bytes(filesize);

ifs.read(&bytes[0], filesize);

Editar: corrigió un error sutil según los comentarios.

Answer 10

std::ifstream ifs( "filename.txt" );

std::string str( ( std::istreambuf_iterator<char>( ifs ) ), 
                 std::istreambuf_iterator<char>()
               );

Answer 11

ifstream ifile(path);
std::string contents((std::istreambuf_iterator<char>(ifile)), std::istreambuf_iterator<char>());
ifile.close();

Answer 12

Otra forma mejor es usar istreambuf_iterator, y el código de muestra es el siguiente:

ifstream inputFile("test.data");

string fileData(istreambuf_iterator<char>(inputFile), istreambuf_iterator<char>());

Answer 13

Probablemente la mejor manera es leer el contenido del archivo completo en una cadena, lo que se puede hacer muy fácilmente utilizando el método rdbuf() de rdbuf() :

std::ifstream in("myfile");

std::stringstream buffer;
buffer << in.rdbuf();

std::string contents(buffer.str());

A continuación, puede utilizar la manipulación regular de cadenas ahora que tiene todo lo que necesita del archivo.

Mientras que Tomek preguntaba por la lectura de un archivo de texto, el mismo enfoque funcionará para la lectura de datos binarios, aunque es necesario proporcionar el indicador std :: ios :: binary al crear la secuencia de archivos de entrada.