warning: address of local variable 'angles' returned [-Wreturn-local-addr]

Question

I'm trying to return float x, y and z angle values for a body object from my ODE (open dynamics engine) simulation.

float* Creature::eulerAngles(const float &q0, const float &q1, const float &q2, const float &q3){

    float angles[3] = {atan2(2 * (q0*q1 + q2*q3), 1 - 2 * (q1*q1 + q2*q2)),
                      asin( 2 * (q0*q2 - q3*q1)),
                      atan2(2 * (q0*q3 + q1*q2), 1 - 2 * (q2*q2 + q3*q3))};
    return angles;
}

Because dBodyGetQuaternion returns 4 const float quaternions I need to then get the rotations and I've had immense difficulty trying to get it to compile. Now it does compile but I'm getting this warning.

Could anyone explain to me why and what it means please?

The error message is pretty clear. You're returning the address of angles, but after you return, angles no longer exists. So what's the caller supposed to do with the address of an object that no longer exists? — David Schwartz
– David Schwartz, Commented Apr 22, 2016 at 4:49

ArekBulski · Accepted Answer · 2021-05-08 14:14:43Z

21

float angles[3] = { ... };

defines a local array.

The statement

return angles;

returns a pointer to the first element of the array.

However, the array is destructed as soon as the function returns. Hence, the returned pointer is a dangling pointer.

That's what the compiler is warning you about. If you dereference the returned pointer in the calling function, you invoke undefined behavior.

In order to return a pointer to an array that will remain valid after the function returns, you need to allocate dynamic memory and return the dynamic memory.

float* Creature::eulerAngles(const float &q0, const float &q1,
                             const float &q2, const float &q3)
{
   float* angles = new float[3];
   angles[0] = atan2(2 * (q0*q1 + q2*q3), 1 - 2 * (q1*q1 + q2*q2));
   angles[1] = asin( 2 * (q0*q2 - q3*q1));
   angles[2] = atan2(2 * (q0*q3 + q1*q2), 1 - 2 * (q2*q2 + q3*q3));

   return angles;
}

Keep in mind that if you do the above, you'll have to make sure to call delete [] on the returned pointer in the calling function.

To avoid the hassles of manually allocating and deallocating memory, you can use std::vector<float> as your return type.

std::vector<float> Creature::eulerAngles(const float &q0, const float &q1,
                                         const float &q2, const float &q3)
{
   std::vector<float> angles(3);
   angles[0] = atan2(2 * (q0*q1 + q2*q3), 1 - 2 * (q1*q1 + q2*q2));
   angles[1] = asin( 2 * (q0*q2 - q3*q1));
   angles[2] = atan2(2 * (q0*q3 + q1*q2), 1 - 2 * (q2*q2 + q3*q3));

   return angles;
}

With this, memory management is done automatically for you.

Since the size of the array is fixed at 3, using std::array<float, 3> is better than using std::vector<float>:

std::array<float, 3> Creature::eulerAngles(const float &q0, const float &q1, const float &q2, const float &q3)
{
   std::array<float, 3> angles;
   angles[0] = atan2(2 * (q0*q1 + q2*q3), 1 - 2 * (q1*q1 + q2*q2));
   angles[1] = asin( 2 * (q0*q2 - q3*q1));
   angles[2] = atan2(2 * (q0*q3 + q1*q2), 1 - 2 * (q2*q2 + q3*q3));

   return angles;
}

edited May 8, 2021 at 14:14

ArekBulski

5,2288 gold badges43 silver badges69 bronze badges

answered Apr 22, 2016 at 4:35

R Sahu

207k15 gold badges168 silver badges291 bronze badges

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

3 Comments

M.M Over a year ago

array<float, 3> might be appropriate since it seems the same size is returned every time

Jade Over a year ago

This works great thank you for an in depth explanation. I've only been using C++ for the past few months and still get confused with how pointers work so appreciate the helpful advice.

R Sahu Over a year ago

@Jade, I am happy to help. Happy coding.

Some programmer dude · Accepted Answer · 2016-04-22 04:43:50Z

2

The warning says exactly what's wrong: You are returning a pointer to the local array angles.

Local variables, doesn't matter it they are simple int variables, or arrays like yours, go out of scope when their function returns. That means they kind of disappear. Having a pointer to such a variable means you can't use that pointer anymore, as it no longer points to memory occupied by the variable. Using it will lead to undefined behavior.

There are two solutions to your problem: The first is to allocate the array dynamically using new[], and return that pointer. Memory allocated with new[] never goes out of scope until you delete[] it.

The second solution is to define the array in the calling function, and pass a pointer to it as an argument and have your function fill it in.

Since I missed that this was a C++ question, there is a third solution that I rather recommend: Using std::array. Then you can declare the array locally inside the function, and return the object and the object and compiler will make sure the data is copied as needed.

edited Apr 22, 2016 at 4:43

answered Apr 22, 2016 at 4:35

Some programmer dude

411k36 gold badges420 silver badges655 bronze badges

1 Comment

M.M Over a year ago

This is a C++ question, so malloc should not really be recommended

jbrove · Accepted Answer · 2016-04-22 04:44:51Z

1

You need to stick the result on the heap so that it survives the return of the local function:

float* Creature::eulerAngles(const float &q0, const float &q1, const float &q2, const float &q3){

float * angles = new float[3]{atan2(2 * (q0*q1 + q2*q3), 1 - 2 * (q1*q1 + q2*q2)),
        asin( 2 * (q0*q2 - q3*q1)),
        atan2(2 * (q0*q3 + q1*q2), 1 - 2 * (q2*q2 + q3*q3))};
return angles;
}

answered Apr 22, 2016 at 4:44

jbrove

1213 bronze badges

Collectives™ on Stack Overflow

warning: address of local variable 'angles' returned [-Wreturn-local-addr]

3 Answers 3

3 Comments

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

3 Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related