Lecture de fichier binaire en C++

Bonjour,

Je me demande quelle est la meilleure manière en C++ de lire un fichier binaire.

La librairie standard est très vaste et semble contenir des tas de fonctions pour y arriver :
http://www.cplusplus.com/reference/fstream/ifstream/

Concrètement, je dispose d’une fichier binaire de plusieurs centaines de Mo dont je souhaite compter le nombre de caractères nuls :

#include <iostream>
#include <string>
#include <fstream>

using std::ios;
using std::cout;
using std::endl;
using std::string;
using std::ifstream;


int main()
{
    // --- Ouverture du fichier binaire ---
    ifstream f_bin ("binary_file.psq", ios::in | ios::binary);
    
    if (!f_bin.is_open())
    {
        cout << "Erreur lors de l'ouverture du fichier !" << endl;
        return 1;
    }
    
    
    // Obtenir la taille du fichier
    int length;

    f_bin.seekg (0, f_bin.end);
    length = f_bin.tellg();
    f_bin.seekg (0, f_bin.beg);
    
    
    
    // Lire tous les caractères du fichier
    // On souhaite compter le nombre de caractères nuls
    char cara;
    int  cnt = 0;
 
    for (int i = 0; i < length; ++i)
    {
        f_bin.read((char*) &cara, sizeof(char)); 
        
        if (cara == '\0')
            ++cnt;
    }
    
    cout << "Nombre de caractères nuls dans ce fichier binaire : "
         << cnt
         << endl;

    f_bin.close();
    return 0;
}

Je pense que le code fonctionne.
Mais est-ce la meilleure approche pour lire un fichier binaire et parvenir à l’objectif efficacement ?

Merci pour ces conseils, ça me sera bien utile !
Néanmoins, ma question était plutôt tournée sur l’utilisation de la librairie standard.

Ouvrir le fichier f_fin avec ifstream est-ce une bonne solution ?

Quelle différence avec fopen par exemple (il me semble que tout code C est compatible C++) ?
http://www.cplusplus.com/reference/cstdio/fopen/

Ou peut-être que je me trompe complètement, et qu’il n’existe que ifstream pour ouvrir un fichier binaire ? La documentation est très confuse par apport à ça je trouve.

je te renvoie la question pourquoi ifstream ne serait pas une bonne solution ? ifstream est fait pour ça . Après oui tu peux utiliser des fonctions du C mais je ne vois pas l’utilité ça ne changera pas de grand chose les performances si c’est ça ta question.

Ah d’accord, merci !
C’est que j’ai l’impression que la librairie standard du C++ contient milles arborescences sur la gestion des stream et je pensais qu’il existait peut-être une fonction plus appropriée, effectivement bien en regard des performances.

Du coup résolu.

Ok merci bien, et niveau performances les deux std::fopen std::ifstream sont équivalents ?

A contrario de fopen(), *fstream sont des capsules RAII qui vont te garantir la restitution de la ressource fichier quelque que soit le chemin pris pour quitter la fonction courante. Si tu utilise les handles du C, il te faut rajouter une couche de unique_ptr avec deleter qui va bien pour être sûr de bien fermer ton fichier même s’il y a des exceptions.

Sinon, pour du binaire, les performances devraient se valoir. Tu vas perdre bien plus de temps à lire octet par octet -> il faut lire par bloc. Après avec un std::count tu auras vite fait de compter tes 0.

PS: La présence de std::feof() du C ou std::*stream::eof() dans une boucle du C++ est un signe fort de bug. Le flag de fin de fichier n’est positionné qu’au moment où la fin est atteinte. Pas avant.
<EDIT>On va utiliser eof pour distinguer les causes de fin: problème majeur dans le fichier (disque corrompu, clé arrachée…), ou fin atteinte, plus le cas: fichier contenant des informations pas compatibles avec ce qui est attendu dans le cas des lectures formatées (genre f >> un_entier qui n’est pas entier).</EDIT>

std::ifstream f(name, std::ios_base::binary); // "in" est implicite sur un ifstream
if (!f) throw std::runtime_error("cannot open file " + name);
size_t nb = 0;

char buffer[4096]; // Je ne sais jamais quelles sont les bonnes tailles à prendre
while (f.read(buffer, std::size(buffer)) {
    nb += count(std::begin(buffer), std::end(buffer), 0);
}
nb += count(std::begin(buffer), std::begin(buffer)+f.gcount(), 0); // pas besoin de tester eof à apriori
// pas besoin de f.close(), c'est implicite à la fin de la portée de cette fonction qui ne doit pas être plus longue, SRP oblige!


// ou avec readsome
for (std::size_t n; (n = f.readsome(buffer, std::size(buffer))) > 0; ) {
    nb += count(std::begin(buffer), std::begin(buffer)+n, 0)
}