The ref_count of this smart pointer needs to be heap allocated? - c++

Question

I was taking a look at the smart pointer implementation from a book (cracking the code interview) which reads like the following:
#include<iostream>
using namespace std;
template <class T>
class SmartPointer
{
protected:
T* ref;
unsigned int* ref_count;
public:
SmartPointer(T* ptr)
{
ref = ptr;
ref_count = (unsigned*)malloc(sizeof(unsigned));
*ref_count = 1;
}
SmartPointer(SmartPointer<T>& sptr)
{
ref = sptr.ref;
ref_count = sptr.ref_count;
++*ref_count;
}
SmartPointer<T> & operator=(SmartPointer<T>& sptr)
{
if (this != &sptr)
{
ref = sptr.ref;
ref_count = sptr.ref_count;
++*ref_count;
}
return *this;
}
~SmartPointer()
{
--*ref_count;
if (!ref_count)
{
delete ref;
free(ref_count);
ref = NULL;
ref_count = NULL;
}
}
};
class Car
{
};
int main()
{
SmartPointer<Car> car = new Car;
}
Since this came from a section about C++:
Question 1) Wouldn't it make more sense to have the following?
ref_count = new unsigned int ; // instead of ref_count = (unsigned*)malloc(sizeof(unsigned));
delete ref_count; // instead of free(ref_count);
Question 2) Or to have ref_count on the stack like in the following?
#include<iostream>
using namespace std;
template <class T>
class SmartPointer
{
protected:
T* ref;
unsigned int ref_count;
public:
SmartPointer(T* ptr)
{
ref = ptr;
// ref_count = new unsigned int ; // ref_count = (unsigned*)malloc(sizeof(unsigned));
ref_count = 1;
}
SmartPointer(SmartPointer<T>& sptr)
{
ref = sptr.ref;
ref_count = sptr.ref_count;
++ref_count;
}
SmartPointer<T> & operator=(SmartPointer<T>& sptr)
{
if (this != &sptr)
{
ref = sptr.ref;
ref_count = sptr.ref_count;
++ref_count;
}
return *this;
}
~SmartPointer()
{
--ref_count;
if (!ref_count)
{
delete ref;
// delete ref_count; // free(ref_count);
ref = NULL;
// ref_count = NULL;
}
}
};
class Car
{
};
int main()
{
SmartPointer<Car> car = new Car;
}
Question 3) There are many types of smart pointers (https://en.cppreference.com/book/intro/smart_pointers), implementation above looks like a unique_prt, shared_ptr or perhaps a weak_ptr?
Appreciate if you recommend a smart pointer implementation I should take a look.

Answer 1

Question 1) Wouldn't it make more sense to [use new instead of malloc]?
Sure. Only reason to need malloc in C++ is to use a poorly designed C API that requires it. There is no need to use it here.
Question 2) Or to have ref_count on the stack like in the following?
Think about how destruction of one pointer could affect all other refcounts stored somewhere else. It would not work.

Answer 2

Question 1) Wouldn't it make more sense to have the following?
Since unsigned is default initialized (in short, no initialization action at all!), so by using new/delete you're just using another pair of allocator/deallocator. Of course this would make your code more C++.
Question 2) Or to have ref_count on the stack like in the following?
Stack-like allocating reference counter is not possible. You may give it a try, and you will figure out why not possible, on yourself.