Memory and scope management - c++

Question

I have a doubt about the scope and the memory management in c++. Here is the case I'm having troubles:
Abc function f()
{
Abc c;
return c;
}
Abc d = f();
if(d) cout << "hi";
Would it say the "hi"? I mean... the Abc created in f() is not dynamic (we didn't write a new)... but we are returning the value, so we mantain a reference to the object. Would it has value, or as soon as it gets out of its scope it dies?
Thanks!

Answer 1

#include <iostream>
using std::cout;
using std::endl;
class Abc
{
int m_value = 0;
public:
Abc()
{
cout << "Default Constructor" << std::endl;
}
Abc(const Abc& _source)
{
cout << "Copy Constructor" << std::endl;
//copy stuff
}
Abc& operator=(const Abc& _source)
{
cout << "assignment operator" << std::endl;
if (this == &_source)
return *this;
//copy stuff
return *this;
}
Abc(const Abc&& _source)
{
cout << "Move Constructor" << std::endl;
//move stuff
}
Abc& operator=(const Abc&& _source)
{
cout << "move assignment operator" << std::endl;
//move stuff
return *this;
}
~Abc()
{
cout << "Destructor"<< std::endl;
}
void setValue(int _value)
{
m_value = _value;
}
int getValue()
{
return m_value;
}
};
Abc f()
{
Abc c;
c.setValue(100);
cout << "c value: " << c.getValue() << endl;
return c;
}
int main()
{
Abc d = f();
cout << "d value: " << d.getValue() << endl;
d.setValue(200);
cout << "d value: " << d.getValue() << endl;
}
Here is the output:
Default Constructor
c value: 100
d value: 100
d value: 200
Destructor
From here you can see that the compiler is smart enough to reuse allocated object without making any dumb copies(C++98/03, C++11 same output).
Compiled with MinGW(GCC 4.7.1).

Answer 2

In your case it is impossible to make an exact statement, in the second case below:
Abc* function f()
{
Abc *c = new Abc();;
return c;
}
Abc* d = f();
if(d) cout << "hi";
And yes, it would say "hi", the difference is that in the first case, c is kept in Stack while in the second case it is kept in Heap. In your case, typing if(d) is not a good method for checking whether object is alive because it is defined on the Stack.
In order to check your case you can add a log to the destructor of Abc and see whether it will be hit or not. You will observe that the destructor of Abc is called when you return the object with f(). But this does not mean that the object is dead. Only its destructor is called. But in this case you can not use destructors properly. This is one of the reasons why pointers to objects are chosen instead of defining them directly.

Answer 3

Abc f()
{
Abc c;
return c;
}
create c of type Abc, copy it and return from function (with NRVO copy may be elided).
Abc d = f();
if(d) cout << "hi";
create d and copy-initialize it with returned value of function f. What is Abc type? If it has operator bool (or operator T() where T is implicitly convertible to bool) - may be it will print "hi".