Come Scrivere stringhe in file binario

Question

Con questo codice ho cercato di stampare la stringa "pippo" 10 volte in formato binario. Ma perché non la funzione per farlo funzionare?

#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

C'è così tanto male qui, sto solo andando a elencare tutto ciò che vedo:

Il ciclo for condizione dovrebbe essere i <10.

Perché stai usando un modello, ma non il parametro templatized T?

Si sta chiamando la parte anteriore () metodo su CStr, ma CStr è un char, non è una stringa, quindi non si sa nemmeno come che si compila.

Supponendo CStr era una stringa, non si vuole prendere l'indirizzo del iteratore anteriore () utilizzando e, invece si vuole dire qualcosa come:

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

E tu non vuoi ciclo per St.size () iterazioni. Basta fare quanto sopra.

Answer 2

OMG, hanno un sacco di errori:

• int main - valore dovrebbe tornare;
• non si utilizza template nella funzione;
• myStr - non è corretto nome chiamata di funzione, i nomi in C ++ sono caso sencetive;
• char CStr - non ha metodo front, e std :: string troppo;
• non si poteva ottenere l'indirizzo del primo elemento come ad esempio nel caso in cui con il vettore;
• sarà meglio se si accetta std :: string come riferimento const;
• si è dimenticato di includere intestazione stringa;
• ...

fissi tuo esempio, con il codice organizzare e la tua denominazione:

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

Ma ho consigliato di utilizzare l'algoritmo std::fill_n

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

Answer 3

In primo luogo, char CStr dice che CStr è un singolo carattere. In secondo luogo, fn.write(&CStr.front(), CStr.size()); considera quel personaggio come contenitore, come std::vector<>, che naturalmente non può compilare.

Supponendo che tutto fino a WriteStr2BinFh è ok, che non ho controllato, questo è il modo in WriteStr2BinFh dovrebbe (potrebbe) aspetto:

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

o, preferibilmente

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

Answer 4

Punti importanti per fare un'operazione IO in modalità binaria:

• Il file deve essere aperto in modalità binaria di uscita e utilizzando le bandiere ios :: out (modalità di uscita) e ios :: binary (modo binario)
• La scrittura funzione prende due parametri. Il primo parametro è di tipo char * per i dati da scrivere e il secondo è di tipo int chiedere la dimensione dei dati da scrivere al file binario.

• file deve essere chiuso alla fine.

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

  Questa I / O funzione binaria scrive alcuni dati alla funzione.

• Il file viene aperto in modalità binaria di uscita e con ios :: out e ios :: binari. C'è un altro ios Prescrizione :: app, che indica al sistema operativo che il file viene aperto anche in modalità di accodamento. Questo significa che qualsiasi nuovo set di dati sarà aggiunto alla fine del file.

• La funzione di scrittura utilizzato in precedenza devono il parametro come un tipo puntatore a carattere. Quindi usiamo un reinterpret_cast tipo di convertitore typecast la struttura in tipo char *.