通过strdup（）和malloc（）构造字符串之间是否存在实际差异？

Question

Suppose I want to write a function that will produce a string, and while I can set an upper limit on the size of the string I don't know in advance exactly how much space the string will take up. I can think of two ways to arrange this:

char *ParametersAsString_1(int temperature, float pressure)
{
    char buffer1[128];
    snprintf(buffer1, 128, "temperature: %d; pressure: %g",
        temperature, pressure);
    return strdup(buffer1);
}

char *ParametersAsString_2(int temperature, float pressure)
{
    char *buffer2 = malloc(128);
    snprintf(buffer2, 128, "temperature: %d; pressure: %g",
        temperature, pressure);
    return buffer2;
}

The only difference I can see is that the second form will potentially waste a bit of memory: it uses 128 bytes for buffer2 for that variable's entire existence. The first function uses 128 bytes for buffer1 plus whatever memory the string “actually” uses, but when buffer1 is removed from the stack the only memory that will be used is whatever the string actually needs.

It looks like the first function would be better if the strings are long-lived and there will be a bunch of them. Are there any other reasons to prefer one of these forms over the other? (This is an academic question; I'm not actually in a situation where using an extra 90 bytes makes a difference.)

Answer 1

You can also use asprintf. buffer will be allocated with the needed size... (This pointer should be passed to free() to release the allocated storage when it is no longer needed)

char*   ParametersAsString_3(int temp, float pres) {                                                                                                                                        
    char* buffer;                                                                                                                                                                         

    asprintf(&buffer, "temperature: %d; pressure: %g", temp, pres);                                                                                                                           
    return (buffer);                                                                                                                                                                          
}

Answer 2

If you are looking for minimum memory usage not knowing the length beforehand, the solution lies in a special usage of snprintf . From the C11 standard:

7.21.6.5

2. .. If n is zero, nothing is written, and s may be a null pointer...

3. The snprintf function returns the number of characters that would have been written had n been sufficiently large, not counting the terminating null character, or a negative value if an encoding error occurred...

This means that if you write:

int size = snprintf(NULL, 0, "format string", arguments);

you will either get a negative value showing error (unlikely) or a positive value saying what would the ultimate size of the string be, without actually writing that string anywhere.

Therefore:

int size = snprintf(NULL, 0, "temperature: %d; pressure: %g", temperature, pressure);
/* error checking */
char *str = malloc((size + 1) * sizeof(*str));
/* error checking */
sprintf(str, "temperature: %d; pressure: %g", temperature, pressure);
return str;

Note that strdup and asprintf are not standard. The former is a POSIX extension and the later is a GNU extension.

---

This solution will give you an unbounded string, so it's quite useful (you don't have to cut the string). However, if you do want to cut the string, simply allocate a smaller memory if size was too big and use snprintf with the proper size to create the (cut) string in the buffer.

---

If you want to be more secure and future proof as well as avoid repeating code, you can use a macro:

#define YOUR_LIB_YOUR_FUNC_NAME_SNPRINTF(s, n)               \
             snprintf(s, n, "temperature: %d; pressure: %g", \
             temperature, pressure)

int size = YOUR_LIB_YOUR_FUNC_NAME_SNPRINTF(NULL, 0);
/* error checking */
char *str = malloc((size + 1) * sizeof(*str));
/* error checking */
YOUR_LIB_YOUR_FUNC_NAME_SNPRINTF(str, size + 1)
return str;

#undef YOUR_LIB_YOUR_FUNC_NAME_SNPRINTF

In fact, modifying this function a little bit to work with vsnprintf , you get an implementation of asprintf that you could use wherever needed.

Answer 3

As to the question in title: strdup() uses malloc(). It means that after strdup you should use free().

As to the examples, the second function allocates memory without freeing, the first not, so forget the second. Still, for the first function, you should free the functions result once you don't need it.

EDIT: the question was edited, so the answer must be edited too :)

Before the question was edited, the second function ended with strdup(buffer2). I meant in my answer, that the second function leacks memory allocated for buffer2. Both functions, as they were then, returned address that should be freed afterwards, but the second would cause additional leack.

Answer 4

strdup calls malloc and memcpy internally. So Function 1 has extra cost of calling memcpy function.

So Function 2 looks better option considering this reason along with reasons specified by @shahbaz.