从 RAII 到 smartPtr：智能指针的原理及实现

最新推荐文章于 2024-08-06 16:24:59 发布
最新推荐文章于 2024-08-06 16:24:59 发布
阅读量220 收藏
点赞数 1
分类专栏： C/C++ 文章标签： c++ 后端 面试 编程语言 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhousc91/article/details/104217337
版权

从 RAII 到 smartPtr：智能指针的原理及实现

RAII 的基本概念

什么是堆

在内存管理的范畴中，我们将程序中能够动态分配内存的区域称为堆 - heap，C/C++ 都提供了操作 heap 的函数或运算符：

  • C 使用 malloc/free 操作 heap

  • C++ 使用 new/delete 操作 heap

类似于下面的代码就会在堆上分配内存：

auto vecPtr = new std::vector<int>();

在堆上分配了内存之后的另一个问题就是释放内存，和 Java 的垃圾收集机制不同，C++ 的内存分配和释放都由内存管理器来操作，通常都不使用垃圾收集，我们需要做的只是把 new 出来的内存再通过 delete 释放掉即可，但是事实上真的这么简单吗？

什么是栈

函数在运行过程中调用数据、生成数据时使用的内存区域称为栈 - stack，它和数据结构中的栈类似，都是 LIFO。以 x86 为例，栈的增长方向是由高地址向低地址增长，函数之间调用时，调用函数会将自己的参数压入栈中，同时把自己下一行的指令也压入栈中，再跳转到新的函数并调整栈指针，新的函数在执行完之后会根据栈中保存的调用函数的地址重新回到调用函数未执行的地方继续执行。

由此可见，栈上空间的分配和释放逻辑都十分简单，只要移动栈指针即可，具体分配空间的时候，每个函数分到的属于自己的那一份称为栈帧 - stack frame，即使是有构造函数和析构函数的情况下，C++ 的编译器也会在栈帧的适当位置添加对构造函数和析构函数的调用。这个过程中，就算函数抛出了异常，编译器也会自动调用析构函数，来看一个例子：

class Obj{
public:
    Obj(){ puts("Obj()"); }
    ~Obj(){ puts("~Obj()"); }
};

void func(int n){
    Obj obj;
    if (n > 0)
        throw "func error";
}

int main() {
    try{
        func(0);
        func(1);
    }
    catch (const char* str){
        puts(str);
    }
    return 0;
}

Output:
    Obj()
    ~Obj()
    Obj()
    ~Obj()
    func error

也就是说，func(1) 在将异常抛出之前就已经调用了自身的析构函数，而这点正是 RAII 的基础，也是最重要的部分。

什么是 RAII

RAII - Resource Acquisition Is Initialization，资源获取即初始化，RAII 是一种资源管理方式，它通过栈和析构函数来管理包括堆在内的所有资源，主流的编程语言中只有 C++ 是使用 RAII 来管理资源的，下面来看一个 C++ 工厂方法的简单示例，为了防止发生对象切片的错误（C++ 的值语义特点所带来的的编码陷阱：函数返回类型为父类对象，实际返回的为子类对象），工厂方法需要返回一个父类对象的指针或者是引用：

// C++11 后建议使用强类型枚举
enum class animalType {
    cat,
    dog,
    fox,
    ...
};

class animal {...};
class cat : public animal {...};
class dog : public animal {...};
class fox : public animal {...};

animal* buyNewAnimal(animalType ani_type){
    switch(ani_type) {
        case animalType::cat :
            return new cat();
        case animalType::dog :
            return new dog();
        case animalType::fox :
            return new fox();
    }
}

此时返回的是一个 animal 类型的父类指针，指向的是子类对象，问题来了，buyNewAnimal 函数返回 animal 指针后便退出了，堆上已经开辟出空间 animal 子类的对应空间，如何才能保证这一部分内存不泄漏？

智能指针的基本概念

