UniquePtr.h

浏览该文件的文档.

 
#pragma once
 
#include <type_traits>
#include <utility>
#include "../DebugTools/MemoryCheak.h"
#include "RefCount.h"
 
namespace FCT {

    template<typename T>
    class UniquePtr {
    public:
        // 编译时检查，确保 T 没有继承自 RefCount
        static_assert(!std::is_base_of<FCT::RefCount, T>::value,
            "UniquePtr cannot manage types derived from FCT::RefCount. Use a reference-counting pointer instead.");

        UniquePtr() noexcept : m_ptr(nullptr) {}

        explicit UniquePtr(T* ptr) noexcept : m_ptr(ptr) {}

        UniquePtr(UniquePtr&& other) noexcept : m_ptr(other.release()) {}

        UniquePtr& operator=(UniquePtr&& other) noexcept {
            if (this != &other) {
                reset(other.release());
            }
            return *this;
        }
 
        // 禁止拷贝构造和拷贝赋值
        UniquePtr(const UniquePtr&) = delete;
        UniquePtr& operator=(const UniquePtr&) = delete;

        ~UniquePtr() {
            reset();
        }

        T* release() noexcept {
            T* temp = m_ptr;
            m_ptr = nullptr;
            return temp;
        }

        void reset(T* ptr = nullptr) noexcept {
            if (m_ptr) {
                FCT_DELETE(m_ptr);
            }
            m_ptr = ptr;
        }

        T* get() const noexcept {
            return m_ptr;
        }

        T& operator*() const {
            return *m_ptr;
        }

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

        explicit operator bool() const noexcept {
            return m_ptr != nullptr;
        }
 
    private:
        T* m_ptr;
    };

    template<typename T, typename... Args>
    UniquePtr<T> makeUnique(Args&&... args) {
        return UniquePtr<T>(FCT_NEW(T, std::forward<Args>(args)...));
    }
 
} // namespace FCT