Como escrever arquivo strings em binário

Question

Com este código eu tentei imprimir o "foo" string 10 vezes em formato binário. Mas por que não a função de fazê-lo trabalho?

#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

Há tanta coisa errada aqui, eu só vou lista tudo o que vejo:

Seu loop condição deve ser i <10.

Por que você está usando um modelo, mas não o templatized parâmetro T?

Você está chamando a frente () método em CStr, mas CStr é um char, não uma string, então eu não sei mesmo como que compila.

Assumindo CStr foi uma string, você não quer tomar o endereço da frente () iterator usando e, em vez disso você quer dizer algo como:

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

E você não quer loop para St.size () iterações. Basta fazer o acima.

Answer 2

omg, ele tem um monte de erros:

• int main - deve retornar valor;
• você não usar template em sua função;
• myStr - não o nome correto em chamada de função, nomes em C ++ são caso sencetive;
• caractere CStr - não tem frente método, e std :: string também;
• você não pode obter o endereço do primeiro elemento, como no caso do vector;
• será melhor se você vai aceitar std :: string como referência const;
• você se esqueceu de incluir cabeçalho string;
• ...

fixa o seu exemplo, com o seu código organizar e sua 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;
}

mas eu tenho recomendado usar std::fill_n algoritmo

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

Answer 3

Em primeiro lugar, char CStr diz que CStr é um único caractere. Em segundo lugar, fn.write(&CStr.front(), CStr.size()); trata esse personagem como um recipiente, como std::vector<>, que naturalmente não pode compilar.

Assumindo que tudo até WriteStr2BinFh é ok, que eu não tenho verificado, é assim WriteStr2BinFh deveria (poderia) look:

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

ou, de preferência

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

Answer 4

Pontos importantes para fazer uma operação io em modo binário:

• O arquivo deve ser aberto na produção e no modo binário usando os ios bandeiras :: out (modo de saída) e ios :: binary (modo binário)
• A função de gravação tem dois parâmetros. O primeiro parâmetro é do tipo char * para os dados a serem escritos eo segundo é do tipo int pedindo o tamanho dos dados a serem gravados para o arquivo binário.

• O arquivo tem de ser fechado no final.

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

  Esta O binário função / I escreve alguns dados para a função.

• O arquivo é aberto na produção e no modo binário com ios :: out e ios :: binários. Há mais um especificador ios :: app, que diz ao sistema operacional que o arquivo também é aberto no modo de acréscimo. Isto significa que qualquer novo conjunto de dados serão anexados ao final do arquivo.

• A função de gravação utilizado acima, precisa o parâmetro como um tipo de ponteiro personagem. Então, nós usamos um reinterpret_cast tipo de conversor typecast a estrutura em char * tipo.