C 和 C++ 的老程序员都曾大量接触过裸指针，都曾一边享受着指针带来的便利一边不停地给自己挖坑埋坑，在介绍智能指针之前，先看看使用指针的时候常见的坑有哪些：

  • 忘记 delete/free 导致内存泄露

  • 同一个指针释放多次，程序崩溃

  • 逻辑 bug，写了 delete/free 结果没有执行到

  • delete/free 之前抛出了异常

前面已经介绍过了，C++ 没有自动内存回收机制，new 出来的必须要自己 delete 掉，智能指针的引入，让程序员可以不再关注资源的释放，它能够保证程序无论正常或异常，在到期的时候都能通过 RAII 机制成功回收。

来看上一节中 buyNewAnimal 函数返回的 animal 指针，只需要将这个返回值放入一个本地变量中，确保这个变量析构的时候会删除上面的对象即可：

class smartAnimalPtr {
public:
    explicit smartAnimalPtr(animal* animalPtr) : animalPtr_(animalPtr){}
    // delete nullptr is legal operation
    ~smartAnimalPtr(){
        delete animalPtr_;
    }
    animal* getPtr() const {
        return animalPtr_;
    }
private:
    animal* animalPtr_{nullptr};
};

void func(){
    smartAnimalPtr newAnimalPtr(buyNewAnimal(dog));
}

func 调用的 buyNewAnimal 函数返回值被 newAnimalPtr 接管，使用者可以直接调用 newAnimalPtr.getPtr() 使用原指针，当 func 函数结束时，newAnimalPtr 析构，animalPtr_ 所指向的区域被释放，整个过程不需要手动调用 delete，而是通过 RAII 巧妙地交给编译器处理了。

除了 delete 之外，在本地变量的析构函数中还可以执行以下操作：

  • 释放同步锁，如下面的多线程累加范例：
std::mutex sum_lock;

void add(int& sum, int& num){
    while(true){
        // 结束一轮 while 后 sum_lock 自动释放
        std::lock_guard<std::mutex> lock(sum_lock);
        if (num < 100) {
            num += 1;
            sum += num;
        }
        else {
            break;
        }
    }
}

int main(){
    int sum = 0, num = 0;
    std::vector<std::thread> tdVec;
    for(int i = 0; i < 10; ++i){
        std::thread td = std::thread(add, std::ref(sum), std::ref(num));
        tdVec.emplace_back(std::move(td));
    }
    // std::mem_fn can generate an object for pointers to members as well as ref and pointers to an object
    std::for_each(tdVec.begin(), tdVec.end(), std::mem_fn(&std::thread::join));
    std::cout << sum << std::endl;
    return 0;
}
  • 关闭文件，如 fstream 析构时会调用 close 以防止流对象销毁后还与打开的文件相关联

上面实现的 smartAnimalPtr 已经可以算是一个简单的智能指针啦。

auto_ptr

我们将 smartAnimalPtr 模板化，并添加一些常用的指针操作：

template <typename T>
class smartAutoPtr {
public:
    explicit smartAutoPtr(T* ptr) : ptr_(ptr) {}
    ~smartAutoPtr() { delete ptr_; }
    T* getPtr() const { return ptr_; }
    T* operator->() const { return ptr_; }
    T& operator*() const { return *ptr_; }
    // 重载 bool 转换运算符
    operator bool() const { return ptr_; }
private:
    T* ptr_{nullptr};
};

上面的代码存在一个很严重的问题，当 smartAutoPtr 拷贝构造或者被赋值时，因为有两个指针指向同一片区域，RAII 会让这片区域释放两次！解决这个问题的第一种方法、也是最简单的方法是禁用这两个函数：

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

第二种方法，我们可以在拷贝构造和赋值时转移指针的所有权，而这也正是 auto_ptr 的处理方式：

template <typename T>
class smartAutoPtr {
public:
    explicit smartAutoPtr(T* ptr) : ptr_(ptr) {}

    smartAutoPtr(const smartAutoPtr& _Right) {
        ptr_ = _Right.release();
    }

