Should I free char* initialized using string-literals?

Question

Should I free char* variables when they were initialized using string literals? To me, the syntax would lead me to the assumption that they are only stack-allocated, but this example showed me, they are not.

#include <stdlib.h> #include <stdio.h>  static char* globalBuffer;  typedef struct Container {     char* buffer; } Container;  Container* Container_new(char* buffer) {     Container* container = malloc(sizeof(Container));     container->buffer    = buffer;     globalBuffer         = buffer;     return container; }  void Container_print(Container* container) {     if (container->buffer != NULL) {         printf("%s", container->buffer);         printf("\n");     }     else {         printf("Container contains a NULL-buffer.");     } }  Container* stage() {     Container* container = Container_new("Test-string.");     Container_print(container);     return container; }  int main() {     Container* container = stage();     Container_print(container);      free(container);     Container_print(container); // I know, this results in undefined behaviour      printf(globalBuffer);     printf("\n");      return 0; } 

I get the following output:

C:\Users\niklas\Desktop>gcc char_test.c  C:\Users\niklas\Desktop>a.exe Test-string. Test-string. ­6> Test-string.  C:\Users\niklas\Desktop> 

So, the char* initialized with string-literals does still exist, even it got out of scope.

So, my question, should I free such char* pointers? Would this be the correct main()?

int main() {     Container* container = stage();     Container_print(container);      free(container->buffer);    // NEW     free(container);     Container_print(container);      printf(globalBuffer);     printf("\n");      return 0; } 

Answer 1

You shall never free() memory that you did not malloc()ed.

The way the compiler implements string-literals is not your business: it's an implementation detail. You can free() a pointer to memory that you allocated using malloc(), and only those, or you are risking the life of your system.

Ideally, malloc() calls and free() calls should appear on the same "design level" (inside the same implementation file for the same module for example), and they should match perfectly: one free() for each malloc(). but that's not always possible.

(Note that some library allocates blocks of memory, returns pointers to those blocks, and instructs you to free them. in this case, you are allowed to free those pointers, but that is a bad design practice from the people who created the library.)