智能指针的使用及其实现原理

已于 2022-10-17 09:04:40 修改
阅读量1.2k 收藏 6
点赞数 1
分类专栏： C++ 面试题 数据结构 文章标签： 算法 c++ 数据结构
于 2022-10-12 20:57:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhybiancheng/article/details/127290515
版权
C++ 同时被 3 个专栏收录
16 篇文章 2 订阅
订阅专栏
数据结构
11 篇文章 0 订阅
订阅专栏
面试题
9 篇文章 0 订阅
订阅专栏
  • 目录
    • 裸指针和智能指针
    • 自己实现智能指针
    • 不带引用计数的智能指针
    • 带引用计数的智能指针
    • 智能指针的循环引用（交叉引用）问题
    • 多线程共享对象的线程安全问题
    • 自定义删除器
    • make_shared和make_unique
    • enable_shared_from_this类和shared_from_this()方法

裸指针和智能指针

传统的指针，例如int* p = new int(1)，我们称为“裸指针”。其会向系统申请堆资源，但是由于使用不当，所以往往会出现“内存泄漏”的问题。情况如下：

  • 忘记写delete去释放堆资源
  • 代码提前退出，导致没有执行delete
  • 代码抛出异常，导致没有执行delete
  • . . .

此时就需要使用智能指针去托管裸指针的资源。
智能指针的作用：保证对象申请的堆资源能够被自动释放。

template<typename T>
class SmartPtr
{
public:
    SmartPtr(T *_ptr = nullptr)
        :ptr(_ptr)
    {}
    ~SmartPtr() { delete ptr; }
private:
    T *ptr;
};

这就是一个最简单的智能指针，利用的就是栈上的对象出作用域的时候自动析构的特征来做到资源的自动释放。

作为指针，它也要能够解引用(*ptr)和使用->。所以可以改进一下

template<typename T>
class SmartPtr
{
public:
    SmartPtr(T *_ptr = nullptr)
        :ptr(_ptr)
    {}
    ~SmartPtr() { delete ptr; }
    // 返回*ptr的引用
    T& operator*() { return *ptr; }
    // 返回ptr本身
    T* operator->() { return ptr; }
private:
    T *ptr;
};

int main()
{
    SmartPtr<int> ptr(new int(666));
    // 相当于 ptr.operator*();
    cout << *ptr << endl; // 666

    struct Test
    {
        void print() { cout << "hello world" << endl; }
    };
    SmartPtr<Test> ptr2(new Test());
    // 相当于 ptr2.operator->().print();
    ptr2->print(); // "hello world"
    // 相当于 ptr2.operator*().print();
    (*ptr2).print(); // "hello world"

    return 0;
}

不带引用计数的智能指针：auto_ptr，scoped_ptr，unique_ptr

我们来想一下下面这种智能指针的使用场景。

template<typename T>
class SmartPtr
{
public:
    SmartPtr(T *_ptr = nullptr)
        :ptr(_ptr)
    {}
    ~SmartPtr() { delete ptr; }
private:
    T *ptr;
};

int main()
{
    SmartPtr<int> ptr1(new int(0));
    SmartPtr<int> ptr2(ptr1);
    return 0;
}

如果两个智能指针都要托管同一块资源，但是由于资源只能被释放一次，而两个智能指针在析构的时候，都会调用delete。因此在第二次资源被delete的时候，就会系统异常。

这种智能指针的“浅拷贝”带来的问题让人棘手，因为并不能将智能指针改成“深拷贝“。

template<typename T>
class SmartPtr
{
public:
    SmartPtr(T *_ptr = nullptr)
        :ptr(_ptr)
    {}
    // 当进行智能指针拷贝构造的时候，进行“深拷贝”
    SmartPtr(const SmartPtr<T>& src)
    {
        ptr = new T(*src.ptr);
    }
    T& operator*() { return *ptr; }
    ~SmartPtr() { delete ptr; }
private:
    T *ptr;
};

