Namespaces
Variants

std::shared_ptr<T>:: reset

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::shared_ptr
Member functions
Modifiers
shared_ptr::reset
Observers
(C++17)
( until C++20* )
(C++26)
(C++26)
Non-member functions
(C++20)
(C++20)
(C++17)
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
functions ( until C++26* )
Helper classes
(C++20)
Deduction guides (C++17)
void reset ( ) noexcept ;
(1) (自 C++11 起)
template < class Y >
void reset ( Y * ptr ) ;
(2) (自 C++11 起)
template < class Y, class Deleter >
void reset ( Y * ptr, Deleter d ) ;
(3) (自 C++11 起)
template < class Y, class Deleter, class Alloc >
void reset ( Y * ptr, Deleter d, Alloc alloc ) ;
(4) (自 C++11 起)

将托管对象替换为由 ptr 指向的对象。可提供可选删除器 d ，当没有 shared_ptr 对象拥有新对象时，该删除器将被用于销毁该对象。默认情况下，使用 delete 表达式作为删除器。始终会选择与所提供类型对应的正确 delete 表达式，这就是该函数通过单独参数 Y 实现为模板的原因。

如果 * this 已拥有一个对象且它是最后一个拥有该对象的 shared_ptr ，则会通过所拥有的删除器销毁该对象。

如果 ptr 指向的对象已被持有，该函数通常会导致未定义行为。

1) 释放所管理对象的所有权（如果存在）。调用后， * this 不再管理任何对象。等效于 shared_ptr ( ) . swap ( * this ) ; 。
2-4) 将托管对象替换为由 ptr 指向的对象。 Y 必须是完整类型且可隐式转换为 T 。此外：
2) 使用 delete 表达式作为删除器。必须提供有效的 delete 表达式，即 delete ptr 必须格式正确、具有明确定义的行为且不抛出任何异常。等效于 shared_ptr < T > ( ptr ) . swap ( * this ) ; 。
3) 使用指定的删除器 d 作为删除器。 Deleter 必须对类型 T 可调用，即 d ( ptr ) 必须格式正确、具有明确定义的行为且不抛出任何异常。 Deleter 必须满足 可复制构造 要求，且其拷贝构造函数和析构函数不得抛出异常。等效于 shared_ptr < T > ( ptr, d ) . swap ( * this ) ; 。
4) 与 (3) 相同，但额外使用 alloc 的副本进行内部数据分配。 Alloc 必须满足 分配器 要求。拷贝构造函数和析构函数不得抛出异常。等效于 shared_ptr < T > ( ptr, d, alloc ) . swap ( * this ) ; 。

目录

参数

ptr - 指向要获取所有权的对象的指针
d - 用于对象删除的删除器
alloc - 用于内部分配的分配器

返回值

(无)

异常

2) std::bad_alloc 如果无法获取所需的额外内存。对于其他错误可能抛出实现定义的异常。若发生异常则会调用 delete ptr 。
3,4) std::bad_alloc 若无法获取所需的额外内存。对于其他错误可能抛出实现定义的异常。若发生异常，将调用 d ( ptr ) 。

示例

运行此代码 
#include <iostream>
#include <memory>
struct Foo
{
    Foo(int n = 0) noexcept : bar(n)
    {
        std::cout << "Foo::Foo(), bar = " << bar << " @ " << this << '\n';
    }
    ~Foo()
    {
        std::cout << "Foo::~Foo(), bar = " << bar << " @ " << this << '\n';
    }
    int getBar() const noexcept { return bar; }
private:
    int bar;
};
int main()
{
    std::cout << "1) 独占所有权\n";
    {
        std::shared_ptr<Foo> sptr = std::make_shared<Foo>(100);
        std::cout << "Foo::bar = " << sptr->getBar() << ", use_count() = "
                  << sptr.use_count() << '\n';
        // 重置 shared_ptr 而不提供新的 Foo 实例
        // 原有实例将在本次调用后被销毁
        std::cout << "调用 sptr.reset()...\n";
        sptr.reset(); // 在此处调用 Foo 的析构函数
        std::cout << "reset() 后: use_count() = " << sptr.use_count()
                  << ", sptr = " << sptr << '\n';
    }   // 不会调用 Foo 的析构函数，已在之前的 reset() 中执行
    std::cout << "\n2) 独占所有权\n";
    {
        std::shared_ptr<Foo> sptr = std::make_shared<Foo>(200);
        std::cout << "Foo::bar = " << sptr->getBar() << ", use_count() = "
                  << sptr.use_count() << '\n';
        // 重置 shared_ptr，为其提供新的 Foo 实例
        // 原有实例将在本次调用后被销毁
        std::cout << "调用 sptr.reset()...\n";
        sptr.reset(new Foo{222});
        std::cout << "reset() 后: use_count() = " << sptr.use_count()
                  << ", sptr = " << sptr << "\n离开作用域...\n";
    }   // 调用 Foo 的析构函数
    std::cout << "\n3) 多重所有权\n";
    {
        std::shared_ptr<Foo> sptr1 = std::make_shared<Foo>(300);
        std::shared_ptr<Foo> sptr2 = sptr1;
        std::shared_ptr<Foo> sptr3 = sptr2;
        std::cout << "Foo::bar = " << sptr1->getBar() << ", use_count() = "
                  << sptr1.use_count() << '\n';
        // 重置 shared_ptr sptr1，为其提供新的 Foo 实例
        // 原有实例将继续由 sptr2 和 sptr3 共享
        std::cout << "调用 sptr1.reset()...\n";
        sptr1.reset(new Foo{333});
        std::cout << "reset() 后:\n"
                  << "sptr1.use_count() = " << sptr1.use_count()
                  << ", sptr1 @ " << sptr1 << '\n'
                  << "sptr2.use_count() = " << sptr2.use_count()
                  << ", sptr2 @ " << sptr2 << '\n'
                  << "sptr3.use_count() = " << sptr3.use_count()
                  << ", sptr3 @ " &lt

参见

构造新的 shared_ptr
(公开成员函数)