C++ : Smart Pointers

#include<iostream>
#include<memory>
#include<string>

using namespace std;

class AudioBook {
    
    private:
    string title;
    string author;
    public:
    AudioBook() {}
    AudioBook (string arg_title, string arg_author): title(arg_title), author(arg_author)
    {}
    inline void PlayBook() {
       cout << "Playing : " << title << endl;
    }   
};

void With_UniquePointer(void) {

    unique_ptr<AudioBook> uptr_a(new AudioBook("Lord Of The Rings", "J. R. R. Tolkien")); 
    uptr_a->PlayBook();

    // Note : make_unique function efficiently creates and returns a unique pointer and is recommended over
    // directly calling unique_ptr constructor.
    auto uptr_b = make_unique<AudioBook>("Game Of Thrones", "George RR Martin"); 
    uptr_b->PlayBook();
}

void With_RawPointer(void) {
    AudioBook * rawptr = new AudioBook("The Hitchhiker's Guide to the Galaxy", "Douglas Adams"); 
    rawptr->PlayBook();

    // Make sure that raw pointer (rawptr) is deleted, else it would cause memory leak.
    delete rawptr;
}

int main() {
    With_UniquePointer();
    With_RawPointer(); 
    return 0;
}

Playing : Lord Of The Rings
Playing : Game Of Thrones
Playing : The Hitchhiker's Guide to the Galaxy

#include <iostream>
#include <memory>
 
class Stock
{
    private:
    std :: string stock_name;
    std :: shared_ptr<Stock> purchase;
    
    public:
    Stock (const std::string& name) : stock_name (name) { 
        std :: cout << "Stock object [" << stock_name << "] created" << std :: endl;
    }   

    ~Stock () {
        std :: cout << "Stock object [" << stock_name << "] destroyed" << std :: endl;
    }   
    
    // The Transact function purchases stock_b with stock_a and vice-versa thereby creating a circular references.
    static void Transact (std :: shared_ptr<Stock>& stock_a, std :: shared_ptr<Stock>& stock_b) {
   
        if (stock_a && stock_b) {
            stock_a->purchase = stock_b;
            stock_b->purchase = stock_a;
            std :: cout << "Transaction 1" << std :: endl;
            std :: cout << "Stock [" << stock_a->stock_name << "] purchased with stock [" << stock_b->stock_name << "]\n";
            std :: cout << "Transaction 2" << std :: endl;
            std :: cout << "Stock [" << stock_b->stock_name << "] purchased with stock [" << stock_a->stock_name << "]\n";
        }
    }   
};
 
int main() {

   auto tesla { std :: make_shared<Stock>("Tesla") }; 
   auto google { std :: make_shared<Stock>("Google") }; 

   // Purchase Tesla stock with Google and vice-versa
   Stock :: Transact (tesla, google);
   return 0;
}

Stock object [Tesla] created
Stock object [Google] created
Transaction 1
Stock [Tesla] purchased with stock [Google]
Transaction 2
Stock [Google] purchased with stock [Tesla]

#include<iostream>
#include<memory>
#include<string>

class AudioBook {

    private:

    std::string title;
    std::string author;

    public:

    AudioBook() {}

    AudioBook (std::string arg_title, std::string arg_author): title(arg_title), author(arg_author) { 
        std :: cout << "Parameterized constructor for AudioBook got called." << std :: endl;
    }   

    inline void PlayBook() {
        std::cout << "Playing : " << title << std::endl;
    }   

    ~AudioBook() {
        std :: cout << "Destructor for AudioBook got called." << std :: endl;
    }   
};

int main() {
 
    auto uptr_a = std::make_unique<AudioBook>("Lord Of The Rings", "J. R. R. Tolkien"); 
    uptr_a->PlayBook();
 
    auto uptr_b = std::move(uptr_a);
    uptr_b->PlayBook();
 
    uptr_b.reset(); // Memory freed as nobody owns it now.
    return 0;
}

