What is this function called when I run this C++ program? - c++

Question

#include <iostream>
using namespace std;
class foo
{
private:
static int cnt; // number in memory
static int nextid; // the next id number
public:
int id; // not shared - each object has it's own
foo()
{
cnt++; // update the counter of alive foos
id = nextid++; // assign an id
cout << "foo # " << id << " is alive " << endl;
}
~foo()
{
cnt--;
cout << "foo # " << id << " is dead " << endl;
}
void stats()
{
cout << "I am foo number " << id << endl;
gstats();
}
static void gstats()
{
cout << "Objects currently alive: " << cnt << endl;
cout << "Total number ever created: " << nextid << endl;
}
foo( foo &f)
{
cnt++; // update the counter of alive foos
id = nextid++; // assign an id
cout << "foo # " << id << " is alive and copied from " << f.id << endl;
}
};
int foo::cnt = 0;
int foo::nextid = 0;
void dmy1( foo a )
{
cout << "called dmy1 ( by value) id is " << a.id << endl;
}
void dmy2( foo &a)
{
cout << "called dmy2 (by reference) id is " << a.id << endl;
}
int main(void)
{
foo::gstats();
foo f1, f2;
f1.stats();
dmy1(f2);
foo::gstats();
}
This is the code my professor gave me to practice C++ static code.
But when I run this program, I have a question.
Objects currently alive: 0
Total number ever created: 0
foo # 0 is alive
foo # 1 is alive
I am foo number 0
Objects currently alive: 2
Total number ever created: 2
foo # 2 is alive and copied from 1
called dmy1 ( by value) id is 2
foo # 2 is dead
Objects currently alive: 2
Total number ever created: 3
foo # 1 is dead
foo # 0 is dead
This is the output.
But I don't know the reason why this function is called
Could you explain?
foo( foo &f)
{
cnt++; // update the counter of alive foos
id = nextid++; // assign an id
cout << "foo # " << id << " is alive and copied from " << f.id << endl;
}
And, also, Why static void gstats(){ ~ } is called after destructing foo #2 ?

Answer 1

Ok, i try to explain what happens
First it is showed no objects exist at this point
foo::gstats();
Now f1 and f2 are declared and created on stack (2 objects alive)
foo f1, f2;
f1.stats is called and shows the current state
f1.stats();
f2 is passed by value (copyed on stack with copy constructor call foo( foo &f)) to dmy1 (3 objects alive)
dmy1(f2);
after leaving dmy1 it's scope (stack variables used by it) is destroyed and f2's copy gets it's destructor called (2 objects alive) and this status is displayed
foo::gstats();
Then main() is left and it's scope is destroyed as well and f1 and f2's destructors are called (0 objects alive)

Answer 2

The function is called copy constructor. It's called because you pass the object f2 to dmy1 by value and a copy of the object is constructed. If you would change the object a inside dmy1, f2 would stay the same - because you implicitly constructed a copy when you passed the parameter in by value.
foo#2 is destructed when you exit the function dmy1, because it's only alive inside that function. So it's destructed before calling gstats.

Answer 3

It is copy constructor, as it was said. But copy constructor should have been declared like this:
foo(const foo &f)
{
...
}