C - Avoiding warning "address of stack memory associated with local variable returned"

Question

I've written the following simple program that sums up the numbers from 0 to 9:

#include <stdio.h>
#include <stdlib.h>

int* allocArray() {
    int arr[10];
    return arr;
}

int main(void){
    int* p;
    int summe = 0;
    p = allocArray();
    for(int i = 0; i != 10; ++i) {
        p[i] = i;
    }
    for(int i = 0; i != 10; ++i) {
        summe += p[i];
    }
    printf("Sum = %d\n", summe);
}

The code compiles and delivers the expected result "45". However I get the following warning: 'address of stack memory associated with local variable 'arr' returned'. What am I doing wrong?

Protip: When you get a weird error message, copy and paste the exact text of the error message into the google search box, like this. Chances are, someone else has been puzzled by the same error, and has asked abut it, and gotten answers. — Steve Summit
– Steve Summit, Commented Jan 22, 2021 at 15:55
Note though that it's a bewilderingly long scroll down that page before someone finally mentions the option of wrapping the array in a struct, which is a perfectly good way to do this while avoiding dynamic allocation (and how C++ implements its properly value-semantic std::array). — underscore_d
– underscore_d, Commented Jan 22, 2021 at 15:55
Same error message: Using C-string gives Warning: "Address of stack memory associated with local variable returned" — Peter Mortensen
– Peter Mortensen, Commented Oct 22, 2022 at 5:05

tadman · Accepted Answer · 2021-01-22 22:06:51Z

5

This is undefined behaviour, plain and simple. The only reason it "works" is because with this particular compiler the stack hasn't been trashed yet, but it is living on borrowed time.

The lifetime of arr ends immediately when the function call is complete. After that point any pointers to arr are invalidated and cannot be used.¹

Your compiler uses stack memory to store local variables, and the warning indicates that you're returning an address to a now-invalidated stack variable.

The only way to work around this is to allocate memory dynamically and return that:

int* allocArray() {
    int* arr = calloc(10, sizeof(int));

    return arr;
}

Where you're now responsible for releasing that memory later.

You can also use static to extend the lifetime of arr:

int* allocArray() {
    static int arr[10];

    return arr;
}

Though this is not without consequences, either, as now arr is shared, not unique to each function call.

¹ Like a lot of things in C there's significant overlap between what you "cannot do" because they lead to undefined behaviour and/or crashes and what you "can do" because it's permitted by the syntax and compiler. It's often your responsibility to know the consequences of any code you write, implied or otherwise.

edited Jan 22, 2021 at 22:06

answered Jan 22, 2021 at 15:49

tadman

212k23 gold badges237 silver badges266 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

David Ranieri Over a year ago

Ooops, almost identical answer :)

Zuppa Over a year ago

It is not undefined behavior - it is a kind of "use after free".

embedded_guy Over a year ago

@Zuppa, this is literally undefined behavior. The standard states that

the lifetime of an object is the portion of program execution during which storage is guaranteed to be reserved for it... If an object is referred to outside of its lifetime, the behavior is undefined

.

Zuppa Over a year ago

@embedded_guy point taken. imho in this case the wording 'undefined behavior' is still a bit weak :)

Zuppa · Accepted Answer · 2021-01-22 15:55:27Z

0

To keep it in your code:

int arr[10];

will allocate the memory on the stack. As soon as you are leaving the function, the content of that array will be overwritten pretty soon. You want to allocate this on the heap.

You would need to use

int* arr = malloc(sizeof(int)*10);

and in the main function, after you've used it (at the end of main), call

delete[] arr;

Nevertheless, this code could be better if the ownership of the array would be properly handled. You want to make yourself familiar with C++ containers and shared/unique pointers.

answered Jan 22, 2021 at 15:55

Zuppa

4775 silver badges16 bronze badges

2 Comments

embedded_guy Over a year ago

I think the OP is tagged for C, not C++.

Zuppa Over a year ago

you're right. apart from the C++ containers/pointers hint, the rest is C.

Collectives™ on Stack Overflow

C - Avoiding warning "address of stack memory associated with local variable returned"

2 Answers 2

4 Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related