Local variable is popped from the stack, when the function is done, isn't it?

**hefese** · 11-20-2013

As far as I know that local variables are popped from the stack when its scope is done. But in the following code, this information isn't provided. The code is running properly, although local variable is popped from the stack.

Here are the code:

Code:

#include <iostream>


using namespace std;


struct ComplexNumber{
    int realNo;
    int imaginaryNo;
};


ComplexNumber operator +(ComplexNumber &cN1,ComplexNumber &cN2)
{
    ComplexNumber temp; // LOCAL VARIABLE


    temp.realNo = cN1.realNo + cN2.realNo;
    temp.imaginaryNo = cN1.imaginaryNo + cN2.imaginaryNo;


    return temp;                // LOCAL VARIABLE IS RETURN ?
}


int main()
{
    ComplexNumber c1;
    ComplexNumber c2;
    ComplexNumber result;


    c1.realNo = 1;
    c1.imaginaryNo = 2;


    c2.realNo = 3;
    c2.imaginaryNo = 4;


    result = c1 + c2;    // There is not any problem, why?


    cout << "result.realNo = " << result.realNo << endl;
    cout << "result.imaginaryNo = " << result.imaginaryNo << endl;


    return 0;
}

result = c1 + c2; // There is not any problem, why?

**Salem** · 11-20-2013

> return temp; // LOCAL VARIABLE IS RETURN ?
A copy of it is returned.

Consider a simple function like

Code:

int foo ( ) {
    return 42;
}

Where does the 42 go?

**hefese** · 11-20-2013

42 assigns to function's name foo.
I guess I understand.

**Salem** · 11-20-2013

> 42 assigns to function's name foo.
No.

When you say
int result = foo();

It's really the same as
int result = 42;

**MutantJohn** · 11-20-2013

I think you can compile using gcc with -S flag and it'll spit out the assembly language of your executable so you can check it yourself using that, can't you?

**hefese** · 11-20-2013

Well, I understand. But how can you explain the following codes?

Code:1

Code:

int *foo(int a,int b)
{
   int x;

   x = a + b;

   return &x;
}

In this code, a return value is expected as adress, but my note says that this line is invalid,because local variable is popped from the stack.

If I think like you, the return value &x is copied. So even if the local variable is popped from the stack, the copy adress is returned.

Code2:

Code:

int &foo(int a,int b)
{
   int x;

   x = a + b;
   
   return x;
}

My note says that this code is invalid, because x is popped. Okay, if you think like you, I can understand this code. But above...?(Code 1)

Originally Posted by MutantJohn

I think you can compile using gcc with -S flag and it'll spit out the assembly language of your executable so you can check it yourself using that, can't you?

I use Code::Blocks, and I don't understand what you want to tell me with -S flag.

**tabstop** · 11-20-2013

In snippet 1, the value returned is the address of the local variable x. This is still a "real" address, but the variable x doesn't live there any more (since it was discarded when the function ended).

In snippet 2, the value returned is a reference to the local variable x. (Note the difference with your original post, which returned a ComplexNumber, not a ComplexNumber&.) Again, the local variable doesn't live there any more (or any where), so you have a dangling reference.

This machine has a slightly old version of CodeBlocks, but I think you still have Settings->Compiler and debugger settings.

**Elkvis** · 11-20-2013

both snippets will produce compiler warnings with any reputable compiler, letting you know that you shouldn't do that.

**King Mir** · 11-20-2013

You can think of the value returned as a variable. A function call will allocate space for the result, call the function, then expect the result in that variable. In the called function, calling return will copy the return expression result into the return slot before jumping back to the original function. This is exactly how it's implemented, with the cravat that the return value can be either a register or a spot on the stack depending on its size and structure.

So referring to a local variable is not allowed, but making a copy of a local variable in the return register is perfectly fine.

**hefese** · 11-21-2013

Thank you for your answers.

Thread: Local variable is popped from the stack, when the function is done, isn't it?

Thread Tools

Search Thread

Display

Local variable is popped from the stack, when the function is done, isn't it?

Similar Threads

Visual Studio won't be able to compile MACRO function with local variable?

warning: function returns addresss of local variable

Local variables popped from stack or is it ?

Error - function returns address of local variable

const pointer parameter assigned to a local variable inside a function

Tags for this Thread