    // copy and swap
    // _Right --> smartAutoPtr(_Right) --> _New
    smartAutoPtr& operator=(const smartAutoPtr& _Right) {
        smartAutoPtr(_Right).reset(*this);
        return *this;
    }

    ~smartAutoPtr() { delete ptr_; }
    T* getPtr() const { return ptr_; }
    T* operator->() const { return ptr_; }
    T& operator*() const { return *ptr_; }
    operator bool() const { return ptr_; }

    // 剥夺原 smartAutoPtr 对指针的所有权给新 smartAutoPtr
    T* release() {
        T* _Tmp = ptr_;
        ptr_ = nullptr;
        return _Tmp;
    }
    void reset(smartAutoPtr& _New) {
        using std::swap;
        swap(ptr_, _New.ptr_);
    }
private:
    T* ptr_{nullptr};
};

赋值运算符的重载利用了 copy and swap 技术，即先通过拷贝构造创建一个新的对象，再交换它们的指针，这样能够保证强安全性，构造是否成功完全不会破坏赋值运算符两边的数据。

由上面的代码不难看出，auto_ptr 在拷贝构造和赋值运算时都会完全剥夺原对象对指针的所有权，也就是说除了最后一个 auto_ptr，其余所有的 auto_ptr 都变成了 nullptr，全部失效了，这样会带来几个问题：

  • STL 对容器类型的要求是要有值语义，即可以复制和赋值。auto_ptr 的复制和赋值经过了 release 和 reset 的处理，因此 auto_ptr 对象不能作为 STL 的容器元素。

  • 将 auto_ptr 作为函数参数按值传递时，函数会在其作用域中生成该 auto_ptr 的拷贝，此时的指针所有权已经转移给了这个临时对象，当函数退出时，该临时对象析构，原 auto_ptr 所指向的对象也被删除了，如果不得不使用 auto_ptr 作为函数参数时，最好使用 const auto_ptr& 的方式。

值得注意的是，auto_ptr 已经从 C++17 标准中删除了。

unique_ptr

unique_ptr 与 auto_ptr 在特性上相差不大，同一时刻只能有唯一的一个 unique_ptr 指向给定的对象，unique_ptr 在处理智能指针拷贝构造和赋值时发生的浅拷贝问题上采用了 smartAutoPtr 所使用的方法一，即直接将拷贝构造和赋值运算禁用，此外，unique_ptr 还引入了移动构造，在 C++11 之前，如果想要将源对象的状态转移到目标对象只能通过拷贝构造，C++11 开始，我们不再需要复制对象，只需要移动对象即可，也就是把源对象的资源控制权转交给目标对象，这个过程中不再需要多余的复制操作。我们将上面的 auto_ptr 稍微修改可以得到一个简化版的 unique_ptr：

template <typename T>
class smartUniquePtr {
public:
    explicit smartUniquePtr(T* ptr) : ptr_(ptr) {}

    // 移动构造函数不会在类中默认生成
    smartUniquePtr(smartUniquePtr&& _Right) {
        ptr_ = _Right.release();
    }

    // 类型转换移动构造
    template <typename U>
    smartUniquePtr(smartUniquePtr<U>&& _Right) {
        ptr_ = _Right.release();
    }

    // necessary
    smartUniquePtr(const smartUniquePtr&) = delete;
    template <typename U>
    smartUniquePtr(const smartUniquePtr<U>&) = delete;

    // new _Right --> *this
    smartUniquePtr& operator=(smartUniquePtr _Right) {
        _Right.reset(*this);
        return *this;
    }

    ~smartUniquePtr() { delete ptr_; }
    T* getPtr() const { return ptr_; }
    T* operator->() const { return ptr_; }
    T& operator*() const { return *ptr_; }
    operator bool() const { return ptr_; }

