Come posso leggere esattamente 128 byte da un flusso in un oggetto stringa?

Question

Come faccio a leggere esattamente 128 byte da un flusso in un oggetto stringa?

Ho scritto un codice per leggere i primi 128 byte di un file e stamparlo e quindi gli ultimi 128 byte del file e stamparlo. L'ultima parte funziona, dal momento che si può facilmente iterare a EOF, ma come faccio a ottenere esattamente 128 byte dal fronte? Il codice sottostante non funziona poiché non è possibile aggiungere 128 a un iteratore ifstream, non è indicizzabile, solo incrementabile (sembra).

Certo, potrei fare un iteratore e * + + 128 volte, ma ci deve essere una linea semplice per farlo, giusto?

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

int main(int argc, char **argv) 
{ 
    std::ifstream ifs ("input.txt",std::ifstream::in | std::ifstream::binary); 

    if (ifs.good()) 
    { 
    // read first 128 bytes into a string 
     ifs.seekg(0,std::ifstream::beg); 
     std::string first128((std::istreambuf_iterator<char>(ifs)), 
          (std::istreambuf_iterator<char>(ifs))+128); 

     std::cout << first128 << std::endl; 

    // read last 128 bytes into a string 
     ifs.seekg(-128,std::ifstream::end); 
     std::string last128((std::istreambuf_iterator<char>(ifs)), 
          std::istreambuf_iterator<char>()); 

     std::cout << last128 << std::endl; 

     return 0; 
    } 

    return 1; 
} 

Answer 1

char buffer[129]; 
ifs.read (buffer,128); 
buffer[128] = '\0'; 
first128 = buffer; 

Che ne dite di questo allora:

template <typename Itr, typename Out> 
void copy_n(Itr it, size_t count, Out out) 
{ 
    for(size_t i=0;i<count;++i) 
     out = *it++; 
} 

... 

std::string first128; 
std::istreambuf_iterator<char> it(ifs); 
copy_n(it, 128, 
    std::back_inserter<std::string>(first128)); 

Answer 2

La mia risposta utilizza un buffer intermedio, ma forse saranno felici che utilizza iteratori per inizializzare la stringa dal buffer.

std::vector<char> buffer(128); // create a buffer 
ifs.read(&buffer[0], buffer.size()); // read to buffer 
std::string first128(buffer.begin(), buffer.end()); // copy from vector 

Per me sembra che siano diventati un po 'troppo carini con l'implementazione di iostream. Cercare di utilizzare gli iteratori per l'I/O del flusso è eccessivamente complicato.

A proposito, sospetto che l'implementazione che stavate tentando, sotto le copertine, eseguisse una varietà di buffering intermedio (forse alcuni nel kernel, alcuni nella libreria) oltre a riassegnare e copiare la stringa più volte man mano che cresce.

Un'altra idea: hai davvero bisogno del risultato in una stringa standard? Si potrebbe semplicemente lavorare dal vettore - evitando il passaggio finale di copiare su una stringa. Oppure, se ti senti avventuroso, potresti creare la tua classe di stringhe che compie consentendoti di esporre il buffer interno nello stesso modo in cui lo fa il vettore.

Answer 3

qui ho alcuni di ricerca sopra streambuffer, leggere direttamente alla stringa dal istream dal costruttore:

class mystringbuf : public std::stringbuf 
{ 
public: 
    explicit mystringbuf(std::istream& istr, size_t n, 
         std::ios_base::openmode __mode = std::ios_base::in) 
    { 
     _M_string.resize(n); 
     std::stringbuf::_M_stringbuf_init(__mode); 
     istr.read(gptr(), n); 
    } 
public: 
    std::stringbuf::char_type* gptr() const 
    { 
     return std::stringbuf::gptr(); 
    } 
    std::string& str_ref(){ 
     return _M_string; 
    } 
}; 
std::ostream& operator << (std::ostream& ostr, mystringbuf& buf){ 
    ostr << buf.str_ref(); 
    return ostr; 
} 

Esempio d'uso:

using std::cout; 
using std::endl; 

int main() 
{ 
    std::stringbuf buffer;   // empty buffer 
    buffer.str("abc def ABC DEF "); // not empty now 
    std::istream is (&buffer);  // associate stream buffer to stream 
    mystringbuf data(is, 10);  // read 10 bytes 
    cout << "data=" << data << endl; 
    return 0; 
} 

uscita:

data=abc def AB 

prega inoltrami se sono da qualche parte sbagliata.