Parameterized constructor for AudioBook got called.
Playing : Lord Of The Rings
Playing : Lord Of The Rings
Destructor for AudioBook got called.

#include<iostream>
#include<memory>
#include<string>

class AudioBook {

    private:

    std :: string title;
    std :: string author;

    public:
    AudioBook() {}
    AudioBook (std :: string arg_title, std :: string arg_author) : title(arg_title), author(arg_author) {
        std :: cout << "Parameterized constructor for AudioBook got called" << std :: endl;
    }
    inline void PlayBook() {
       std::cout << "Playing : " << title << std :: endl;
    }
    ~AudioBook() {
        std :: cout << "Destructor for AudioBook got called" << std :: endl;
    }
};

int main() {

    auto shared_ptr_a = std :: make_shared<AudioBook>("Sherlock Holmes", "Arthur Conan Doyle");
    shared_ptr_a->PlayBook();

    {
        // Initialization via assignment operator increments the reference count.
        auto shared_ptr_b = shared_ptr_a;
        shared_ptr_b->PlayBook();

        // Initialization via copy constructor increments the reference count.
        auto shared_ptr_c(shared_ptr_b);
        shared_ptr_c->PlayBook();

        // When the below shared pointer that is not being shared with others goes out of scope,
        // the destructor gets called.
        auto shared_ptr_scoped = std :: make_shared<AudioBook>("Rabbit & Bear", "Julian Gough");
        shared_ptr_scoped->PlayBook();
    }

    // Shared pointer can also be initialized with null pointer
    auto shared_ptr_d(nullptr);

    std :: cout << "Program ends. Returning now" << std :: endl;
    return 0;
}

Parameterized constructor for AudioBook got called
Playing : Sherlock Holmes
Playing : Sherlock Holmes
Playing : Sherlock Holmes
Parameterized constructor for AudioBook got called
Playing : Rabbit & Bear
Destructor for AudioBook got called
Program ends. Returning now
Destructor for AudioBook got called

#include <iostream>
#include <memory>

class Stock
{
    private:
    std :: string stock_name;
    // Shared pointer [ std :: shared_ptr<Stock> ] would give rise to circular references, causing a memory leak.
    // The memory leak could be fixed by making purchase a weak pointer [ std :: weak_ptr<Stock> ]
    std :: weak_ptr<Stock> purchase;

    public:
    Stock (const std :: string& name) : stock_name (name) {
        std :: cout << "Stock object [" << stock_name << "] created" << std :: endl;
    }

    ~Stock () {
        std :: cout << "Stock object [" << stock_name << "] destroyed" << std :: endl;
    }

    // // The Transact function purchases stock_b with stock_a and vice-versa thereby creating a circular references.
    static void Transact (std :: shared_ptr<Stock>& stock_a, std :: shared_ptr<Stock>& stock_b) {

        if (stock_a && stock_b) {
            stock_a->purchase = stock_b;
            stock_b->purchase = stock_a;
            std :: cout << "Transaction 1" << std :: endl;
            std :: cout << "Stock [" << stock_a->stock_name << "] purchased with stock [" << stock_b->stock_name << "]\n";
            std :: cout << "Transaction 2" << std :: endl;
            std :: cout << "Stock [" << stock_b->stock_name << "] purchased with stock [" << stock_a->stock_name << "]\n";
        }
    }
};

int main() {

   auto tesla { std :: make_shared<Stock>("Tesla") };
   auto google { std :: make_shared<Stock>("Google") };

   // Purchase Tesla stock with Google and vice-versa
   Stock :: Transact (tesla, google);
   return 0;
}

Stock object [Tesla] created
Stock object [Google] created
Transaction 1
Stock [Tesla] purchased with stock [Google]
Transaction 2
Stock [Google] purchased with stock [Tesla]
Stock object [Google] destroyed
Stock object [Tesla] destroyed