    T* release() {
        T* _Tmp = ptr_;
        ptr_ = nullptr;
        return _Tmp;
    }
    void reset(smartUniquePtr& _New) {
        using std::swap;
        swap(ptr_, _New.ptr_);
    }
private:
    T* ptr_{nullptr};
};

上面的代码需要注意，在定义了移动构造函数的情况下，如果没有提供拷贝构造函数，会自动禁用拷贝构造函数。
但是，编译器并不会把 smartUniquePtr(smartUniquePtr<U>&& _Right) {} 看作是移动构造，换句话说，编译器不会把所有的模板函数看作构造函数，如果想消除代码重复，仍然需要将拷贝构造函数手动禁用。
再看 smartUniquePtr 的使用：

    // buyNewAnimal 返回的是一个临时变量，调用移动构造函数
    smartUniquePtr<animal> ptr1{ buyNewAnimal(animalType::dog) };
    smartUniquePtr<animal> ptr2{ nullptr };
    // ptr1 是一个左值，需要转换成右值
    // ptr1 --> temp rv obj --> ptr3
    smartUniquePtr<animal> ptr3 = std::move(ptr1);
    smartUniquePtr<animal> ptr4{ std::move(ptr3) };

unique_ptr 除了能够支持管理堆上分配的内存，还能够通过移动语义使 unique_ptr 对象与容器兼容。
但 unique_ptr 仍然有一些不足，它仍然无法避免重复释放的问题，使用移动语义之后的源对象也仍然失去了对原指针的所有权，无法再次使用。
要避免上述这些情况，最好的办法是使用带有引用计数功能的智能指针。

shared_ptr

在 unique_ptr 中，一个对象只能被一个 unique_ptr 拥有，这在大部分场合是无法满足要求的，更常见的是多个智能指针同时拥有一个对象，只有当所有的指针都失效了，才会删除该对象，这样的智能指针就是 shared_ptr。
shared_ptr 的底层通过引用计数来进行空间管理，每当有一个新的指针指向这块空间时，引用计数加一，反之减一，直到引用计数为零时才释放空间。
来看一下 shared_ptr 的简单实现，和 unique_ptr 的不同之处在于它需要实现共享的引用计数，因此我们在堆上 new 一个 ref_count 出来，并在 shared_ptr 中保存指向它的指针，完整的操作需要包含 add、reduce 和 get 三种行为：

class ref_count {
public:
    ref_count() noexcept : cnt_(1) {}
    void add() noexcept { ++cnt_; }
    long reduce() noexcept { return --cnt_; }
    long get() const noexcept { return cnt_; }
private:
    long cnt_;
};

template <typename T>
class smartSharedPtr {
public:
    template <typename U>
    friend class smartSharedPtr;

    explicit smartSharedPtr(T* ptr = nullptr) : ptr_(ptr) {
        if (ptr_) {
            refptr_ = new ref_count();
        }
    }

    // copy constructor ref_count add
    smartSharedPtr(const smartShared& _Right) {
        ptr_ = _Right.ptr_;
        if (ptr_) {
            _Right.refptr_->add();
            refptr_ = _Right.refptr;
        }
    }

    // template copy constructor
    template <typename U>
    smartSharedPtr(const smartSharedPtr<U>& _Right) noexcept {
        ptr_ = _Right.ptr_;
        if (ptr_) {
            _Right.refptr_->add();
            refptr_ = _Right.refptr;
        }
    }

    // template move constructor
    template <typename U>
    smartSharedPtr(smartSharedPtr<U>&& _Right) noexcept {
        ptr_ = _Right.ptr_;
        if (ptr_) {
            refptr_ = _Right.refptr_;
            _Right.ptr_ = nullptr;
        }
    }

    // overload assignment operator
    smartSharedPtr& operator=(smartSharedPtr _Right) noexcept {
        _Right.swap(*this);
        return *this;
    }

    ~smartSharedPtr() {
        // 每次析构时都需要将 ref_count 减一
        if (ptr_ && !refptr_->reduce()) {
            delete ptr_;
            delete ref_count_;
        }
    }