int main()
{
    SmartPtr<int> ptr1(new int(666));
    SmartPtr<int> ptr2(ptr1);
    *ptr2 = 20;
    cout << *ptr1 << endl; // 输出666
    return 0;
}

用户本来想让两个指针管理同一块资源，但是由于深拷贝，两个指针分别管理内容相同的内存。因此这达不到裸指针原本想要的效果。

在C++库中有三种不实现引用计数的智能指针，分别是

  • auto_ptr
  • scoped_ptr
  • unique_ptr

auto_ptr

int main()
{
    auto_ptr<int> ptr1(new int(10));
    auto_ptr<int> ptr2(ptr1);
    cout << *ptr1 << endl; // 空指针异常
    return 0;
}

上面这段导致系统崩溃了。原因其实就是auto_ptr的实现原理有关。当auto_ptr进行赋值构造的时候，当前智能指针就会管理资源的权力全部交给被赋值的对象，而自己就指向空了。

T* release()
{
	T* tmp = ptr;
	ptr = nullptr;
	return tmp;
}

所以导致当使用*ptr1的时候，就会报出空指针异常的错误。
由于auto_ptr这种特性，所以官方是不推荐使用这种指针的。因为可能由于忘记了哪一个智能指针有管理资源的权力，导致错误地使用了智能指针，最终导致了空指针异常。

scoped_ptr

scoped_ptr内部实现更加暴力，它不能被赋值或者拷贝。

scoped_ptr(const scoped_ptr<T>&) = delete;
scoped_ptr<T>& operator=(const scoped_ptr<T>&) = delete;

unique_ptr

unique_ptr和scoped_ptr有一点是相同的，unique_ptr也是不能被拷贝或者赋值的。但是不同的时候，unique_ptr中支持移动构造和移动赋值。

unique_ptr(const unique_ptr<T>&) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>&) = delete;

// 支持移动构造和移动赋值
unique_ptr(const unique_ptr<T>&& src);
unique_ptr<T>& operator=(const unique_ptr<T>&& src);

如果配合move将变量转成右值引用或者传递临时对象的时候，就可以拷贝构造或者赋值出unique_ptr。

template<typename T>
unique_ptr<T> getSmartPtr()
{
    unique_ptr<T> ptr(new T());
    return ptr;
}

int main()
{
    unique_ptr<int> ptr1(new int);
    //  unique_ptr<int> ptr2(ptr1) // 错误
    unique_ptr<int> ptr2(move(ptr1)); // move移动语义将变量强转成右值

    unique_ptr<int> ptr3 = getSmartPtr<int>(); // getSmartPtr返回的是临时智能指针对象
    return 0;
}

综合来说还是比较推荐使用unique_ptr的，因为在智能指针之间的拷贝或者赋值的时候，使用者还是会感知到资源是被转移的。而不像auto_ptr会经常忘记资源管理权在谁手上。

带引用计数的智能指针：shared_ptr和weak_ptr

不带引用计数的智能指针同时只能存在一个智能指针在管理资源。而带引用计数的智能指针就可以实现多个智能指针管理同一块资源。
其原理就是：每一个智能指针对象都有一个引用计数，记录就是该智能指针指向的资源有多少个对象在管理。每当多出一个对象管理该资源，引用计数++。反之，若对象不管理该资源，引用计数–。并且只有当引用计数为0的时候，资源才会被释放。

/**
 * 多个对象共用同一个引用计数空间
 */
template<typename T>
class RefCnt
{
public:
    RefCnt(T *ptr = nullptr)
        : ptr_(ptr)
        , count_(0)
    {
        if (ptr_ != nullptr)
           count_ = 1;
    }
	// 线程不安全
    void addRef() { count_ ++; }
    int delRef() { return -- count_; }
private:
    T *ptr_;
    int count_;
};

/**
 * 实现是一个带引用计数的智能指针（不保证线程安全）
 */
