#include <iostream>

class TestObject {
public:
    TestObject() {
        std::cout << "Constructor" << std::endl;
        instanceCount += 1;
    }

    TestObject(const TestObject &other) {
        std::cout << "Copy constructor" << std::endl;
    }

    ~TestObject() {
        std::cout << "Destructor" << std::endl;
        instanceCount -= 1;
    }

    static void testPrint() {
        std::cout << "testPrint" << std::endl;
    }

    static int getInstanceCount() {
        return instanceCount;
    }

private:
    static int instanceCount;
};

int TestObject::instanceCount = 0;

/// Holds unique ownership of a pointed to object and destroys it automatically
template<class T>
class UniquePtr {
public:
    explicit UniquePtr(T *object) : object(object) {}

    /// Copy constructor
    /// Shouldn't be used, since the pointer wouldn't be unique otherwise
    UniquePtr(const UniquePtr &other) = delete;

    /// Move constructor
    UniquePtr(UniquePtr &&other) : object(other.object) {
        other.object = nullptr;
    }

    /// Copy assignment operator
    UniquePtr &operator=(const UniquePtr &) = delete;

    /// Move assignment operator
    /// Shouldn't be used, since the pointer wouldn't be unique otherwise
    UniquePtr &operator=(UniquePtr &&) = delete;

    /// Destructor
    virtual ~UniquePtr() {
        delete object;
    }

    T operator*() const {
        return *object;
    }

    operator bool() const {
        return object != nullptr;
    }

    T *operator->() const {
        return object;
    }

    /// Release ownership of the owned object and return the pointer to it
    T *Release() {
        T *returnObject = object;
        object = nullptr;

        return returnObject;
    }

    /// Reset the internal pointer to null
    void Reset() {
        delete object;

        object = nullptr;
    }

    /// Swaps the currently owned object with another
    void Swap(T *other) {
        delete object;

        object = other;
    }

private:
    T *object;
};

int main() {
    {
        std::cout << "Constructing first pointer" << std::endl;
        UniquePtr pointer = UniquePtr<TestObject>(new TestObject());

        std::cout << "Calling test print via pointer" << std::endl;
        pointer->testPrint();

        std::cout << "Swapping for new object" << std::endl;
        pointer.Swap(new TestObject());

        std::cout << "Move constructing new pointer" << std::endl;
        UniquePtr pointer2 = UniquePtr<TestObject>(std::move(pointer));
    }

    std::cout << std::endl << "All pointers should now be out of scope!" << std::endl;
    std::cout << TestObject::getInstanceCount() << " instances left" << std::endl;

    return 0;
}