Cómo escribir cadenas en el archivo binario

Question

Con este código intento imprimir la cadena "foo" 10 veces en formato binario. Pero ¿por qué no la función de hacer que funcione?

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

template <typename T> void WriteStr2BinFh (string St, ostream &fn) {
     for (unsigned i = 0; i < St.size(); i++) {
         char CStr = St[i];
         fn.write(&CStr.front(), CStr.size());
     }
     return;
}

int main() {
   string MyStr = "Foo";
   ofstream myfile;
   myfile.open("OuputFile.txt", ios::binary|ios::out);

   // We want to print it 10 times horizontally
   // separated with tab

  for (int i = 0; i < 9; i++) {
      WriteStr2BinFh(Mystr+"\t", myfile);
   }

   myfile.close();   
}

Answer 1

Hay tanto mal aquí, sólo voy a enumerar todo lo que veo:

Su condición de bucle debe ser i <10.

¿Por qué utiliza una plantilla pero no el parámetro a plantillas T?

Usted está llamando la parte delantera () método en CStr, pero CStr es un char, no es una cadena, así que ni siquiera saben cómo se compila.

Si se asume CStr era una cadena, que no quiere tomar la dirección de la parte delantera iterador () utilizando y, por el contrario desea decir algo como:

fn.write(St.c_str(), St.size());

Y usted no desea bucle para St.size () iteraciones. Sólo hacer lo anterior.

Answer 2

OMG, que tiene una gran cantidad de errores:

• int main - debe devolver el valor;
• no utiliza la plantilla en su función;
• myStr - no nombre correcto en llamada de función, nombres en C ++ son sencetive caso;
• Char CStr - no tiene método de frente, y std :: string también;
• No se podía conseguir la dirección del primer elemento, como en el caso con el vector;
• será mejor si va a aceptar std :: string como referencia constante;
• que se olvidó de incluir un encabezado de cuerda;
• ...

fija su ejemplo, con su código de organizar y su nomenclatura:

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

void WriteStr2BinFh( const std::string& St, std::ostream &out ) 
{
    out.write( St.c_str(), St.size() );
}

int main() 
{
    std::string MyStr = "Foo";
    std::ofstream myfile( "OuputFile.txt", std::ios::binary | std::ios::out );


    for (size_t i = 0; i < 9; ++i) 
    {
        WriteStr2BinFh( MyStr+"\t", myfile );
    }

   myfile.close();   
   return 0;
}

Pero he recomendado utilizar el algoritmo std::fill_n

std::fill_n( std::ostream_iterator< std::string >( myfile, "\t" ), 10, MyStr );

Answer 3

En primer lugar, dice que char CStr CStr es un solo carácter. En segundo lugar, fn.write(&CStr.front(), CStr.size()); trata a ese personaje como un contenedor, como std::vector<>, que por supuesto no se puede compilar.

Suponiendo que todo lo que hasta WriteStr2BinFh está bien, que no lo he comprobado, esta es la forma en WriteStr2BinFh debería (podría) aspecto:

void WriteStr2BinFh(const string& St, ostream &fn)
{
    for(string::iterator it = St.begin(); it != St.end(); ++it)
    {
        fn.put(*it);
    }
}

o, preferiblemente

void WriteStr2BinFh(const string& St, ostream &fn)
{
    fn.write(St.c_str(), St.length());
}

Answer 4

Los puntos importantes para hacer una operación IO en modo binario:

• El archivo tiene que ser abierto de la producción y el modo binario usando las banderas ios :: out (modo de salida) y ios :: (modo binario) binario
• La función de escritura toma dos parámetros. El primer parámetro es de tipo char * de los datos a escribir y la segunda es de tipo int preguntando por el tamaño de los datos que se escriben en el archivo binario.

• El archivo ha de estar cerrado en el extremo.

  void write_to_binary_file(WebSites p_Data)
  {
      fstream binary_file("c:\\test.dat",ios::out|ios::binary|ios::app);
      binary_file.write(reinterpret_cast<char *>(&p_Data),sizeof(WebSites));
      binary_file.close();
  }
  

  Este I / O función binaria escribe algunos datos a la función.

• El archivo se abre en la producción y el modo binario con ios :: y ios :: binarios. Hay uno más especificadores de ios :: aplicación, que indica al sistema operativo que el archivo se abre en modo de anexos. Esto significa que cualquier nuevo conjunto de datos se añade al final del archivo.

• La función de escritura utilizado anteriormente, necesita conocer el tipo de puntero como un personaje. Por eso, utilizamos un tipo de convertidor reinterpret_cast a encasillarse en la estructura de tipo char *.