template<typename T>
class SmartPtr
{
public:
    SmartPtr(T *ptr = nullptr)
            : ptr_(ptr)
    {
        refCnt_ = new RefCnt<T>(ptr_);
    }
    // 拷贝构造
    SmartPtr(const SmartPtr<T>& src)
        : ptr_(src.ptr_)
        , refCnt_(src.refCnt_)
    {
        if (ptr_ != nullptr)
            refCnt_->addRef();
    }
    // 赋值
    SmartPtr<T>& operator=(const SmartPtr<T>& src)
    {
        if (this == &src)
            return *this;

        // 如果当前对象的引用计数为0的时候，就释放该对象
        if (0 == refCnt_->delRef())
        {
            delete ptr_;
        }
        ptr_ = src.ptr_;
        refCnt_ = src.refCnt_;
        refCnt_->addRef();
        return *this;
    }

    T& operator*() { return *ptr_; }
    T* operator->() { return ptr_; }
    ~SmartPtr()
    {
		// 只有当引用计数为0的时候，才会delete回收资源
        if (0 == refCnt_->delRef())
        {
            delete ptr_;
            ptr_ = nullptr;
        }
    }
private:
    T *ptr_;
    RefCnt<T> *refCnt_; // 指向该资源的引用计数的指针
};

int main()
{
    SmartPtr<int> ptr1(new int(0));
    SmartPtr<int> ptr2(ptr1);
    SmartPtr<int> ptr3;
    ptr3 = ptr2;
    *ptr1 = 666;
    cout << *ptr2 << ' ' << *ptr3 << endl;
    return 0;
}

上面实现的智能指针中RefCount的count使用的是int，而在addRef和delRef中都是直接使用++和–的，所以在多线程环境下会造成数据不一致的情况。
在share_ptr和weak_ptr的实现原理和上述智能指针类似，但是其引用计数采用的是atomic_int，其通过CAS锁机制保证了++和–是线程安全的。

shared_ptr带来的循环引用问题

shared_ptr被称为强智能指针，weak_ptr被称为弱智能指针。其中的区别就是shared_ptr会改变资源的引用计数，而weak_ptr不会改变资源的引用计数。
shared_ptr这种强智能指针会循环引用的问题，如下代码：

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

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

int main()
{
    shared_ptr<A> ptra(new A());
    shared_ptr<B> ptrb(new B());

    ptra->ptrb_ = ptrb;
    ptrb->ptra_ = ptra;

	// use_count()可以查看指针指向的资源的引用计数
	cout << ptra.use_count() << endl; // 2
	cout << ptrb.use_count() << endl; // 2

    return 0;
}

当ptra和ptrb不再指向申请的内存的时候，A和B内部的ptrb_和ptra_还会指向申请的资源，导致引用计数没有减到0，因此资源没有释放。
在这里插入图片描述

此时就需要使用到weak_ptr。 一般在定义对象的时候，用强智能指针；引用对象的时候，使用弱智能指针。 由于弱智能指针不会影响到引用计数的增减，所以不会影响到资源的释放。

class B;
class A
{
public:
    A() { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }
    weak_ptr<B> ptrb_; // 弱智能指针
};

class B
{
public:
    B() { cout << "B()" << endl; }
    ~B() { cout << "~B()" << endl; }
    weak_ptr<A> ptra_; // 弱智能指针
};

int main()
{
    shared_ptr<A> ptra(new A());
    shared_ptr<B> ptrb(new B());

    ptra->ptrb_ = ptrb;
    ptrb->ptra_ = ptra;

    cout << ptra.use_count() << endl; // 1
    cout << ptrb.use_count() << endl; // 1

    return 0;
}

在这里插入图片描述

注意：weak_ptr可以解决循环引用的问题，是因为weak_ptr在申请资源的过程中只充当了一个观察者的身份。即weak_ptr不能像裸指针那样使用*ptr或者ptr->。如果一定想要使用weak_ptr调用其指向对象中的函数的话，就需要将weak_ptr提升成为shared_ptr。

class B;
class A
{
public:
    A() { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }
    void print() { cout << "hello world" << endl; }
    weak_ptr<B> ptrb_; // 弱智能指针
};

