Can we swap char* with std::string

Question

Is it legal to modify the result of std::string::op[]?

I would like to swap the contents of char* and std::string and could not do it. After going through the above link, I'm still unable to get the answer for my question.

This is what I am trying to do and could not succeed in swapping the string with char*. The code is verified on VS2010.

UPDATE 1 All the effort is to see if I could gain any performace and not gain any SO points. :-)
UPDATE 2 I mentioned in the comments why I intend to do this. Do people still believe that this requires to be on hold ?

void Swap(char* const& left, char* const& right)
{
    std::swap(const_cast<char*>(left), const_cast<char*>(right));
}



std::string ToString()
{
   std::string ret(1, ' ');
   char* str = new char[6]();
   strcpy(str, "Jagan");
   Swap(&ret[0], str);

    return ret;
}

Answer 1

It cannot be done.

std::string provides no standard way for you to replace its internal data pointer.

In fact, not all implementations of std::string always have a pointer to a zero-terminated block of characters allocated using new[]. You are not supposed to know, and you're certainly not supposed to rely on it if you found out anyway (information hiding/implementation hiding).

Different std::string implementations might do any of the following:

• keep the size separately from a non-zero-terminated char *. Other than classic C strings, instances of std::string are allowed to contain null characters.
• the above, but shared between different std::strings with reference counts. You don't want to interfere here.
• have a stack-allocated char [16] that is used for short strings instead of a heap pointer

This is why you're stuck with copying the contents of a std::string when you want to swap with a char* that you manage yourself.

Answer 2

All the code &ret[0] does is create a temporary variable that is a pointer to the characters in ret. The call to swap sets this temporary variable to the pointer str, and str to this temporary variable. The result is that ret is unaffected and you leak the memory in str. To make it clearer, this code is equivalent to

char* str = new char[6]();
strcpy(str, "Jagan");
char* tmpPtr = &ret[0]
Swap(tmpPtr, str);

So you can see at the end of it tmpPtr is equal to the original value of str. There's simply no way for you to get to the internal char* pointer within str. And this is deliberate, because the wider question is why would you want to do this? Even if you could assign to the internal pointer of str, doing so would violate encapsulation -- you'd be assuming that the internal pointer was allocated using new for example. But stl containers can -- and do -- use their own internal allocation mechanisms, and ought to be free to change their implementations in the future without client code breaking. Just as you can change the implementations of your classes without your clients' code breaking.

Answer 3

Yes, as you saw in the linked post, you can modify the value of string[x] provided that x >= 0 && x < string.size() but the standard is quite clear that you can't modify anything else (and you certainly can't pass around &string[x] as a valid pointer-to-modifiable-null-terminated-string -- remember that string.c_str() and string.data() return a const char*.

You can, however, implement:

void swap(std::string& left, char* right) {
  auto right_size = std::strlen(right);
  auto left_size = left.size();
  assert(left_size <= right_size);
  std::string temp = std::move(left);
  left = right;
  std::copy(std::begin(temp), std::end(temp), right);
  right[left_size] = '\0';
}

inline void swap(char* left, std::string& right) {
  swap(right, left);
}

(live here)

Answer 4

What you are doing is wrong on so many levels.

To "swap" a std::string with a manually managed string pointed to by a char *, you need to manually manage that string, as in:

std::string one = ...;
char *two = ...;

// swap:
std::string tmp = two;
delete[] two;
two = new char[one.size() + 1];
memcpy(two, one.c_str(), one.size() + 1);
one = tmp;