istream vs mappage de la mémoire d'un fichier?

Je suis en train de mapper un fichier dans la mémoire et ensuite d'analyser ligne par ligne - est istream ce que je devrais utiliser?

Est istream le même que l'association d'un fichier de la mémoire sous Windows? J'ai eu des difficultés en essayant de trouver un exemple complet de la cartographie d'un fichier dans la mémoire.

J'ai vu des gens lien mappage de la mémoire d'articles à partir de MSDN, mais si quelqu'un peut recommander un petit (~15 ligne?) exemple je vous en serais très reconnaissant.

Je dois être à la recherche de quelque chose de mal, mais lors de la recherche de "C++ mappage de la mémoire exemple" sur Google, je ne pouvais pas trouver un exemple qui inclus une itération à travers.

Ceux-ci étaient les plus proches des résultats (juste pour les gens de réaliser que je ont regardé):

"je suis en train de mapper un fichier dans la mémoire et analyser ligne par ligne". Pouvez-vous nous dire pourquoi vous voulez à la carte mémoire le fichier? Pourquoi n'est-ce pas l'analyse ligne par ligne (à l'aide, dire, ifstream ou fopen) est-elle suffisante?
purement pour des raisons de performances. J'ai été sous le (faux?) impression qu'il est plus rapide de cartographie de l'ensemble du dossier?
Cela dépend de ce que vous faites avec les données. Si vous l'utilisez pour un bon analyseur qui implémente les retours en arrière, puis les fichiers mappés en mémoire sont uncontestedly plus vite, mais si vous êtes juste de l'itération transmet à travers les données (comme avec de multiples simple std::getline appels), je doute qu'il y aura aucune différence notable. Certainement il n'y a pas de dommage à l'aide d'un fichier mappé en mémoire, sauf si vous êtes faible sur l'espace d'adressage virtuel (probablement un problème dans le code 32 bits avec GO+ taille des fichiers).
mmap-ing, le dossier peut être un peu le plus rapide. BTW, sur Linux, fopen(3) sait à propos de la m modificateur de mode pour mapper le fichier. Cependant, êtes-vous sûr que cela en vaut la peine? Avez-vous référence? Je suppose que vous allez gagner seulement quelques pour cent de la performance. N'est que pour vous?

OriginalL'auteur user997112 | 2012-05-31

  1. 12

    std::istream est un type abstrait – vous ne pouvez pas l'utiliser directement. Vous devriez être en tirent avec un tableau personnalisé adossés à des streambuf:

    #include <cstddef>
#include <string>
#include <streambuf>
#include <istream>

template<typename CharT, typename TraitsT = std::char_traits<CharT>>
struct basic_membuf : std::basic_streambuf<CharT, TraitsT> {
    basic_membuf(CharT const* const buf, std::size_t const size) {
        CharT* const p = const_cast<CharT*>(buf);
        this->setg(p, p, p + size);
    }

    //...
};

template<typename CharT, typename TraitsT = std::char_traits<CharT>>
struct basic_imemstream
: virtual basic_membuf<CharT, TraitsT>, std::basic_istream<CharT, TraitsT> {
    basic_imemstream(CharT const* const buf, std::size_t const size)
    : basic_membuf(buf, size),
      std::basic_istream(static_cast<std::basic_streambuf<CharT, TraitsT>*>(this))
    { }

    //...
};

using imemstream = basic_imemstream<char>;

char const* const mmaped_data = /*...*/;
std::size_t const mmap_size = /*...*/;
imemstream s(mmaped_data, mmap_size);
//s now uses the memory mapped data as its underlying buffer.

    Comme pour la carte mémoire elle-même, je vous recommande d'utiliser Coup de pouce.Interprocessus à cet effet:

    #include <cstddef>
#include <string>
#include <boost/interprocess/file_mapping.hpp>
#include <boost/interprocess/mapped_region.hpp>

namespace bip = boost::interprocess;

//...

std::string filename = /*...*/;
bip::file_mapping mapping(filename.c_str(), bip::read_only);
bip::mapped_region mapped_rgn(mapping, bip::read_only);
char const* const mmaped_data = static_cast<char*>(mapped_rgn.get_address());
std::size_t const mmap_size = mapped_rgn.get_size();

    le Code pour imemstream prises de cette réponse par Dietmar Kühl.

    d'où l'apport de mmaped_data venir? Nous avons besoin d'une référence pour le fichier, je suppose?
    Cela dépend sur quelle plate-forme vous êtes sur -- C++ standard ne fournit pas les fichiers mappés en mémoire. Sur *nix, il y a mmap; sur Windows, il y a CreateFileMapping. Personnellement, j'utilise Boost.Interprocessus'les fichiers mappés en mémoire, car ils sont multi-plateforme; je vais modifier dans un exemple pour cela.
    Merci, l'apprécie beaucoup
    Si vous êtes à la cartographie d'un fichier texte sur Windows, vous devrez peut-être faire face avec '\r' dans le istringstream manuellement.
    getline(s,ligne) << endl; (de chat) est incorrect. getline n' pas de retour de la chaîne qui a été lu. Essayez while(std::getline(s, line)) { std::cout << line << "\n"; }

    OriginalL'auteur ildjarn

  2. 1

    Est istream le même que l'association d'un fichier de la mémoire sous windows?

    Pas exactement. Ils ne sont pas les mêmes dans le même sens d'un "stream" n'est pas un "fichier".

    Pense à un fichier stocké séquence, et à un flux de données comme interface pour le "canal" (un stream_buffer) que la séquence de flux lorsque le déménagement de son magasin vers la réception de variables.

    Pense à un fichier mappé en mémoire en tant que "fichier"- au lieu de cela stockée à l'extérieur de l'unité de traitement - sont stockées dans de synchronisation dans la mémoire. Il a l'avantage d'être visible comme un cru de la mémoire tampon d'un fichier. Si vous voulez le lire comme un ruisseau, le plus simple est probablement à l'aide d'un istringstream qui a cru tampon comme le lieu de la lecture.

    Pour être honnête, je préfère lire le fichier en entier à la fois, par opposition à un flux
    Cela dépend de ce que tu vas faire avec son contenu. Si le fichier est un texte et vous, qu'à lire les chiffres, vous devez analyser en quelque sorte. Le std::istream (et dérivés) sont juste que de l'analyseur.

    OriginalL'auteur Emilio Garavaglia