cómo leer archivos de imagen y almacenarlos en la memoria (std :: string) en C++?

Question

he investigado en línea la mayor parte de hoy pero no he podido encontrar la respuesta, así que estoy recurriendo a stackoverflow por alguna sugerencia.

básicamente, tengo una biblioteca de C++ que utiliza curl para realizar el método PUT para cargar un archivo de imagen. ahora esta biblioteca toma una std :: string para datos. Tengo archivos de imagen (como jpg, gif, png) en mi disco local.

no me importa el contenido del archivo (como en, no hago nada con él además de pasarlo a esta biblioteca para el método PUT). ¿Cómo puedo leer archivos de imagen y almacenarlos en std :: string? ¿y si el contenido del archivo contiene el terminador NULL?

intenté agregar algunos de los códigos que he probado, pero soy nuevo aquí y no estoy seguro de cómo pegar mi código aquí en el formato correcto. Cualquier ayuda sería apreciada.

Answer 1

El método más fácil que se me ocurre. Abra el archivo en modo binario, luego lea todo en 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)); 

Usted puede leer archivos de imagen a std::string con código como este. Ajuste el parámetro para el método reserve para que sea mayor que el 99% de los tamaños de sus archivos. Los bytes cero (que llama terminadores NULL) se tratan correctamente con ifstream y string.

---

he encontrado una buena article, donde se comparan varios métodos de carga del archivo binario. Aquí es el método más rápido de ese artículo:

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()); 

Y aquí es la más corta:

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

---

actualización

Algo como esto puede ser utilizado para alimentar a la devolución de llamada función (no la probé):

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

esta es la forma en la biblioteca hace llamadas puestas en 'datos' es cadena pasada como el contenido del archivo

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); 

y aquí está la frunction devolución de llamada para 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; 
}