La lettura di un file in un vettore tutto in una volta

Question

Si tratta di una buona idea per la lettura in un std::vector, o c'è qualche Gotcha qui:

using namespace std; 
ifstream file("blah.dat", ios::binary); 

vector<T> v(N); 

file.read(static_cast<char*>(v.data()), N * sizeof(T)); 

fa il vector serie mi permetterà di fare questo per popolare un vettore ? Per motivi di semplicità, supponiamo che T sia un semplice vecchio tipo di dati.

Answer 1

Qui non c'è un comportamento non definito se T è banalmente copiabile, quali sono certamente i POD. vector<T>::data è garantito per restituire un puntatore a un array contiguo di vector<T>::sizeT s e la rappresentazione dell'oggetto di un tipo banalmente copiabile T è una sequenza contigua di sizeof(T) byte (che potrebbe includere il riempimento interno).

Se i byte memorizzati in quello spazio non sono validi rappresentazioni oggetto T, è possibile ottenere un comportamento non definito quando si accede a loro. Esattamente quali sequenze di byte costituiscono una rappresentazione oggetto valida T è un po 'un'area grigia; per lo meno dovresti essere in grado di scrivere in modo portabile i byte sottostanti di un oggetto di un tipo banalmente copiabile in un file e rileggerli correttamente nei byte sottostanti di un oggetto dello stesso tipo.

Per l'amor di paranoia, probabilmente sarei messo:

static_assert(std::is_trivially_copyable<T>(), 
       "NO NO NO - T MUST BE TRIVIALLY COPYABLE!"); 

prima della file.read per future-proofing.

Answer 2

Non sono tenuti a farlo, in realtà quello che si suppone di fare (dal momento che il C++ originale) è questo

std::ifstream file("foo.txt"); 
file >> std::noskipws;   // use this line so that whitespace won't be skipped 
std::vector<char> buffer(std::istream_iterator<char>(file), 
         std::istream_iterator<char>()); 

La ragione per cui non si dovrebbe fare a modo tuo è perché non ha senso che un oggetto viva in un file (almeno in C++). I file contengono solo caratteri, che vengono quindi formattati da operator>> per creare oggetti. Lo standard consente al compilatore di fare cose davvero strane ad un oggetto (specialmente quando RTTI è abilitato) che rende inutile "salvare" un oggetto su un file. Stai molto meglio semplicemente creando il tuo formato di serializzazione per questo.

Answer 3

Sembra che si trarrebbe vantaggio da un file mappato in memoria. Boost fornisce due implementazioni, quindi non devi scherzare con mmap() direttamente.

Utilizzando boost.iostreams:

#include <boost/iostreams/device/mapped_file.hpp> 

boost::iostreams::mapped_file_source file("blah.dat"); 
std::size_t size = file.size()/sizeof(T); 
const T * ptr = reinterpret_cast<const T*>(file.data()); 
for (std::size_t i=0; i<size; ++i) 
    std::cout << ptr[i] << std::endl; 

È inoltre possibile utilizzare boost.interprocess, ma richiede più codice per essenzialmente la stessa funzionalità.

Il vantaggio principale è che non si alloca memoria per accedere al file, verrà caricato su richiesta al momento dell'accesso ai dati. I dati stessi vivranno in cache/pagine bufferizzate, quindi non occupano più memoria (vengono scartati se il sistema ha bisogno di memoria per qualcos'altro.)