内存管理

// RAII基类模板
template<typename Resource, typename Deleter>
class RAIIWrapper {
public:
    // 构造时获取资源
    explicit RAIIWrapper(Resource* res) : resource_(res) {}
    
    // 析构时自动释放资源
    ~RAIIWrapper() {
        Deleter{}(resource_);  // 调用删除器释放资源
    }
    
    // 访问资源
    Resource* get() const { return resource_; }
    
private:
    Resource* resource_;  // 管理的资源指针
};

// ... existing code ...
private:
    _LIBCPP_NO_UNIQUE_ADDRESS __compressed_pair<pointer, deleter_type> __ptr_;
// ... existing code ...

// ... existing code ...
// 非数组版本make_unique
 template <class _Tp, class... _Args>
inline _LIBCPP_HIDE_FROM_ABI
typename __unique_ptr_traits<_Tp>::pointer
__make_unique(_Args&&... __args) {
    return ::new _Tp(std::forward<_Args>(__args)...);
}

 template <class _Tp, class... _Args>
inline _LIBCPP_HIDE_FROM_ABI
unique_ptr<_Tp>
make_unique(_Args&&... __args) {
    return unique_ptr<_Tp>(__make_unique<_Tp>(std::forward<_Args>(__args)...));
}

// ... existing code ...

// ... existing code ...
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 ~unique_ptr() { reset(); }

// ... existing code ...

// ... existing code ...
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer release() _NOEXCEPT {
pointer __t = __ptr_;
__ptr_ = pointer();
return __t;
}

_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void reset(pointer __p = pointer()) _NOEXCEPT {
pointer __tmp = __ptr_;
__ptr_ = __p;
if (__tmp)
__deleter_(__tmp);
}
// ... existing code ...

// ... existing code ...
private:
    element_type* __ptr_;       // 指向实际对象的指针
    __shared_weak_count* __cntrl_;  // 指向控制块的指针
// ... existing code ...

// 1. 初始化原始指针成员
explicit shared_ptr(_Yp* __p) : __ptr_(__p) {
// 2. 用 unique_ptr 临时持有 __p，确保异常安全
unique_ptr<_Yp> __hold(__p);
// 3. 定义分配器与控制块类型
typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
typedef __shared_ptr_pointer<_Yp*, __shared_ptr_default_delete<_Tp, _Yp>, _AllocT> _CntrlBlk;
// 4. 构造控制块（包含引用计数、删除器、分配器）
__cntrl_ = new _CntrlBlk(__p, __shared_ptr_default_delete<_Tp, _Yp>(), _AllocT());
// 5. 控制块构造成功，释放 unique_ptr 的临时所有权
__hold.release();
// 6. 启用 weak_this 机制（支持 enable_shared_from_this）
__enable_weak_this(__p, __p);

}

class _LIBCPP_EXPORTED_FROM_ABI __shared_weak_count : private __shared_count {

long __shared_weak_owners_;           //弱引用计数

public:

_LIBCPP_HIDE_FROM_ABI explicit __shared_weak_count(long __refs = 0) _NOEXCEPT

: __shared_count(__refs),           //强引用计数

__shared_weak_owners_(__refs) {}

protected:

~__shared_weak_count() override;

public:

#if defined(_LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS)

void __add_shared() noexcept;

void __add_weak() noexcept;

void __release_shared() noexcept;

#else

_LIBCPP_HIDE_FROM_ABI void __add_shared() _NOEXCEPT { __shared_count::__add_shared(); }

_LIBCPP_HIDE_FROM_ABI void __add_weak() _NOEXCEPT { __libcpp_atomic_refcount_increment(__shared_weak_owners_); }

_LIBCPP_HIDE_FROM_ABI void __release_shared() _NOEXCEPT {

if (__shared_count::__release_shared())

__release_weak();

}
#endif
void __release_weak() _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT { return __shared_count::use_count(); }
__shared_weak_count* lock() _NOEXCEPT;
virtual const void* __get_deleter(const type_info&) const _NOEXCEPT;

private:
virtual void __on_zero_shared_weak() _NOEXCEPT = 0;

};

// 减少强引用计数，返回是否为最后一个引用
bool __release_shared() noexcept {
    if (__atomic_fetch_sub(&__shared_, 1, __ATOMIC_ACQ_REL) == 1) {
        __on_zero_shared();
        return true;
    }
    return false;
}
// ... existing code ...

// ... existing code ...
template <class _Tp, class... _Args>
inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>
make_shared(_Args&&... __args) {
    typedef typename __shared_ptr_default_allocator<_Tp>::type _Alloc;
    return std::allocate_shared<_Tp>(_Alloc(), std::forward<_Args>(__args)...);
}

// 分配并构造对象和控制块
 template <class _Tp, class _Alloc, class... _Args>
inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>
allocate_shared(const _Alloc& __a, _Args&&... __args) {
    return __allocate_shared_common<_Tp>(__a, std::forward<_Args>(__args)...);
}
// ... existing code ...

~shared_ptr() noexcept {
  if (__cntrl_) __cntrl_->__release_shared(); // __cntrl_ 是控制块指针
}

// 减少强引用计数，返回是否为最后一个引用
bool __release_shared() noexcept {
    if (__atomic_fetch_sub(&__shared_, 1, __ATOMIC_ACQ_REL) == 1) {
        __on_zero_shared();  
        return true;
    }
    return false;
}
// ... existing code ...

void __release_weak() noexcept {
  if (__atomic_fetch_sub(&_weak_count, 1, __ATOMIC_ACQ_REL) == 1) {
    __on_zero_shared_weak(); // 弱引用计数归零，释放控制块内存
  }
}

class __shared_weak_count : public __shared_count {
  long __shared_weak_owners_; // 弱引用计数
public:
  void __add_weak() noexcept;    // 弱引用+1
  void __release_weak() noexcept; // 弱引用-1
};

private:
    element_type* __ptr_;       // 指向实际对象的指针
    __shared_weak_count* __cntrl_;  // 指向控制块的指针

// ... existing code ...
shared_ptr<_Tp> lock() const noexcept {
    shared_ptr<_Tp> __r;
    __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_;
    if (__r.__cntrl_)
        __r.__ptr_ = __ptr_;
    return __r;
}
// ... existing code ...

#include <memory>
#include<iostream>
class B;

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::shared_ptr<A> a_ptr;
    ~B() { std::cout << "B destroyed" << std::endl; }
};

void test_circular_reference() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->b_ptr = b;  // A引用B
    b->a_ptr = a;  // B引用A，形成循环
}
// 函数结束时，a和b析构，但A和B的引用计数仍为1，导致内存泄漏

int main(){
    test_circular_reference();
}

#include <memory>
#include <iostream>
class B;

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::weak_ptr<A> a_ptr;  // 使用weak_ptr打破循环
    ~B() { std::cout << "B destroyed" << std::endl; }
};

void test_solve_circular_reference() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->b_ptr = b;
    b->a_ptr = a;  // weak_ptr不增加强引用计数
}
// 函数结束时，a和b析构，A和B的引用计数降为0，正确释放

int main(){
	test_solve_circular_reference(); 
}