Direkt von einem std :: istream in einen std :: string lesen

Question

Gibt es trotzdem eine bekannte Anzahl von Bytes direkt in eine std :: string zu lesen, ohne dafür einen temporären Puffer zu erstellen?

zB zur Zeit kann ich es tun, indem

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 hat eine resize Funktion, die Sie könnten, oder einen Konstruktor verwenden, die das gleiche tun werden:

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

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

Dies ist nicht getestet, und ich Ich weiß nicht, ob Strings einen zusammenhängenden Speicher benötigen.

Answer 2

Sie optimieren nur die Codelänge oder versuchen, sich hier eine Kopie zu ersparen? Was ist falsch mit dem temporären Puffer?

Ich würde argumentieren, dass Sie tatsächlich den Schutz der Schnur umgehen versuchen, direkt zu versuchen, es so zu tun. Wenn Sie sich Sorgen über die Leistung der Kopie in einer std :: string machen, weil Sie festgestellt haben, dass sie die Leistung Ihrer Anwendung in irgendeiner Weise beeinflusst, würde ich direkt mit dem char * arbeiten.

EDIT:. Doing mehr suchen ... initializing std::string from char* without copy

In der zweiten Antwort, es ist ziemlich flach festgestellt, dass Sie nicht erreichen können, was Sie suchen (dh zu erreichen, füllen Sie eine std :: string ohne eine Wiederholung über den char * zu kopieren.)

Werfen Sie einen Blick auf Ihre Load-Routine (Post es hier vielleicht?) und minimieren Zuweisungen: neu und löschen sind sicherlich nicht frei, so dass Sie zumindest etwas Zeit sparen können, wenn Sie müssen den Puffer nicht ständig neu erstellen. Ich finde es immer hilfreich, es zu löschen, indem ich den Puffer auf 0 oder null setze, um den ersten Index des Arrays bei jeder Iteration zu beenden, aber Sie können diesen Code im Interesse der Leistung schnell entfernen, sobald Sie in Ihrem Algorithmus sicher sind.

Answer 3

Man könnte so etwas wie getline verwenden:

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

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

Answer 4

Ich würde einen Vektor als Puffer verwenden.

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

Obwohl Sie wahrscheinlich mit der Verwendung einer Zeichenfolge als Puffer (wie von GMan beschrieben). Es ist nicht durch den Standard garantiert, dass ein Strings-Member an aufeinanderfolgenden Orten ist (also überprüfe deine aktuelle Implementierung und schreibe einen großen Kommentar, den sie überprüfen muss, wenn sie auf einen anderen Compiler/eine andere Plattform portiert).

Answer 5

Sie könnten eine Kombination aus copy_n verwenden und eine 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; 
} 

kein Kopieren, keine Hacks, keine Möglichkeit, überrannt, kein undefiniertes Verhalten.

Answer 6

Eine einfache Möglichkeit wäre:

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