class B
{
public:
    B() { cout << "B()" << endl; }
    ~B() { cout << "~B()" << endl; }
    void print()
    {
		// 通过lock()，可以将弱智能指针提升为强智能指针
        shared_ptr<A> p = ptra_.lock();
        // 如果ptra_指向的资源还存在的话，就可以提升成功。否则返回nullptr
        // 判断ptra_提升成功为强智能指针。
        if (p != nullptr)
            p->print();

    }
    weak_ptr<A> ptra_; // 弱智能指针
};

int main()
{
    shared_ptr<A> ptra(new A());
    shared_ptr<B> ptrb(new B());
	
    ptrb->print(); // B: print() -> A:print() -> "hello world"
    return 0;
}

多线程下共享资源的线程安全问题

我们来看这样一个场景

class A
{
public:
    A() { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }
    void print() { cout << "hello world" << endl; }
};

void handler(A* ptr)
{
    ptr->print();
}

int main()
{
    A *ptr = new A();
	// 起一个线程去调用ptr指向的A()的print()
    thread t(handler, ptr);

    delete ptr;
    t.join();
    return 0;
}

结果：
在这里插入图片描述

如果我们将A析构，资源释放之后。子线程中是否还能够调用A()中的print()呢？

class A
{
public:
    A() { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }
    void print() { cout << "hello world" << endl; }
};

void handler(A* ptr)
{
    // 让子线程睡眠2s，让主线程中先调用delete将A析构掉
    this_thread::sleep_for(chrono::seconds(2));
    ptr->print();
}

int main()
{
    A *ptr = new A();
    thread t(handler, ptr);

    delete ptr;
    t.join();
    return 0;
}

结果：:
在这里插入图片描述

我们惊奇地发现，虽然已经调用~A()释放了A对象的资源。但是线程任然可以调用A()的print()。这就导致了线程不安全。

想要解决这个问题就需要使用到weak_ptr和shared_ptr配合。在子线程中weak_ptr来观察资源是否存在，如果存在就提升为强智能指针然后调用A()的print()。如果不存在就不调用。

class A
{
public:
    A() { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }
    void print() { cout << "hello world" << endl; }
};

// 这里使用weak_ptr接收传递过来的“弱化”的ps
void handler(weak_ptr<A> ptrw)
{
    // 子线程睡眠2s，等待主线程析构掉ptrw指向的对象
    std::this_thread::sleep_for(std::chrono::seconds(2));
    shared_ptr<A> ptrs = ptrw.lock();
    if (ptrs != nullptr)
    {
        ptrs->print();
    }
    else
    {
        cout << "~A(), A was destroyed" << endl;
    }
}

int main()
{
    thread t;
    {
        shared_ptr<A> ps(new A());
        // 传递过去ps的弱智能指针
        t = thread(handler, weak_ptr<A>(ps));
    } // 出了作用域 ps 调用析构函数，销毁ps指向的A()对象
    
    t.join();
    return 0;
}

结果：在这里插入图片描述

因为A()资源被销毁了，所以弱智能智能没能成功升级，所以没有调用print();

如果想要让子线程中的弱智能指针升级为强智能指针的话，就可以让主线程不要那么快就将A()资源释放。

class A
{
public:
    A() { cout << "A()" << endl; }
    ~A() { cout << "~A()" << endl; }
    void print() { cout << "hello world" << endl; }
};

void handler(weak_ptr<A> ptrw)
{
    shared_ptr<A> ptrs = ptrw.lock();
    if (ptrs != nullptr)
    {
        ptrs->print();
    }
    else
    {
        cout << "~A(), A was destroyed" << endl;
    }
}

int main()
{
    thread t;
    {
        shared_ptr<A> ps(new A());
        // 传递过去ps的弱智能指针
        t = thread(handler, weak_ptr<A>(ps));
        
        // 让主线程睡眠2s，这样子线程中的智能指针就可以升级为强智能指针了
        std::this_thread::sleep_for(std::chrono::seconds(2));
    } // 出了作用域 ps 调用析构函数，销毁ps指向的A()对象

    t.join();
    return 0;
}