    // get ref_count
    long getRefCnt() const {
        if (ptr_) {
            return refptr_->get();
        }
        else {
            return 0;
        }
    }

    T* getptr() const noexcept { return ptr_; }
    T& operator*() const noexcept { return *ptr_; }
    T* operator->() const noexcept { return ptr_; }
    operator bool() const noexcept { return ptr_; }

    void swap(smartSharedPtr& _New) noexcept {
        using std::swap;
        swap(ptr_, _New.ptr_);
        swap(refptr_, _New.refptr_);
    }

private:
    T* ptr_;
    ref_count* refptr_;
};

template <T>
void swap(smartSharedPtr<T>& _Left, smartSharedPtr<T>& _Right) noexcept {
    _Left.swap(_Right);
}

在上面的代码中，需要注意以下几点：

  • 为了让编译器优化代码，需要为移动构造函数添加 noexcept 声明

  • refptr_ 为每个类的私有成员，是不能在 smartSharedPtr 对象之间共享的，需要添加友元类的声明

  • 按照现代 C++ 标准需要设计支持移动的对象，即对象不仅要有 swap 成员函数与另一个对象交换，在其所属名空间下还需要需要有一个全局 swap 函数提供给其他对象使用

  • 智能指针还需要实现类型转换的函数模板，这里给出 dynamic_cast，其他实现与此类似：

// for pointer type conversion
template <typename U>
smartSharedPtr(const smartSharedPtr<U>& _Right, T* ptr) {
    ptr_ = ptr;
    if (ptr_) {
        _Right.refptr_->add();
        refptr_ = _Right.refptr_;
    }
}

// 取出 _Right 的 ptr_ 转换成 T 类型后将 ref_count++ 并包装返回
template <typename T, typename U>
smartSharedPtr<T> dynamic_pointer_cast(const smartSharedPtr<U>& _Right) {
    T* _Tmp = dynamic_cast<T*>(_Right.getptr());
    return smartSharedPtr<T>(_Right, _Tmp);
}

weak_ptr

shared_ptr 通常被称为强智能指针，而 weak_ptr 被称为弱智能指针，介绍 weak_ptr 之前先看下面的代码：

class B;
class A {
public:
    A () {}
    ~A () {}
    shared_ptr<B> ptrb;
};
class B {
public:
    B () {}
    ~B () {}
    shared_ptr<A> ptra;
};

int main() {
    // ref_count of A is 1
    shared_ptr<A> ptra(new A());
    // ref_count of B is 1
    shared_ptr<B> ptrb(new B());
    // ref_count of B is 2
    ptra->ptrb = ptrb;
    // ref_count of A is 2
    ptrb->ptra = ptra;
    std::cout << ptra.use_count() << ptrb.use_count() << std::endl;
    return 0;
}

main 结束时，两个对象的引用计数分别减到 1，因为不等于 0，不满足对象的空间释放条件，最终导致内存泄露，这个问题被称为 shared_ptr 的循环引用问题。

那么怎么解决这个问题呢？当然是通过 weak_ptr，weak_ptr 对 shared_ptr 管理的对象存在非拥有性引用，换句话说，它表达的是一种临时所有权 - 如果某个对象只有存在的时候才需要被访问，而且随时可能会被删除导致指针失效时，就使用 weak_ptr 跟踪该对象，当 weak_ptr 需要使用该对象时，需要将其升级为 shared_ptr，如果原 shared_ptr 销毁，这个对象的生命周期则会延长到这个升级的 shared_ptr 被销毁为止。

weak_ptr 的特点可以总结为下面几点：

  • weak_ptr 中没有提供一般的指针操作，如果要访问资源必须通过 lock 将其升级为 shared_ptr

  • 定义对象的时候使用 shared_ptr ，引用对象的时候使用 weak_ptr

  • weak_ptr 不会改变对象的引用计数，它只是一个观察者的角色

上面的代码使用 weak_ptr 可以修改为：

