Comment écrire les chaînes dans le fichier binaire

Question

Avec ce code, j'ai essayé d'imprimer la chaîne « foo » 10 fois au format binaire. Mais pourquoi ne pas la fonction de le faire fonctionner?

#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

Il y a tellement de mal ici, je vais juste énumérer tout ce que je vois:

Votre état pour la boucle doit être i <10.

Pourquoi utilisez-vous un modèle, mais pas le paramètre T sans canevas?

Vous appelez le front de la méthode () sur CStr, mais CStr est un char, pas une chaîne, donc je ne sais même pas comment compilant.

Si l'on suppose CStr était une chaîne, vous ne voulez pas prendre l'adresse de l'avant () iterator à l'aide et, au lieu que vous voulez dire quelque chose comme:

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

Et vous ne voulez pas faire une boucle pour itérations St.size (). Il suffit de faire ce qui précède.

Answer 2

omg, il a beaucoup d'erreurs:

• int main - valeur devrait revenir;
• ne pas utiliser template dans votre fonction;
• MyStr - pas le nom correct dans l'appel de fonction, les noms en C ++ sont cas sencetive;
• char CStr - n'a pas avant la méthode et std :: string trop;
• vous ne pouviez pas obtenir l'adresse de premier élément tel que dans le cas avec le vecteur;
• il sera mieux si vous accepterez std :: string comme référence const;
• vous avez oublié d'inclure en-tête de chaîne;
• ...

fixe votre exemple, avec votre code d'organiser et de votre désignation:

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

mais j'ai reccomended utiliser l'algorithme de std::fill_n

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

Answer 3

D'abord, char CStr dit que CStr est un seul caractère. En second lieu, fn.write(&CStr.front(), CStr.size()); traite ce caractère comme un conteneur, comme std::vector<>, ce qui bien sûr ne peut pas compiler.

En supposant que tout à WriteStr2BinFh est ok, que je n'ai pas vérifié, voici comment WriteStr2BinFh devrait (pourrait) voir:

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

ou, de préférence

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

Answer 4

Les points importants pour faire une opération io en mode binaire:

• Le fichier doit être ouvert en sortie et le mode binaire en utilisant les drapeaux ios :: out (mode de sortie) et ios :: binaire (mode binaire)
• La écriture de fonction prend deux paramètres. Le premier paramètre est de type char * pour les données à écrire et le second est de type int demandant la taille des données à écrire dans le fichier binaire.

• fichier doit être fermé à la fin.

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

  Cette fonction binaire E / S des données à écrit-la fonction.

• Le fichier est ouvert en sortie et en mode binaire avec ios :: out et ios :: binaires. Il y a une plus spécificateur ios :: app, qui indique au système d'exploitation que le fichier est également ouvert en mode append. Cela signifie que tout nouvel ensemble de données seront ajoutées à la fin du fichier.

• La fonction d'écriture utilisée ci-dessus, a besoin du paramètre comme un type de pointeur de caractère. Nous utilisons donc un reinterpret_cast convertisseur de type à typer la structure en type char *.