小总结：

  • weak_ptr帮助shared_ptr解决了循环引用的问题。
  • weak_ptr作为弱智能指针通常充当了一个观察者的身份，来判断其指向的资源是否存在。如果存在就可以提升成为强指针指针进行资源的使用；否则就不能使用资源。

自定义删除器

删除器就是一个函数对象。智能指针在调用析构函数需要以删除器这个函数对象重载的operator()来“释放”资源。在unique_ptr和shared_ptr中都是存在默认的删除器。

template<typename T>
class default_delete
{
public:
    void operator()(T* ptr)
    {
		// 默认直接使用delete释放资源
        delete ptr;
    }
};

源码：在这里插入图片描述

默认的释放资源的方式就是直接使用delete，但是很多资源不能使用delete。例如：如果申请了100个int元素的空间数组，就需要使用delete[]来释放资源。如果是打开的文件，要就需要使用fclose来关闭文件。
因此就需要我们自定义删除器，来做到定制化的“释放资源”服务。

template<typename T>
class arr_delete
{
public:
    void operator()(T* ptr)
    {
        delete[] ptr;
    }
};

template<typename T>
class file_delete
{
public:
    void operator()(T* ptr)
    {
        fclose(ptr);
    }
};

int main()
{
    unique_ptr<int, arr_delete<int>> ptr1(new int[100]);
    unique_ptr<FILE, file_delete<FILE>> ptr2(fopen("test.txt", "w"));
    return 0;
}

使用lambda表达式优化删除器

每一个定制的删除器只会被用在智能指针析构的时候，所以其实不用专门定义一个类。而可以使用lambda表达式来构造一个函数对象。

int main()
{
	// lambda表达式要放在unique_ptr的第二个参数中
	// 同时<>泛型的第二个参数要指明lambda表达式的类型,可以使用function<>
    unique_ptr<int, function<void(int*)>> ptr1(
			  new int[100]
			, [](int* ptr) { delete[] ptr; });
    unique_ptr<FILE, function<void(FILE*)>> ptr2(
             fopen("test.txt", "w")
			,[](FILE* ptr) { fclose(ptr);});
    return 0;
}

用make_shared，make_unique代替shared_ptr，unique_ptr

最后来说一下前面shared_ptr存在的问题。shared_ptr在使用的时候可能会出现循环引用的问题，这个可以通过使用weak_ptr做解决。但是shared_ptr还可能会出现内存泄漏的问题。

template<typename T>
class shared_ptr
{
private:
	int *ptr_;   // 指向资源的指针
	RefCnt *ref; // 指向资源的引用计数
};

在使用shared_ptr的时候，其中有两个指针，一个指向的是申请的资源，一个指向的是该资源的引用计数。这两块空间都是需要new出来的。如果申请的资源new成功了，但是引用计数的空间new失败了，那么这块空间就没有办法进行释放了，这就造成了内存泄漏。
在这里插入图片描述

注：uses是强引用指针的引用个数，weaks是弱引用指针的引用个数。

所以C++11中提供了make_shared来配合使用。make_shared的返回值就是shared_ptr，但是在make_shared的构造函数中不用手动进行new空间。而是直接将值写入make_shared的构造函数中，自动会分配空间。最重要的是make_shared会将外界需要创建的空间和引用计数所需的空间一起开辟，从而使得两块空间都能开辟成功或者都失败。
在这里插入图片描述

这样带来的好处就是两块空间一起开辟，分配资源的效率变高了。同时防止了资源泄漏的风险。

int main()
{
    shared_ptr<int> ps = make_shared<int>(10);
    auto ps2 = make_shared<int>(10);
    cout << *ps << ' ' << *ps2 << endl; // 10 10
    return 0;
}

但是这样也带来了一些缺陷。原本两块空间是分别存储的，所以当引用计数中强引用计数的个数为0的时候，申请的资源就可以被回收了。等待弱引用指针的指向也为0的时候，引用计数的空间才会被释放。现在申请的空间和引用计数的空间放在一起了，当强智能指针的指向为0，而弱智能指针的引用不为0的时候，不能释放申请的空间。因为此时引用计数不能释放，而两块空间是在一起的，所以申请的空间也不能被释放。这就导致了申请的内存被延迟释放的问题。
另外make_shared不能定制删除器，所以想要打开一个文件的时候，就不能将FILE托管给make_shared而只能给unique_ptr或者shared_ptr了。

