Edited to add another question about pointing to local variables with global pointers. This has been solved. The solution I found is at the end.

From what I understand, I can do the following:

char *myString = "";
myString = "Hello World";
myString = "Goodbye";

And this would not be wrong. However, thinking a bit into it, it makes no sense to me, because when/how is memory being allocated/rellocated/freed for this? First of all I make a string with 0 chars, so it needs 0 bytes. Then it needs ~11 bytes, then only 7. The memory needed to store the string is changing, but at no point in time have I done anything with memory, so is C managing it in the background? Does C not manage it and therefore this is wrong? What would happen if I now did myString=NULL;? Would that leave allocated memory with no one pointing to it?

To hijack my own post and not spam, an additional question about memory. If I create a variable inside a function, say int myLocalInt;, C automatically reserves memory for that variable to be stored in, so I don't need to do any malloc shit. If I then declare a pointerint *myLocalIntPtr;, I can make that pointer point to that variable's memory (myLocalIntPtr=&myLocalInt) and I wouldn't need to do malloc, right?And now for the important question. In the previous example with the local int, what would happen if I assigned a global pointer the memory address of the local int when the function the int is local to ends?

int *globalPtr;
int someFunction(){
    int myLocalInt = 5;
    globalPtr = &myLocalInt;
    printf("Of course this would print 5: %d",*globalPtr);
    return 0;
}
int main(){
    someFunction();
    printf("But what about now? Is it still 5? i=%d",*globalPtr);
}

I just realized I can test that myself, so I'll go do that. Beside that, I understand that C releases all local variables when their block ends, but given that there's still a pointer to it I thought it might not.

If it was freed, globalPtr would now be aiming at non-allocated memory, which is a problem. Especially because I don't know how to check if a block of memory is currently allocated. (I guess I could try calling free on it, and if there's an error it's not allocated). I understand this would give undefined behaviour, with it being possible that the print outside still gives 5, or it might give some other number if the memory has been altered, or could give an error.

Testing did not help much, however thinking did. It seems memory allocated to local variables will always be freed when the local variable goes out of scope. However, if the variable is a pointer, and it was allocated memory with malloc or any of those, that memory is still reserved. So the solution in my case is to declare pointers to the types I needed instead of the types themselves. I thought I was being cheeky by declaring the variables of the type directly and avoiding memory management, but it backfired.

Hey,

const char * text = “test“;

how is a string literal stored? I once catched up, that it is stored in a constant memory section.

If i would define a function like this:

void foo(const char * text) { }

and then call this function infinitely with foo(“test“), does this can lead to memory overflow or something? Because the string i put in this function is stored everytime again and again, and so the memory would be full?

Or would this only be, if i put different strings in the function and call it infinitely?