Leitura diretamente de um std :: istream em um std :: string

Question

Existe uma maneira de ler um número conhecido de bytes, diretamente em uma std :: string, sem a criação de um buffer temporário para fazê-lo?

por exemplo, atualmente eu posso fazer isso por

boost::uint16_t len;
is.read((char*)&len, 2);
char *tmpStr = new char[len];
is.read(tmpStr, len);
std::string str(tmpStr, len);
delete[] tmpStr;

Answer 1

std::string tem uma função resize você poderia usar, ou um construtor que vai fazer o mesmo:

boost::uint16_t len;
is.read((char*)&len, 2);

std::string str(len, '\0');
is.read(&str[0], len);

Esta é testado, e eu não sei se cordas são obrigados a ter armazenamento contíguo.

Answer 2

Você pode usar uma combinação de copy_n e um insert_iterator

void test_1816319()
{
    static char const* fname = "test_1816319.bin";
    std::ofstream ofs(fname, std::ios::binary);
    ofs.write("\x2\x0", 2);
    ofs.write("ab", 2);
    ofs.close();

    std::ifstream ifs(fname, std::ios::binary);
    std::string s;
    size_t n = 0;
    ifs.read((char*)&n, 2);
    std::istream_iterator<char> isi(ifs), isiend;
    std::copy_n(isi, n, std::insert_iterator<std::string>(s, s.begin()));
    ifs.close();
    _unlink(fname);

    std::cout << s << std::endl;
}

nenhuma cópia, sem hacks, sem possibilidade de superação, nenhum comportamento indefinido.

Answer 3

Você pode usar algo como getline:

#include <iostream>
#include <string>
using namespace std;

int main () {
  string str;
  getline (cin,str,' ');
}

Answer 4

Gostaria de usar um vetor como o buffer.

boost::uint16_t len;
is.read((char*)&len, 2); // Note if this file was saved from a different architecture 
                         // then endianness of these two bytes may be reversed.

std::vector buffer(len);  // uninitialized.
is.read(&buffer[0], len);

std::string  str(buffer.begin(),buffer.end());

Embora provavelmente você vai fugir com o uso de uma corda como o tampão (como descrito por GMan). Não é garantido pela norma que um cordas membros estão em locais consecutivos (de modo a verificar a sua implementação atual e colocar um grande comentário que ele precisa verificar ao portar para outro compilador / plataforma).

Answer 5

Você está apenas otimizando comprimento de código ou tentando salvar a si mesmo uma cópia aqui? O que há de errado com o buffer temporário?

Eu diria que você está realmente contornar as proteções da corda tentando escrever diretamente fazê-lo assim. Se você está preocupado com o desempenho da cópia para um std :: string, porque você identificou que é de alguma forma afetar o desempenho de sua aplicação, eu trabalhar diretamente com o caractere *.

EDIT: Fazer mais olhar ... Inicializar std :: string de char * sem cópia

Na segunda resposta, é afirmado muito categoricamente que você não pode conseguir o que você está olhando para conseguir (ie. Preencher um std :: string sem uma iteração sobre o char * para copiar.)

Dê uma olhada em sua rotina de carga (postá-lo aqui, talvez?) E minimizar alocações: nova e excluir certamente não são livres para que você possa, pelo menos, poupar algum tempo se você não tem que recriar o buffer constantemente . Eu sempre achei apagar útil lo por memset'ing buffer para 0 ou nulo que encerra o primeiro índice do array cada iteração, mas você pode eliminar rapidamente que o código do interesse de desempenho uma vez que você está confiante em seu algoritmo.

Answer 6

Uma maneira fácil seria:

std::istream& data
const size_t dataSize(static_cast<size_t>(data.rdbuf()->in_avail()));
std::string content;
content.reserve( dataSize);
data.read(&content[0], dataSize);