总结：

  • make_shared优点
    1. 分配资源效率变高
    2. 防止资源泄漏
  • make_shared缺点
    1. 托管的资源延迟释放
    2. 不能定制删除器

类似的C++14中针对unique_ptr也做了一个make_unique，作用和make_shared类似，也是将unique_ptr指向的内存和引用计数的空间一起开辟防止资源泄漏。

enable_shared_from_this和shared_from_this()

如果想要在一个类中以智能指针的方式返回一个对象的资源，该怎么办呢？是这样吗？

class A
{
public:
    A()
    {
        ptr_ = new int(0);
    }

    ~A()
    {
        delete ptr_;
        ptr_ = nullptr;
    }

    shared_ptr<A> getSmartPtr()
    {
        return shared_ptr<A>(this);
    }

private:
    int* ptr_;
};


int main()
{
    shared_ptr<A> ptr1(new A());
    shared_ptr<A> ptr2 = ptr1->getSmartPtr(); // 获得A()中的智能指针
    
    cout << ptr1.use_count() << endl; // 1
    cout << ptr2.use_count() << endl; // 2
	// 系统崩溃
    return 0;
}

有上文可知，shared_ptr有两种构造函数，一种是针对裸指针的，一种是针对智能指针的。对于裸指针的构造函数，shared_ptr会创建出该指针指向的资源的引用计数。对于智能指针的构造函数，shared_ptr会增加指向资源的引用计数。

如果getSmartPtr()通过shared_ptr(this)这样实现的话，getSmartPtr返回的临时对象会创建出一个指向该资源的引用计数。当该临时对象销毁的时候，因为它指向的引用计数只有这个临时对象使用，所以随着临时对象的消失，该引用计数也要被销毁，从而资源也要被销毁。这个不是我们想要的。因为ptr1还在管理该资源，在ptr1析构的时候，又会析构一次该资源，那么就会导致nullptr exception。

shared_ptr(this)肯定是不行的了，所以C++中提供了enable_shared_from_this这个基类，该类中有一个成员函数shared_from_this()可以以智能指针的形式返回当前类的对象（等同于shared_ptr(this)），同时不会增加资源的引用计数的个数。从而不会造成资源被析构多次的情况。

class A : public enable_shared_from_this<A>
{
public:
    A()
    {
        ptr_ = new int(0);
    }

    ~A()
    {
        delete ptr_;
        ptr_ = nullptr;
    }

    shared_ptr<A> getSmartPtr()
    {
        return shared_from_this();
    }

private:
    int* ptr_;
};


int main()
{
    shared_ptr<A> ptr1(new A());
    shared_ptr<A> ptr2 = ptr1->getSmartPtr(); // 获得A()中的智能指针

    cout << ptr1.use_count() << endl; // 2
    cout << ptr2.use_count() << endl; // 2
    return 0;
}

原理实现

  • enable_shared_from_this类中有一个weak_ptr，当调用shared_ptr的裸指针的构造函数，就会初始化该weak_ptr，并作为观察者观察A对象的资源。（关键）
  • 当调用shared_from_this的时候，就会去尝试将weak_ptr升级为shared_ptr。如果weak_ptr观察的资源还存在的话，weak_ptr就可以升级为shared_ptr。否则不行。

问题集

SmartPtr *p = new p(SmartPtr());像这样使用智能指针管理一块堆资源可以吗？

不可以，因为申请的堆资源还是用裸指针来管理的。

auto_ptr可以用在容器当中吗？

不可以，因为容器中的拷贝和赋值涉及的元素很多。由于auto_ptr的赋值，会导致赋值之前的容器中的元素全部都不能再使用了。

注意事项

