Comment enregistrer une chaîne de caractères dans un fichier binaire

Question

Voici mon code

    bool saveFile (string name, string contents)
{
    ofstream file;
    file.open(name.c_str(), ios::binary);
    file.write(contents.c_str(),contents.size());
    file.close();

}

Ok edit :

Ma chaîne de caractères contient

10100101111111110000

Lorsque je l'enregistre en tant que fichier binaire et que je l'ouvre à l'aide du bloc-notes, je m'attends à voir des caractères aléatoires de la table ascii, mais au lieu de cela, je vois exactement le même flux de 0 et de 1.

Answer 1

Si vous disposez d'une chaîne de texte "binaire" composée de '1' y '0' vous pouvez le coder en octets à l'aide de la fonction std::bitset<8> .

void saveFile (std::string name, std::string contents) {
    std::ofstream file(name.c_str(), std::ios::binary);
    for ( std::size_t byte = 0; byte < contents.size(); byte += 8 ) {
        file.put( std::bitset< 8 >( contents, byte, // convert one byte
          std::min( (std::size_t) 8, contents.size() - byte ) // or as many bits as are left
          .to_ulong() ); // to two's complement representation
    }
}

Answer 2

En gros, la principale différence entre un fichier binaire et un fichier texte est que chaque octet que vous écrivez dans le premier est enregistré sans modification, tandis qu'un caractère de nouvelle ligne écrit dans le second peut être traduit en séquence de nouvelle ligne du système sous-jacent, par exemple retour chariot + saut de ligne pour Windows.

Voici un exemple :

#include <fstream>
#include <ios>

int main() {
  std::ofstream file;
  std::string s = "Hello, World!\n";
//  file.open("binary", std::ios_base::binary);
  file.open("text");
  file.write(s.c_str(),s.size());
  file.close();
}

Si je compile ce programme tel qu'il est maintenant avec g++ et que je l'exécute sous Windows, j'obtiens ce résultat :

$ od -c text
0000000   H   e   l   l   o   ,       W   o   r   l   d   !  \r  \n
0000017

Si je commente la ligne où le fichier "texte" est écrit et décommente celle où le fichier "binaire" est écrit, j'obtiens :

$ od -c binary
0000000   H   e   l   l   o   ,       W   o   r   l   d   !  \n
0000016

( od est une commande d'UNIX/Linux qui affiche le contenu exact d'un fichier)

Pour répondre à votre question, voici un exemple de la façon dont vous pourriez le faire "à la main". En utilisant un bitset comme dans la réponse acceptée, est probablement une approche plus raisonnable :

#include <fstream>
#include <ios>
#include <iostream>
#include <string>
#include <vector>

int main() {
    std::string s = "10100101111111110000";
    std::vector<unsigned char> v;
    unsigned char c = 0;
    int i = 0;
    for ( auto d : s ) {
        if ( d == '1' )
            ++c;
        c <<= 1;
        ++i;
        if ( i % 8 == 0 ) {
            v.push_back(c);
            c = 0;
            i = 0;
        }
    }
    if ( i != 0 ) {
        c <<= 8 - i;
        v.push_back(c);
    }
    std::basic_ofstream<unsigned char> file;
    file.open("binary", std::ios_base::binary);
    file.write(v.data(), v.size());
    file.close();
}

Answer 3

Vous avez écrit des caractères lisibles (représentant les caractères numériques '1' et '0') dans le fichier binaire, de sorte que lorsque vous le regardez dans un éditeur, vous pouvez le lire. Si vous voulez lire des "déchets", vous devez écrire dans le fichier des "déchets", c'est-à-dire des caractères "illisibles" qui se situent en dehors de la plage des caractères "imprimables" ( a-zA-Z0-9!@#$%^ etc.).