Destruction of automatic variables in C

Taking this into account, the question would be: why does this happen? isn't the string return value supposed to die after the function has finished?

Let's take your function:

char *cadena(){
    char *cadena = "Hola";
    return cadena;
}

And let's see the assembler that it generates:

.LC0:
        .string "Hola"
cadena():
        push    rbp
        mov     rbp, rsp
        mov     QWORD PTR [rbp-8], OFFSET FLAT:.LC0
        mov     rax, QWORD PTR [rbp-8]
        pop     rbp
        ret

If you notice, the string "Hola"is stored outside the function. It is as if it were a variable that you marked as static, or a global variable . That's why you can access it outside of the function, it doesn't get destroyed. This is what is usually done with literal strings.

It is equivalent to this:

char *cadena(){
    static const char[] foo = {'H', 'o', 'l', 'a', '\0'};
    char *cadena = (char*) foo;
    return cadena;
}

Regarding this, I have an assumption: when this type of assignment is actually made, the C compiler (in my case gcc 9.3.0, I'm on ubuntu at the moment) loads string in dynamic memory and that is why there is still getting to the line 16.

Rather save the string in the section textof your executable (I may be misremembering the name).

With this:

Final edit: I've been doing a lot of testing and came to the following conclusion... Apparently, when arrays are created as 'raw' pointers, in functions, their value persists after function completion, otherwise it doesn't. .

I assume you mean this example:

int *arreglo(){
    int *array = (int *) calloc(sizeof(int), 2);
    array[0] = 1;
    array[1] = 2;
    printf("referencia a array desde funcion <main> %i\n", array);
    return array;
}

That they are cleaned after the function is finished only applies to variables that are on the stack. If you use calloc, you are allocating memory on the heap, and it will be there until you free it using free.

Although I am checking this with examples, this may be working by many coincidences (unfortunately, this has already happened to me (^ _ ^) ), so it would be nice if someone who knew confirmed all this

Stack variables die when they go out of scope (the {}). These are the ones you normally declare:

{
    int a;
    float b;

    double* c;
}

// Aqui ya no puedes usarlas

Then there are the static variables inside the functions, which will last from when they are initialized, until the program ends.

int foo() {
    // Inicializada en la primera llamada a la funcion
    static int bar = 10;
}

There are the global variables that will last the entire program, and finally there is the memory that you allocate using mallocand calloc, which will be available until you free it using free.

What happens is that the literal "Hola"is stored in read-only memory while the variable cadenais stored on the stack . What is stored in this variable is the memory address of the string.

In general, if the string is in an array definition, it will be placed on the stack as well:

char[] saludo = "Hola";

And if they are stored in a pointer it will go to read-only memory.

char* saludo = "Hola";

It's not a sure thing as it varies by compiler.

Sources: https://stackoverflow.com/a/349030 https://stackoverflow.com/a/2589963 https://stackoverflow.com/a/14468729/13419694

Perhaps you have the doubt because the strings you declare are static, imagine that when you compile your program all the strings you declare "de esta forma"have to go inside your binary, if not, where are you going to get them from?

#include <stdio.h>

char *cadena() 
{
    
    char *cadena_estatica = "Cadena Interna";
    return cadena_estatica;
}

int main(int argc, char **argv)
{
    char *sigue_viva = cadena();
    printf("%s", sigue_viva);
}

so when you do the assignment char *cadena_estatica = "Cadena Interna"

you're setting the pointer to a static string which lives in your binary and lives for the entire execution of the program; when you finally return it you're just passing the memory address of the static string, so we know for a fact that it's a valid memory space.

Now let's create the string ourselves inside the function and programmatically:

#include <stdio.h>
#include <malloc.h>


char *nuevo() 
{
    char interna[21];
    for(int i = 0; i<=19; i++)
        interna[i] = 'a';
    interna[20] = '\0';
    return interna;
}

int main(int argc, char **argv)
{
    printf("%s\n", nuevo());
}

and the program fails as you are now pointing to a page that has already been discarded.