堆内存和 malloc 查询

Question

I am trying to get my head around dynamic memory allocation and was hoping someone could explain why the following code executes as it does.

#include <stdlib.h>
#include <string.h>

char* create_string(void);

int main(){

    char* str1 = NULL;
    char* str2 = NULL;

    str1 = create_string();
    
    str2 = (char*)malloc(11);
    
    str2 = create_string();

    printf("String 1 is: %s", str1);
    
    printf("String 2 is: %s", str2);

    free(str1);

}

char* create_string()
{
    char* stack_str = "TestString";
    char* heap_str = (char*)malloc(strlen(stack_str) + 1);
    strcpy(heap_str, stack_str);
    if(heap_str == NULL)
    {
        printf("Oh no");
        return NULL;
    }

    return heap_str;

}

As far as I thought, to allocate memory on the heap, you have to use malloc with a size which allocates a block of memory and then use a function such as strcpy() or memcpy(), as I have done with str2 above (malloc 11 for the size of "TestString" plus one for the null terminator.)

I am just confused why assigning the result of create_string to str1 which is a null pointer which has not been allocated a block of memory produces the same output as str2.

Many thanks in advance!

Answer 1

"As far as I thought, to allocate memory on the heap, you have to use malloc with a size which..." size in malloc() is number of bytes which is unsigned integer. Therefore syntactically str2 = (char*)malloc(11); is correct.

Both str1 and str2 are pointing to different memory locations from the heap containing "TestString". This is according to what you have programmed. However str2 = (char*)malloc(11); returns 11 bytes of memory that can store character data type and returns a pointer to this location in heap. There is no issue in this. However, in your code you have leaked this allocation when you assign create_string() pointer to it.

Answer 2

It is not wroking exactly as you think.

Firstly, C has constant strings, which will be initialized by double quotes. Those objects when used, actually return a pointer that points to the location of the initialized constant string array.

char * ptr="something"   //"something" return a pointer to the location of the string array 
                         // and is assigned to the ptr.

You don't need to allocate memory for constant string as they are managed by compilers. What's happening in the code is stack_str locates to this constant string array which is managed by the compiler. So it is always present. You create a memory block and stores the address in heap_str , and copies the stack_str contents to the dynamically allocated memory, and returns the pointer. In effect,

 str2 = (char*)malloc(11);

is not used for anything and is wasted. Hope you understands.

Edit: In your create_str() , you check heap_str isn't NULL AFTER strcpy() . If the malloc() failed for some reason, the program will still crash even if you check for NULL.