Question

Is it possible to use an std::string for read() ?

Example :

std::string data;

read(fd, data, 42);

Normaly, we have to use char* but is it possible to directly use a std::string ? (I prefer don’t create a char* for store the result)

Thank’s

Answer 1

Well, you’ll need to create a char* somehow, since that’s what the
function requires. (BTW: you are talking about the Posix function
read, aren’t you, and not std::istream::read?) The problem isn’t
the char*, it’s what the char* points to (which I suspect is what
you actually meant).

The simplest and usual solution here would be to use a local array:

char buffer[43];
int len = read(fd, buffer, 42);
if ( len < 0 ) {
    //  read error...
} else if ( len == 0 ) {
    //  eof...
} else {
    std::string data(buffer, len);
}

If you want to capture directly into an std::string, however, this is
possible (although not necessarily a good idea):

std::string data;
data.resize( 42 );
int len = read( fd, &data[0], data.size() );
//  error handling as above...
data.resize( len );  //  If no error...

This avoids the copy, but quite frankly… The copy is insignificant
compared to the time necessary for the actual read and for the
allocation of the memory in the string. This also has the (probably
negligible) disadvantage of the resulting string having an actual buffer
of 42 bytes (rounded up to whatever), rather than just the minimum
necessary for the characters actually read.

(And since people sometimes raise the issue, with regards to the
contiguity of the memory in std:;string: this was an issue ten or more
years ago. The original specifications for std::string were designed
expressedly to allow non-contiguous implementations, along the lines of
the then popular rope class. In practice, no implementor found this
to be useful, and people did start assuming contiguity. At which point,
the standards committee decided to align the standard with existing
practice, and require contiguity. So… no implementation has ever not
been contiguous, and no future implementation will forego contiguity,
given the requirements in C++11.)