堆对象如何使用堆栈中的数据？

Question

I've declared the struct foo like this:

struct foo {
    const char* name_lower; 
    const char* name_caps
    //..
};

I dynamically create instances of foo on the heap and want to save a value in the name_lower and name_caps member variable. This is done by the function bar

void bar(foo* entry, const char* str, int delimiter_pos) {

    char l[2] = {str[caps_pos-1], '\0'}; // create new string
    char c[2] = {str[caps_pos+1], '\0'};

    entry->name_lower = &l[0]; // assign these strings the foo instance
    entry->name_caps =  &c[0];
}

I am worried, because I don't know if this code is going to crash. The temporarily created arrays l and c will be saved on the stack. Once the function terminates the stack will be cleared up and c and l will probably disappear.

Does this mean that the foo instance will lose its names, ie its references? If so, how can I solve this problem?

Answer 1

Continuing from the comment, the easiest way to allocate/copy and assign the start address for new blocks of memory for l and c is to use strdup (from string.h ):

void bar(foo* entry, const char* str, int delimiter_pos) {

    char l[2] = {str[caps_pos-1], '\0'}; // create new string
    char c[2] = {str[caps_pos+1], '\0'};

    entry->name_lower = strdup (l); // assign these strings the foo instance
    entry->name_caps =  strdup (c);
}

Don't forget to free the memory allocated to entry->name_lower and entry->name_caps when no longer needed.

Answer 2

You should instead use char *l = (char *)malloc(2 * sizeof(char)); and then initialize it; similarly for char *c . Then set entry->name_lower = l; entry->name_caps = c; entry->name_lower = l; entry->name_caps = c;

When allocating make sure you check whether the allocation succeeded, ie whether malloc returned non-NULL address.

Make sure you free the memory after you don't need it anymore: free(entry->name_lower); free(entry->name_caps); free(entry->name_lower); free(entry->name_caps); .

Answer 3

It will not lose anything. The pointers in the struct will retain their value, but the content will change and you will eventually get SIGSEGV.

For the char * to persist, you need to allocate it on the heap too.

void bar(foo* entry, const char* str, int delimiter_pos) {
    char * l = malloc(2);
    char * c = malloc(2);
    /* Check l and c for NULLs */

    l[0] = str[caps_pos-1];
    l[1] = '\0';
    c[0] = str[caps_pos+1];
    c[1] = '\0';

    entry->name_lower = l;
    entry->name_caps = c;
}

Remember that you should also free() the struct members when you will no longer need it.

Answer 4

If you have a limit on the length of your strings, you can use char arrays instead of pointers. In your example, all strings have a length of 1. Assuming your strings cannot be longer than that, you can use char[2] instead of char* :

struct foo {
    char name_lower[2];
    char name_caps[2];
    //..
};

void bar(foo* entry, const char* str, int delimiter_pos) {
    entry->name_lower[0] = str[caps_pos-1];
    entry->name_lower[1] = '\0';
    entry->name_caps[0] = str[caps_pos+1];
    entry->name_caps[1] = '\0';
}

Historical note:

Because this is so easy to use, people got accustomed to this, and forced artificial limits on string length, leading to buffer overflows. If your strings are not limited, use dynamic allocation instead of char arrays.