come leggere i file di immagine e memorizzarli in memoria (std :: string) in C++?

Question

ho ricercato online per la maggior parte di oggi ma non sono riuscito a trovare la risposta, quindi mi sto rivolgendo allo stackoverflow per qualche suggerimento.

In sostanza, ho una libreria C++ che usa arricciatura per eseguire il metodo PUT per caricare un file immagine. ora questa libreria prende una std :: string per i dati. Ho file di immagine (come jpg, gif, png) sul mio disco locale.

Non mi interessa il contenuto del file (come in, non faccio niente con esso oltre a passarlo a questa libreria per il metodo PUT). come posso leggere i file immagine e memorizzarli in std :: string? Cosa succede se il contenuto del file contiene il terminatore NULL?

Ho provato ad aggiungere alcuni codici che ho provato, ma sono nuovo qui e non sono sicuro di come incollare il mio codice qui nel formato corretto. Qualsiasi aiuto sarebbe apprezzato.

Answer 1

Il metodo più semplice a cui riesco a pensare. Apri il file in modalità binaria, quindi leggi l'intera cosa in un stringstream.

std::ifstream fin("foo.png", std::ios::in | std::ios::binary); 
std::ostringstream oss; 
oss << fin.rdbuf(); 
std::string data(oss.str()); 

Answer 2

std::ifstream fin("foo.png", std::ios::binary); 
std::string data; 
data.reserve(1000000); 
std::copy(std::istreambuf_iterator<char>(fin), 
      std::istreambuf_iterator<char>(), 
      std::back_inserter(data)); 

Si può leggere i file di immagine per std::string con codice come questo. Regola il parametro per il metodo reserve in modo che sia più grande del 99% delle dimensioni del tuo file. Zero byte (che si chiamano terminatori NULL) vengono trattati correttamente con entrambi ifstream e string.

---

ho trovato un buon article, dove sono confrontati diversi metodi di caricamento del file binario. Ecco il metodo più veloce da tale articolo:

std::ifstream fin("foo.png", std::ios::binary); 
fin.seekg(0, std::ios::end); 
std::string data; 
data.resize(fin.tellg()); 
fin.seekg(0, std::ios::beg); 
fin.read(&data[0], data.size()); 

Ed ecco il più breve:

std::ifstream fin("foo.png", std::ios::binary); 
std::string data((std::istreambuf_iterator<char>(fin)), 
       std::istreambuf_iterator<char>()); 

---

Aggiornamento

Qualcosa di simile può essere utilizzata per alimentare il callback funzione (non l'ho provato):

std::ifstream fin("foo.png", std::ios::binary); 
fin.seekg(0, std::ios::end); 
... 
curl_easy_setopt(m_ctx, CURLOPT_INFILESIZE, fin.tellg()); 
curl_easy_setopt(m_ctx, CURLOPT_READDATA,  (void *)&fin); 
fin.seekg(0, std::ios::beg); 
... 
static size_t put_callback(void *ptr, size_t size, size_t nmemb, void *data){ 
    std::ifstream* in = static_cast<std::ifstream*>(data); 
    if(in->eof()) return 0; 
    in->read((char *)ptr, size*nmemb); 
    return in->gcount(); 
} 

Answer 3

questo è come la biblioteca effettua chiamate PUT dove 'dati' è stringa passata come contenuto del file

stringstream data_stream.str(data.c_str()); 
curl_easy_setopt(m_ctx, CURLOPT_UPLOAD,  1L); 
curl_easy_setopt(m_ctx, CURLOPT_PUT,   1L); 
curl_easy_setopt(m_ctx, CURLOPT_INFILESIZE, data.length()); 
curl_easy_setopt(m_ctx, CURLOPT_READFUNCTION, put_callback); 
curl_easy_setopt(m_ctx, CURLOPT_READDATA,  (void *)&data_stream); 
curl_easy_setopt(m_ctx, CURLOPT_WRITEFUNCTION, get_callback); 
curl_easy_setopt(m_ctx, CURLOPT_WRITEDATA,  (void *)&m_request_response); 

ed ecco il frunction callback per curlopt_readfunction

static size_t put_callback(void *ptr, size_t size, size_t nmemb, void *data){ 

    stringstream *output_stream; 
    int   retval; 

    output_stream = (stringstream *) data; 

    if(output_stream->eof()) return 0; 

    retval = min(size*nmemb,output_stream->str().size()); 
    output_stream->read((char *)ptr, retval); 

    //return the number of bytes processed 
    return retval; 
}