Smart Pointers in C++

#include <memory>
// Create a unique pointer using make_unique factory function.
std::unique_ptr<Entity> uptr1 = std::make_unique<Entity>();
// or `std::unique_ptr<Entity> uptr1 = std::unique_ptr<Entity>(new Entity);`

// Change ownership to uptr2.
std::unique_ptr<Entity> uptr2 = std::move(upre1);

template<class T, class Deleter = std::default_delete<T>>
class unique_ptr {
    T *p_ = nullptr;
    Deleter d_;
public:
    explicit unique_ptr(T* p = nullptr, Deleter d = Deleter()) : p_(p), d_(d) {}
    ~unique_ptr() {
        if (p_) d_(p_);
    }
    // Copy is not allowed.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
    // Object is movable.
    unique_ptr(unique_ptr&& other) noexcept : p_(other.p_), d_(std::move(other.d_)) {
        other.p_ = nullptr;
    }
    unique_ptr& operator=(unique_ptr&& other) noexcept {
        if (this != &other) {
            if (p_) d_(p_);
            p_ = other.p_;
            d_ = std::move(other.d_);
            other.p_ = nullptr;
        }
        return *this;
    }
    T* get() const { return p_; }
    T* release() { T* tmp = p_; p_ = nullptr; return tmp; }
    void reset(T* p = nullptr) {
        if (p_ != p) {
            if (p_) d_(p_);
            p_ = p;
        }
    }
};
template<class T>
struct default_delete {
    void operator()(T *p) const { delete p; }
};

struct DBConnection{
// All kinds of resources.
// All kinds of methods.
};
struct DBDeleter{
	void operator()(DBConnection* db){
		std::cout << "Closing Database Connection.\n";
		dbClosing(db);
	}
};
class DBManager{
	std::unique_ptr<DBConnection, DBDeleter> dbConnect_;
public:
	explicit DBManager(DBConnection* dbConnect) : dbConnect_(dbConnect){}
	void query(const std::string& q){
		if(dbConnect_){
			db_query(dbConnection_.get(), q.c_str());
		}
	}
	void close(){
		dbConnection_.reset();
	}
};

int main(){
	DBConnection* db = dbOpen("example.db");
	DBManager dbManager(db);
	dbManager.query("SELECT * FROM Student");
	// dbManager.close(); // <-Close the database now.
	return 0;
} // <- Close the database by using DBDeleter.

std::shared_ptr<Resource> pResource1 = new Resource;
std::shared_ptr<Resource> pResource2;
pResource2 = pResource1; // Ref count + 1

std::shared_ptr<ReadBuffer> pReadBuf = new ReadBuffer;
pReadBuf = pResource1;  // ref count for shared_ptr<Resource> + 1
						// ref count for shared_ptr<ReadBuffer> - 1

struct Fruit { int juice; }; 
struct Vegetable { int fiber; }; 
struct Tomato : Fruit, Vegetable { int sauce; };

std::shared_ptr<Tomato> tomato = make_shared<Tomato>;
std::shared_ptr<Fruit> fruit = tomato;
std::shared_ptr<Vegetable> fruit = tomato;

struct CustomDeleter {
    void operator()(int* p) const {
        delete p;
    }
};
// Deleter type is part of the smart pointer.
std::unique_ptr<int, CustomDeleter> p1(new int); 

struct CustomDeleter {
    void operator()(int* p) const {
        delete p;
    }
};
// Deleter is not part of the smart pointer.
std::shared_ptr<int> p(new int, CustomDeleter()); 
std::shared_ptr<int> p2 = p; 

auto ptr = new A;
{
	std::shared_ptr<A> sptrA1(ptr); // create 1st control block for *ptr
	std::shared_ptr<A> sptrA2(ptr); // 2nd control block is created...
} // double delete

std::shared_ptr<A> sptrA(new A);

std::unique_ptr<A> uptrA(new A);
std::shared_ptr<A> sptrA = std::move(uptrA);

std::vector<std::shared_ptr<Widget>> processedWidgets;
class Widget{
private:
...
public:
...
	void process();
...
};

void Widget::process() {
...
// After process
processedWidgets.emplace_back(this); // Compiles, but disaster.
}

std::vector<std::shared_ptr<Widget>> processedWidgets;
class Widget : public std::enable_shared_from_this<Widget> {
private:
...
public:
...
	void process();
...
};

void Widget::process() {
	...
	// After process
	processedWidgets.emplace_back(std::shared_from_this());
}

class Widget : public std::enable_shared_from_this<Widget> {
private:
    Widget() {}

public:
    static std::shared_ptr<Widget> create() {
        return std::make_shared<Widget>();
    }
    void process() {
        auto self = shared_from_this();
    }
};

std::shared_ptr fastLoadWidget(WidgetID id) { 
	static std::unordered_map<WidgetID, std::weak_ptr<Widget> cache; 
	auto objPtr = cache[id].lock(); // objPtr is std::shared_ptr 
									// to cached object (or null 
									// if object's not in cache) 

	if (!objPtr) {                  // if not in cache, 
		objPtr = loadWidget(id);    // load it 
		cache[id] = objPtr;         // cache it 
	} 
	return objPtr; 
}