shared_ptr虽然能够帮助我们实现多个指针同时管理一块资源。但是也有很多问题：

  • 循环引用：
    • 要配合weak_ptr使用，让weak_ptr去观察资源，但是不增加引用计数的引用数量。
    • 编程建议：一般在定义对象的时候，用强智能指针；引用对象的时候，使用弱智能指针。
  • 资源泄漏：创建资源引用计数失败，导致资源无法被回收
    • 要配合make_shared使用。make_shard将资源空间和指向它的引用计数空间合并成一块。
    • 编程建议：多使用make_shared去管理资源。
  • 空指针异常：多次使用裸指针去构造shared_ptr，导致资源的引用计数有多个，在对象析构的时候，资源会被释放多次
    • 要配合enable_shared_from_this类和其成员函数shared_from_this()使用。
    • 编程建议：多个shared_ptr托管相同资源时，第一个shared_ptr使用裸指针构造，其他的shared_ptr都是用智能指针构造。
hyzhang_
关注
专栏目录
智能指针的使用和原理
编程爱好者的博客
03-18 536
不多说一个Demo上来 void other(shared_ptr<vector<int>>& smart_p2) { shared_ptr<vector<int>>smart_p4 = smart_p2;//赋值重载 printf("1,2,3,4数组的引用计数是%d\n", smart_p2.use_count()); } voi...
C++智能指针及其原理
weixin_44788162的博客
03-22 307
智能指针介绍 智能指针(RAII)是利用对象的生命周期来管理资源的技术。 RAII，Resource Acquisition Is Initialization 顾名思义，就是在初始化对象的时候获取资源，在这个对象进行析构时会帮我们释放资源，这样做的好处有很多： 不需要显示的释放资源 可以避免因为没有及时释放资源而造成的内存泄漏 资源的生命周期与对象相同 智能指针原理 下面简单的实现一个智能指...
智能指针的实现及原理
10-27 8855
 本文主要讨论C++程序设计的一种常用技术——智能指针（smart pointer），主要内容包括引用计数（reference count）和句柄类(handle class)。如果文中有错误或遗漏之处，敬请指出，谢谢！    作者： tyc611, 2007-02-01   当类中有指针成员时，一般有两种方式来管理指针成员：一是采用值型的方式管理，每个类对象都保留一份指针指向的对
C++智能指针及其应用
最新发布
weixin_46366676的博客
10-14 765
但是，引用计数带来了很多问题，下面将把这些问题提出，并给出shared_ptr解决问题的设计方案。
C++中智能指针的工作原理和简单实现
weixin_30814223的博客
03-18 128
智能指针：它的一种通用实现方法是采用引用计数的方法。智能指针将一个计数器与类指向的对象相关联，引用计数跟踪共有多少个类对象共享同一指针。 每次创建类的新对象时，初始化指针并将引用计数置为1； 当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数； 对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则...
智能指针_百度百科
xu的blog
09-29 1155
导读： 智能指针　　智能指针Smart Pointer 编辑本段智能指针的原理及实现　　当类中有指针成员时，一般有两种方式来管理指针成员：一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。　　智能指针(smart pointer)的一种通用实现技术是使用引用计数(reference count)。智能
智能指针实现原理
bureau123的博客
05-20 759
std智能指针
C++智能指针的原理和实现.pdf
02-27
三、智能指针的实现原理 智能指针通常包含一个原始指针成员，用于存储动态分配的对象。它们的构造函数接收一个原始指针，并在析构函数中调用`delete`释放内存。此外，智能指针还提供了操作符重载，如`*`和`->`，...
C++智能指针的原理及其线程安全性不可多说
秃头的博客
07-23 976
C++标准库中主要提供了三种智能指针：std::unique_ptr、std::shared_ptr和std::weak_ptr。原理： std::shared_ptr 是一种共享所有权的智能指针，多个shared_ptr可以指向同一个对象，使用引用计数来跟踪有多少个shared_ptr指向同一个对象。转移所有权的线程安全：**std::unique_ptr的所有权转移操作（例如std::move）在单线程环境中是安全的，但在多线程环境中需要额外的同步来保证线程安全。1.所有权独占：不能复制，但可以移动。
Chromium学习之智能指针
11-13
在Chromium项目中，智能指针的实现非常关键，本文将重点介绍Chromium中几种智能指针的实现机制及其应用场景。 #### 二、第一类智能指针：`scoped_refptr` 第一类智能指针允许多个智能指针共享同一个对象。为了实现...
C++ 智能指针的简单原理
duchenlong的博客
08-27 428
C++中的智能指针，auto_ptr，std::unique_ptr，std::shared_ptr（线程安全），weak_ptr和守卫锁的原理和简单的模拟实现。以及delete带来的可能存在的内存泄漏的问题
智能指针的实现及原理 + Good ! 句柄类
so true_interview /
12-15 1291
C++程序设计的一种常用技术——智能指针（smart pointer），主要内容包括引用计数（reference count）和句柄类(handle class)。 当类中有指针成员时，一般有两种方式来管理指针成员：一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。    智能指针(smart pointer)的
智能指针的实现原理及使用
magic_world_wow的博客
08-03 602
C/C++的内存管理比较繁琐，在使用C++编程时经常从堆上申请内存（new），当使用完毕后我们需要将申请的内存归还（delete）。一般情况下我们申请一次就得释放一次，即new多少内存就delete多少。所以在C++中new和delete是成对出现的。但是当我们申请(new)了一部分内存而在释放(delete)之前程序返回或没有执行到delete处程序抛出异常结束了，那么我们申请的内存就无法归还给...
智能指针的实现
weixin_33895695的博客
04-07 85
看到了迭代器这里，想到了应该把智能指针的知识总结一下了 我实现了三种智能指针，分别是auto_ptr,scoped_ptr,shared_ptr命名是根据boost库中的智能指针命名的 什么是智能指针？智能指针可以帮助你在忘记释放new出来的内存的时候自动帮助你释放内存 可以有效避免内存泄漏 例如当异常出现，跳转之后。。。内存是应该被释放的呀，一直抓住人家不放会造成内存泄漏哦 智能指针就...
C++中为什么需要智能指针
skiing_886的专栏
09-03 3399
对于C/C++程序员来说，指针是天堂，同时指针也是地狱。指针有多少好处，又有多少让人头疼的问题我们这里就不多说了。但为了局部解决指针的问题，我们提出了智能指针这个概念。   实际上，我一直不明白，智能指针用于干什么！直到我遇到有关栈和堆问题的时候，才依稀有了点感悟，我现在的感悟几乎肯定是不全面的，但是很重要。 几乎有关指针的问题的出现集中在指针指向堆上空间的时候，为什么呢？
智能指针的原理、使用和实现
热门推荐
一个小孩
08-10 1万+
1，智能指针的作用 C++程序设计中使用堆内存是非常频繁的操作，堆内存的申请和释放都由程序员自己管理。程序员自己管理堆内存可以提高了程序的效率，但是整体来说堆内存的管理是麻烦的，C++11中引入了智能指针的概念，方便管理堆内存。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，程序发生异常时内存泄露等问题等，使用智能指针能更好的管理堆内存。理解智能指针需要从下面三个层次： 从较浅的层面看，智能指针是利用了一种叫做RAII（资源获取即初始化）的技术对普通的指针进行封装，这使...
智能指针详细解析(智能指针的使用，原理解析)
qq_61988957的博客
12-01 4904
智能指针的使用跟普通指针类似，可以使用运算符“ * " 和 ” -> "去获得指向的对象，因此，我们就需要在类中重载" * " 和" -> "函数。当程序结束时，此时ptr1和ptr2指针被销毁时，对象ptr1和ptr2会自动调用析构函数去释放所指向的资源，这是智能指针特点。由于我的类中没有定义拷贝构造函数和赋值重载函数，那么我们只能调用类中原生的拷贝构造函数和赋值重载函数。那么就会程序就会出现崩溃的问题，如下:ptr2和ptr1指向的同一块空间。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hyzhang_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值