Why does my destructor appear to be called more often than the constructor?

Question

#include<iostream>
using namespace std;

class A{
public:
    static int cnt;
    A()
    { 
        ++cnt; 
        cout<<"constructor:"<<cnt<<endl;
    }
    ~A()
    {
        --cnt;
        cout<<"destructor:"<<cnt<<endl;
    }
};

int A::cnt = 0;

A f(A x){
    return x;
}
int main(){
    A a0;
    A a1 = f(a0);
    return 0;
}

The program will output:

constructor:1
destructor:0
destructor:-1
destructor:-2

The constructor and destructor don't appear in pairs?

Answer 1

You need to add a copy constructor that increases the counter.

A(const A&)
{ 
    ++cnt; 
    cout<<"copy constructor:"<<cnt<<endl;
}

If you don't add it explicitly, the compiler generates one that does nothing with the counter cnt.

This expression

A a1 = f(a0);

is creating copies of a0, which make use of the copy constructor. The exact number of copies may vary depending on copy elision, but your cnt should be 0 at the end of the program.

Note: In C++11, you should also consider the possibility of a compiler generated move copy constructor, however, once you declare your own copy constructor, the compiler no longer generates the move version.

Answer 2

You are not tracking all constructors, only the default constructor. The compiler has generated a copy constructor and used it a couple of times, accounting for the 2 objects that are listed as destroyed and not as created.