Comment Écrire des Chaînes de caractères Dans un Fichier Binaire

Avec ce code, j'ai essayé d'imprimer la chaîne "toto" 10 fois
dans un format binaire. Mais pourquoi ne pas la fonction pour 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();   
}

OriginalL'auteur neversaint | 2009-03-26

  1. 9

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

    Pour votre condition de boucle doit être i < 10.

    Pourquoi êtes-vous à l'aide d'un modèle mais pas la templatized paramètre T?

    Vous êtes à l'appel de la méthode avant() sur CStr, mais CStr est un char, pas une chaîne, donc je ne sais même pas qui compile.

    En supposant CStr est une chaîne de caractères, vous ne voulez pas prendre l'adresse de l'avant() itérateur à l'aide de &, au contraire, vous voulez dire quelque chose comme:

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

    Et vous ne voulez pas de la boucle de Saint-size() itérations. Il suffit de faire ci-dessus.

    OriginalL'auteur i_am_jorf

  2. 3

    omg, il ont beaucoup d'erreurs:

    • int main - devraient valeur de retour;
    • vous n'utilisez pas de template< typename T > dans votre fonction;
    • Mystr - pas de nom correct dans l'appel de fonction, les noms en c++ sont des cas sencetive;
    • char CStr - n'a pas de méthode à l'avant, et std::string;
    • vous ne pourriez pas obtenir l'adresse du premier élément, comme dans le cas avec le vecteur;
    • il sera mieux si vous l'acceptez std::string comme référence const;
    • vous avez oublié d'inclure la chaîne d'en-tête;
    • ...

    fixe à votre exemple, avec votre code d'organiser et de votre nom:

    #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 je l'ai recommandé d'utiliser std::fill_n algorithme

    std::fill_n( std::ostream_iterator< std::string >( myfile, "\t" ), 10, MyStr );
    J'ai comme un retour explicite dans main(); toutefois, la norme C++ nécessite de tomber de la fin de main() équivalent à retourner la valeur 0.
    Intrest fait. J'ai vérifié - élément 3.6.1.5 de standrd - oui, vous avez raison. Mais de toute façon, je thnk il convient de clarifier.

    OriginalL'auteur bayda

  3. 1

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

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

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

    OriginalL'auteur Johann Gerell

  4. 1

    Points importants pour faire une opération e /s en mode binaire:

    • Le fichier doit être ouvert en sortie et le mode binaire en utilisant les drapeaux ios::out (output mode) et ios::binary( mode binaire)
    • La fonction d'écriture prend deux paramètres. Le premier paramètre est de type char* pour que les données soient écrites, et le second est de type int pour demander 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();
}

      Cet I/O fonction binaire écrit des données dans la fonction.

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

    • La fonction d'écriture utilisé ci-dessus, doit le paramètre comme un personnage de type pointeur. Nous avons donc utiliser un convertisseur de type reinterpret_cast de transtypage de la structure en char* type.

    OriginalL'auteur HipsterZipster