PV913qunique_ptr_basics

#include<iostream>
#include <chrono>

class Element
{
    int val;
public:
    Element(int valP) : val{ valP } { std::cout << "Element constructed for " << this << '\n'; };
    Element() : Element{ 0 } {};
    ~Element(){ std::cout << "Element destructed for " << this << '\n'; };
    int getVal() const { return val; };
};


template <typename T>
class SmartPtr
{
    T* ptr;
public:
    SmartPtr(T* ptrP) : ptr{ ptrP } {}
    ~SmartPtr() { delete ptr; }

    SmartPtr(const SmartPtr& obj) = delete;
    SmartPtr& operator=(const SmartPtr& obj) = delete;

    SmartPtr(SmartPtr&& sPtr)
        : ptr{ sPtr.ptr }
    {
        sPtr.ptr = nullptr;
    }

    SmartPtr& operator=(SmartPtr&& sPtr)
    {
        if (!(&sPtr == this))
        {
            ptr = sPtr.ptr;
            sPtr.ptr = nullptr;
        }
        return *this;
    }

    T& operator*() { return *ptr; };
    const T& operator*()const { return *ptr; };
    T* operator->() { return ptr; };
    const T* operator->()const { return ptr; };
    T* release() noexcept { ptr = nullptr; return ptr; };
    const T* get()const { return ptr; };
};

void foo()
{
    //Element* ptr{ new Element{rand() % 10} };
    //SmartPtr<Element> sPtr{ ptr };
    SmartPtr<Element> sPtr{ new Element{rand() % 10} };

    std::cout << "Value is: " << sPtr->getVal() << '\n';
    //if (ptr->getVal() < 6) { throw std::runtime_error("Too small"); };
    if (sPtr->getVal() < 6) { throw std::runtime_error("Too small"); };

    // some work with ptr
    //delete ptr;
}

std::unique_ptr<Element> generateElement()
{
    auto ptr{ std::make_unique<Element>(rand() % 10) };
    return ptr;
}

void useElement(const Element& el)
{
    std::cout << "useElement: Value is: " << el.getVal() << '\n';
    //return el;
}
int main()
{
    srand(time(nullptr));

    //for (int i{ 0 }; i < 5; ++i)
    //{
    //  try
    //  {
    //      foo();
    //  }
    //  catch (std::exception ex)
    //  {
    //      std::cout << "Exception! => " << ex.what() << '\n';
    //  }
    //
    //}
    //SmartPtr<Element> sPtr{ new Element{rand() % 10} };
    //std::cout << "Value is: " << sPtr->getVal() << '\n';
    //std::cout << "sPtr == nullptr " << (sPtr.get() == nullptr) << '\n';
    //delete sPtr.release();
    //std::cout << "sPtr == nullptr " << (sPtr.get() == nullptr) << '\n';
    //std::cout << " Programm is still running! \n";
    /*auto sPtrOne{ std::move(sPtr) };
    std::cout << "sPtr == nullptr " << (sPtr->get() == nullptr) << '\n';
    std::cout << "sPtrOne == nullptr " << (sPtrOne.get() == nullptr) << '\n';
    std::cout << "Value is: " << sPtrOne->getVal() << '\n';*/

    //std::unique_ptr<Element> uPtr{ std::make_unique<Element>(rand() % 10) };
    std::unique_ptr<Element> uPtr{ generateElement() };
    useElement(*uPtr);
    std::cout << "uPtr != nullptr " << static_cast<bool>(uPtr) << '\n';

    return 0;

    std::cout << "Value is: " << uPtr->getVal() << '\n';
    std::cout << "uPtr != nullptr " << static_cast<bool>(uPtr) << '\n';
    //delete uPtr.release();
    std::cout << "uPtr != nullptr " << static_cast<bool>(uPtr) << '\n';
    auto uPtrOne{ std::move(uPtr) };
    std::cout << "uPtr != nullptr " << static_cast<bool>(uPtr) << '\n';
    std::cout << "uPtrOne != nullptr " << static_cast<bool>(uPtrOne) << '\n';
    std::cout << "Value is: " << uPtrOne->getVal() << '\n';
    uPtrOne.reset(new Element{ 42 });
    std::cout << "Value is: " << uPtrOne->getVal() << '\n';
    std::cout << " Programm is still running! \n";
}