Currently I have a complex function that myself and our team are not wanting to refactor to utilize std::string and it takes a char* which is modified. How would I properly make a deep-copy of string::c_str() into a char*? I am not looking to modify the string's internally stored char*.
char *cstr = string.c_str(); fails because c_str() is const.
You can do it like this:
const std::string::size_type size = string.size(); char *buffer = new char[size + 1]; //we need extra char for NUL memcpy(buffer, string.c_str(), size + 1); 
std::string::size_type or std::size_t.
std::vector<char> to do that for you, and access the array as v.data() or &v[0]. Or even another string, if you don't mind borderline-undefined behaviour.Rather than modify the existing function, I'd just create an overload that acts as a wrapper. Assuming the existing function is ret_type f(char *), I'd write the overload something like:
ret_type f(std::string s) { return f(&s[0]); } Note passing s by value instead of reference, minimizing the effort expended to get a copy of the string.
In theory, this isn't guaranteed to work (i.e., a string's buffer isn't guaranteed to be contiguous) until C++03. In reality, that guarantee was fairly easy for the committee to add primarily because nobody knew of an implementation of std::string that did anything else.
Likewise, it could theoretically be missing the NUL terminator. If you're concerned about that possibility you could use return f(const_cast<char *>(s.c_str())); instead, or add an s.push_back('\0'); before the return:
ret_type f(std::string s) { s.push_back('\0'); return f(&s[0]); } 
s.push_back( '\0' ) in your wrapper function, just to be sure. And you surely meant const_cast in the last bit of code.
The obvious solution is:
std::vector<char> tmp( string.begin(), string.end() ); tmp.push_back( '\0' ); function( &tmp[0] ); (I rather like Jerry Coffin's solution, however.)
std::stringand use&stringCopy[0].strdup,new/strcpy, @chris' suggestion, ... You have the choice.