How does counter decrement of smart pointer work? - c++

Question

Below is a sample code for shared pointer. I define a shared pointer inside curly braces scope. sp1 is initialized by new A (counter = 1) and sp1 is assigned to sp2 (copy and/or assignment increase the counter by 1 so, counter = 2). I always thought destructor of the A is called when counter becomes 0. But in my case the smart pointer when is about to get out of scope ( via the curly brace ) the counter is two.
My question is : who changed the counter from 2 to 0?
#include <iostream>
#include <memory>
using namespace std;
class A{
public:
~A(){
std::cout << "~A" << std::endl;
}
};
int main(){
{
shared_ptr<A> sp1 (new A);
shared_ptr<A> sp2 = sp1;
std::cout << "sp1 count = " << sp1.use_count() << std::endl;
std::cout << "sp2 count = " << sp2.use_count() << std::endl;
}
return 0;
}
EDIT:
Link to paper on smart pointer
output:
sp1 count = 2
sp2 count = 2
~A

Answer 1

When your code gets to the end of main, the destructor for both sp1 and sp2 runs, which decrements the counter to zero - that is a VERY important part of shared pointers, that the destructor reduces the reference count and thus, when "nothing" is left, the destructor of the actual shared object gets called.
The destuctor of shared_ptr will have some logic like this:
counter--; // Should be atomic!
if (counter == 0)
{
delete owned_thing;
}

Answer 2

A better example (IMO) would be something like this:
int main()
{
std::shared_ptr<A> sp1{new A};
std::cout << "1: sp1.use_count() = " << sp1.use_count() << '\n';
{
std::shared_ptr<A> sp2 = sp1;
std::cout << "2: sp1.use_count() = " << sp1.use_count() << '\n';
std::cout << "2: sp2.use_count() = " << sp2.use_count() << '\n';
}
std::cout << "3: sp1.use_count() = " << sp1.use_count() << '\n';
}
The output from this program should be (using your class with its destructor):
1: sp1.use_count() = 1
2: sp1.use_count() = 2
2: sp2.use_count() = 2
3: sp1.use_count() = 1
~A
First you create a shared pointer and initialize it, making the use counter 1. Then you enter a new scope and in it create a new shared pointer initializing it (using the shared pointers copy-constructor) with the old pointer, leading to the use count of both pointers being 2. Then the second shared pointer goes out of scope, and the shared pointer destructor decrements the use count by one. Finally the second shared pointer goes out of scope, as the main function returns, and the use count is decremented by the sp1 destructor. Now it has reached zero, and the contained pointer is deleted resulting in the A destructor being called.