Pass std::string to a function f(**char)

Is it possible to pass the pointer of a std::string to a function which expects a **char? The function expects a **char in order to write a value to it.

Currently I am doing the following:

char开发者_开发技巧 *s1;
f(&s1);
std::string s2 = s1;

Is there no shorter way? It is obvious, that s2.c_str() does not work, since it returns const *char.

That's the appropriate way to handle that sort of function. You cannot pass in the std::string directly because, while you can convert it to a C string, it is laid out in memory differently and so the called function would not know where to put its result.

If possible, however, you should rewrite the function so it takes a std::string& or std::string * as an argument.

(Also, make sure you free() or delete[] the C string if appropriate. See the documentation for whatever f() is to determine if you need to do so.)

No, that's not possible. The function overwrites the pointer (s1) itself. You could pass in the data array from the string (&s2[0]) but that would only allow you to overwrite the currently reserved content space, not the pointer.

The function also somehow allocates memory for the string. You may need to clean that up too. If it had worked, how would it have been cleaned up?

You cannot - the string's char buffer is not writeable, and you shouldn't do it. You can always use an intermediate buffer:

const size_t n = s2.size();

char buf[n + 1];
buf[n] = 0;

std::copy(s2.begin(), s2.end(), buf);

f(&buf);

s2.assign(buf, n);

Yes, write a wrapper function/macro then just use it

One way you can pass your string into your function is to have your string

std::string name;

As the data-member of your object. And then, in the f() function create a string like you did, and pass it by reference like you showed

void f( const std::string & parameter_name ) {
    name = parameter_name;
}

Now, to copy the string to char * so you can pass it into a function as a char reference:

From this link:

If you want to get a writable copy like str.c_str(), like char *, you can do that with this:

std::string str;
char * writable = new char[str.size() + 1];
std::copy(str.begin(), str.end(), writable);
writable[str.size()] = '\0'; // don't forget the terminating 0

// don't forget to free the string after finished using it
delete[] writable;

the above is not exception safe!

You can then pass the char * writable into your f() function by reference.