Convert std::string to char * in c++11

Question

I am writing a library for mixed-languages and so we have to stick to a C interface. I need to call this API function:

void getproperty(const char * key, /* in  */ 
                 char * value      /* out */) {

I need to set value with the contents of an std::string.

std::string stdString = funcReturningString();
// set value to contents of stdString

I've seen lots of answers on possible strategies, but none for this specific use-case and neither were any considered the "best" or "standard." We are using C++11, for what its worth. Some of the answers vaguely recommended copying the contents of the string to a buffer and using that. But how to do it? I would like some more opinions on this conversation so I can finally pick a strategy and stand by it.

Thank you!

UPDATE: Here is the solution I used

I am using uint32_t to keep consistent with the other API functions. bufferSize is a reference because FORTRAN calls everything by reference.

void getproperty(const char * key,            /* in  */ 
                 const uint32_t & bufferSize, /* in  */
                 char * value,                /* out */
                 uint32_t & error             /* out */) 
{
  std::string stdString = funcReturningString();

  if (bufferSize < str.size() + 1) {
    // Set the error code, set an error message, and return
  }

  strcpy(value, stdString.c_str());
}

I chose strcpy() to keep everything standard and I chose a bufferSize parameter so that I wouldn't have to worry about some of problems of double indirection mentioned in the comments.

Answer 1

It seems like the getproperty API call is flawed. There is no way for the caller to state the length of value. This means the implementation of getproperty can't safely write into value because it has no idea how long it is. The getproperty method either needs to be changed to take a char** value or to take the length of the value buffer as a parameter. Let's assume the latter is done

void getproperty(const char* key, char* value, size_t valueLength);

Now in order to copy the contents of the value returned from funcReturningString we just need to use strncpy

std::string stdString = funcReturningString();
strlcpy(value, stdString.c_str(), valueLength);

Note that this is still flawed. If valueLength == 0 or its less than the length of the string then this won't work. It'd probably be best to change getproperty to also return an error code of some sort so that failures like this can be communicated to the caller

Answer 2

A simple approach would be:

strcpy(value, stdString.c_str());

But you need to be careful of buffer overruns. Ideally the caller to this function should also give the size of the buffer it is providing to ensure you don't write past the end of it. One way of doing this is to pass an extra parameter buffer_size and to use

strncpy(value, stdString.c_str(), buffer_size);
if (buffer_size > 0) value[buffer_size-1] = 0;

Otherwise, shorten the stdString first before copying.

Answer 3

If you need to get modifiable copy of value you should allocate memory yourself, also type of value should be pointer-to-pointer.

void getproperty(const char * key, /* in  */ 
                 char ** value     /* out */) {
  if (value == NULL) {
      // ERROR
      return;
  }

  const std::string& stdString = funcReturningString();

  // if this function is called from C 
  // you need to use 'malloc' instead of 'new' operator
  *value = malloc(stdString.size() + 1); // +NUL
  if (*value == NULL) {
      // ERROR mem alloc
      return;
  }

  memcpy(*value, stdString.c_str(), stdString.size() + 1); // +NUL
}

Then you should call it like that (on C):

char* value = NULL;
getproperty("key", &value);
// use
...
// free it
free(value);

Answer 4

If this is going to target Windows then you generally need to free in the same DLL that you allocate. This is because the linkage with the c-runtime may be with some combination of static/dynamic, single/multi-threaded. In each case it affects how the heap is managed.

It is very bad if there would be many C runtime libraries.
In principle, the One Definition Rule says there should be the only one malloc and only one free in the program... And it is good to have them :-)
memcpy may be prefered by performance reasons. Also, why use iterators and algorithm copy instead of memcpy when you really need memory to be copied? And what the "type safety" it provide?