class B;
class A {
public:
    A () {}
    ~A () {}
    weak_ptr<B> ptrb;
};
class B {
public:
    B () {}
    ~B () {}
    weak_ptr<A> ptra;
};

int main() {
    // ref_count of A is 1
    shared_ptr<A> ptra(new A());
    // ref_count of B is 1
    shared_ptr<B> ptrb(new B());
    // ref_count of B is 1
    ptra->ptrb = ptrb;
    // ref_count of A is 1
    ptrb->ptra = ptra;
    std::cout << ptra.use_count() << ptrb.use_count() << std::endl;
    return 0;
}

智能指针的使用

Deleter

unique_ptr 的声明为：std::unique_ptr<T, Deleter>::unique_ptr
前面已经说过，智能指针在析构的时候除了 delete 堆上空间，还可以关闭文件、释放同步锁等，unique_ptr 可以让我们自定义指针释放资源的方式，方法是传入一个函数对象，我们用 lambda 表达式来简单实现如下：

int main() {
    std::unique_ptr<FILE, std::function<void(FILE*)>> openFile(fopen("config.yml", "w"), [](FILE* fp)->void{ fclose(fp); });
    return 0;
}

shared_ptr 的 Deleter 的使用方法与 unique_ptr 稍有不同：

struct foo {
    foo() {}
    ~foo() {}
};

struct deleter {
    void operator()(func* fp) const {
        delete fp;
    }
};

int main() {
    std::shared_ptr<foo> sp(new foo, deleter());
    return 0;
}

多线程场景下的智能指针

多个线程访问同一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他操作，调用这个对象的行为都可以获得正确的结果，那么这个对象就是线程安全的。

shared_ptr/weak_ptr 的线程安全可以分为两个部分讨论：

  • shared_ptr/weak_ptr 管理的对象是否是线程安全的

  • shared_ptr/weak_ptr 对象本身是否是线程安全的

第一个问题，shared_ptr/weak_ptr 能够实现多线程下其管理的对象是线程安全的，多线程下，一个常见的错误是当一个线程已经将堆上的对象析构了，此时另一个线程去访问已经析构了的对象，产生未定义行为。

muduo 网络库中的 Observable 类给出了一个解决方法：通过 weak_ptr 探查对象的生死：

class Observable {
public:
    void register_(const weak_ptr<Observer> x);
    void notifyObservers();
private:
    mutable MutexLock mutex_;
    std::vector<weak_ptr<Observer>> observers_;
    typedef std::vector<weak_ptr<Observer>>::iterator Iterator;
};

void Observable::notifyObservers() {
    MutexLockGuard lock(mutex_);
    Iterator it = observers_.begin();
    while (it != observers_.end()) {
        // 遍历 vector 依次尝试 promote weak_ptr
        // lock 是线程安全的
        shared_ptr<Observer> obj(it->lock());
        if (obj) {
            obj->update();
            ++it;
        }
        else {
            // promote 失败说明对象已经销毁，从 vector 中删除 weak_ptr
            it = observers_.erase(it);
        }
    }
}

第二个问题，shared_ptr 本身并不是线程安全的，它的引用计数是安全无锁的，但是对象的读写不是，因为 shared_ptr 有两个数据成员，读写操作不能原子化。

如果要通过多个线程读写同一个 shared_ptr 对象，需要加锁。
继续看一个 muduo 网络库中的例子：

void read() {
    shared_ptr<foo> localPtr;
    {
        MutexLockGuard lock(mutex);
        localPtr = globalPtr;
    }
    doit(localPtr);
}
void write() {
    shared_ptr<foo> newPtr(new foo);
    {
        MutexLockGuard lock(mutex);
        globalPtr = newPtr;
    }
    doit(newPtr);
}

参考文献：

Linux 多线程服务端编程
Effective Modern C++
cppreference

