22

Say I have an array of chars, which I have allocated on the heap, and which I want to convert into an std::string. Currently I am doing the following:

char *array = new char[size];
WriteIntoArray(array, size);
std::string mystring(array);
delete[] array;
return mystring; // or whatever

From what I read on the internet (http://www.cplusplus.com/reference/string/string/string/), the string constructor performs a copy of the buffer I pass it, leaving me to free the buffer (later, the string frees its internal buffer). What I would like to do is to allocate my buffer, transfer control of it to the string, and then have it free my buffer when it is destructed.

The question initializing std::string from char* without copy looked promising, but my code relies on API calls ("WriteIntoArray" in the above example) which have to write into an array of chars, so I have to create a C-style char* buffer, and cannot convert my code to use only built-in string operations (which was the answer suggested).

Is there some standard way to do this, or should I just write my own string class (ugh)? Thanks!

Improve this question

3 Answers 3

Reset to default
19

If you're using a conforming C++0x implementation, or one of the many C++ libraries that guarantee contiguous storage for std::string, then you can get a char* that points directly to the storage used by your std::string.

For example:

std::string mystring;
mystring.resize(size);
WriteIntoArray(&mystring[0], size);
return mystring;

You may have to think carefully about a null terminator, however.

Improve this answer
Sign up to request clarification or add additional context in comments.

14 Comments

No. reserve() reserves the space, but it does not belong to the string (yet). Accessing a[0] or a[1] is still UB. If you checkout size() it will still be zero. What you actual want is resize()
You can't use reserve(), you must use resize(). And then figure out a proper resize() after the call.
reserve needs to be resize. What does "think carefully about a null terminator" really mean? Are any guarantees made as to whether the array pointed to by &mystring[0] must be null-terminated? Is std::string responsible for ensuring that such a terminator is there? If WriteIntoArray writes a null terminator, should it be removed? (I ask because I don't know what is guaranteed and required by std::string.)
Presumably WriteIntoArray puts on a null terminator, which would need to be removed after the call; you probably want to add mystring.resize(size-1); just before returning. If it doesn't add the null, then you should be using vector<char> instead of string.
@SørenLøvborg Yes, it is permitted in C++11. There's a lot of arcane wording around this, which pretty much boils down to it being illegal to modify the null terminator, and being illegal to modify anything through the data() or c_str() pointers, but valid through &str[0]. stackoverflow.com/a/14291203/5696
|
12

You may implement your own std::allocator that instead of allocating new memory for your string, uses as the source the region you already have instantiated.

You should then instantiate your std::string using your allocator.

http://www.codeproject.com/Articles/4795/C-Standard-Allocator-An-Introduction-and-Implement

Improve this answer

1 Comment

Cool idea, totally forgot about allocators.
6

You can't std::string owns the pointer and thus copies the data into a space that it allocates.

What you could do is:

std::string  mystring(size, ' ');
WriteIntoArray(&mystring[0], size);
return mystring; // or whatever
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.