Archie Scott
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++智能指针的原理和实现.pdf
02-27
智能指针是C++中用于自动管理动态内存的对象，它遵循RAII（Resource Acquisition Is Initialization）原则，确保在适当的时间自动释放所持有的内存资源。在C++11及其后续版本中，标准库提供了四种类型的智能指针：`...
C++：什么是RAII？ | 智能指针的初步讲解 | 智能指针是为了避免什么问题？| 被遗弃的auto_ptr
Sauron7i的博客
04-02 1393
文章目录一、什么是RAIIRAlI的原理二、智能指针的引入1.为什么要使用智能指针三、被弃用的auto_ptr模拟实现auto_ptr(*)和(->)重载 一、什么是RAII RAll (Resource Acquisition ls Initialization）是由c++之父Bjarne Stroustrup提出的，中文翻译为资源获取即初始化，使用局部对象来管理资源的技术称为资源获取即初始化；这里的资源主要是指操作系统中有限的东西如内存(heap)、网络套接字，互斥量，文件句柄等等，局部对象是指存
C++中RAII技术的实现原理是什么？
AdolphMacDonald的博客
04-22 380
例如，unique_ptr是一种独占式智能指针，它保证同一时间内只有一个unique_ptr指向某个对象，当unique_ptr被销毁时，其所指向的对象也会被销毁。RAII的核心思想是将资源的生命周期与对象的生命周期绑定起来，当对象被创建时获取资源，当对象被销毁时释放资源。在C++编程中，我们应该充分利用RAII技术的优势，通过创建合适的RAII对象来管理各种资源，以提高代码的安全性、简洁性和可维护性。这样，当使用这个类的对象时，文件句柄会在对象创建时自动获取，并在对象销毁时自动释放。
C++中RAII机制的介绍与简单实例
Zuoerfeng
12-12 1671
今天看陈硕的多线程书上提到了C++中RAII技术的使用，通过用C11里面自带的智能指针来完成对资源的控制，但是一直不太清楚具体RAII是怎么样的，带着这样的疑问，特地去看了几篇博客，找了一个简单的文件句柄打开关闭RAII管理的实例，瞬间就明白了，这里分享出来。主要从两个部分，首先是RAII技术的介绍，然后是RAII技术的简单实例。 RAII技术的介绍 1、RAII定义 RAII，它是“Resour...
smartPtr指针的实现
weixin_33788244的博客
03-29 124
编写一个智能指针类。智能指针是一种数据类型，一般用模板实现，模拟指针行为的同时还提供自动来及回收机制。它会自动记录SmartPointer&lt;T*&gt;对象的引用计数，一旦T类型对象的引用计数为零，就会释放该对象。 解法： 智能指针跟普通指针一样，但它借由自动化内存管理保证了安全性，避免了诸如悬挂指针、内存泄漏和分配失败等问题。 智能指针必须为给定对象的所有引用维护单一引用计数。 实...
raii.js:基于ES6 Promise的RAII堆栈工具
04-30
RAII.js介绍RAII.js是基于ES6 Promise的RAII（资源获取即初始化）实现。 RAII.js确保您的资源按顺序进行了初始化和销毁​​，并且可以随时取消（销毁）整个堆栈。安装只需通过npm在项目中安装raii.js即可： npm ...
RAII.scala:资源获取正在初始化
05-07
要使用Do ，请将以下设置添加到您的build.sbt中， libraryDependencies + = " com.thoughtworks.raii " %% " asynchronous " % " latest.release " 并检查的用法。 ResourceT Do由一些monad变压器组成。 Do的...
关于c++ 智能指针及 循环引用的问题
08-31
在C++11及更高版本中，智能指针被正式引入，成为现代C++编程的重要组成部分，遵循RAII（Resource Acquisition Is Initialization，资源获取即初始化）原则，确保在对象生命周期结束后正确地释放资源。 智能指针主要...
2. RAII与智能指针1
08-03
智能指针的实现原理通常包括引用计数（对于`std::shared_ptr`）、拷贝构造和拷贝赋值操作，以及支持移动语义。它们确保在对象生命周期结束时，无论正常执行还是发生异常，都能调用析构函数来释放资源。这种机制被...
C++　ＲＡＩＩ
一直在路上
11-20 1511
在写C++设计模式——单例模式的时候，在写到实例销毁时，设计的GC类是很巧妙的，而这一巧妙的设计就是根据当对象的生命周期结束时会自动调用其析构函数的，而这一巧妙的设计也是有专业的名词的——RAII。那以下将围绕RAII，全面的讲解RAII的相关知识。 什么是RAII？ RAII是Resource Acquisition Is Initialization的简称，是C++语言的一种管理资
C++——RAII机制
Map的博客
04-13 347
1. 什么事RAII？ RAII是Resource Acquisition Is Initialization（wiki上面翻译成 “资源获取就是初始化”）的简称，是C++语言的一种管理资源、避免泄漏的惯用法。它保证在任何情况下，使用对象时先构造对象，最后析构对象。 利用C++构造的对象最终会被销毁的原则。RAII的做法是使用一个对象，在其构造时获取对应的资源，在对象生命期内控制对资源的访问，...
c++智能指针（SmartPtr）简单剖析
Sakuramyb马永博的博客
08-22 2446
一、什么是智能指针？智能指针(smart pointer)：是存储指向动态分配（堆）对象指针的类，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数(reference count)。由于c++语言没有自动回收机制，写代码时总要new一个空间，用完之后必须要delete掉，有时候程序代码过于复杂，经常会忘记delete内存，从而导致程序异退出，因此
C++ 智能指针(unique_ptr / shared_ptr)代码实现
天行健，地势坤
04-23 589
文章目录unique_ptr 智能指针的实现shared_ptr 智能指针的实现指针类型转换 unique_ptr 智能指针的实现 一个对象只能被单个unique_ptr 所拥有。 #include <iostream> using namespace std; /*增加模板类型，保证智能指针的类型是由传入的类型决定的*/ template <typename T> ...
谈谈C++中的swap函数
热门推荐
dizuo的专栏
05-21 14万+
1，最通用的模板交换函数模式：创建临时对象，调用对象的赋值操作符。 template void swap ( T& a, T& b ) { T c(a); a=b; b=c; }  需要构建临时对象，一个拷贝构造，两次赋值操作。 2，针对int型优化： void swap(int & __restrict a, int & __restrict b) { a ^= b; b ^= a
SmartPtr(智能指针)
ypt
08-05 1641
为什么会有智能指针？ 在我们现实生活中有这样一个使用场景，每次我们new或者malloc了一块空间，完了必须需要我们手动delete或者free释放这块空间，否则会出现内存泄漏。但是，实际应用中程序未必都会按照顺序执行到释放空间那一步，有时候会在中间部分抛出异常使执行流发生跳转或者发生其他状况，总之代码未按照我们期望的那样去执行，就有可能导致内存泄漏。这时候我们就引入智能指针（自动化管理指针所指...
智能指针的实现（构造，析构，赋值，移动，析构）与测试
RaKiRaKiRa的博客
07-07 1386
智能指针代码： // 引用计数器类 用于存储指向同一对象的指针数 template<typename T> class Counter { private: // 数据成员 T* ptr; // 对象指针 int cnt; // 引用计数器 // 友元类声明 template<typename T> friend class SmartPt...
C++ - 函数重载
jiaowenjie的专栏
08-06 29
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
C++初学者指南-5.标准库(第二部分)--数值运算算法
最新发布
silencestarsky的博客
08-06 545
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
GDI+入门到精通：智能指针库解决内存管理问题
GDI+从入门到精通（vc大讲堂）是一系列针对GDI开发基础的教程，主要讲解如何使用boost库中的智能指针来解决C++内存管理中的常见问题。该课程由步磊峰，UIPower3D界面引擎负责人主讲，分为四部分。 第一部分介绍了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值