智能指针C++详解 C++11

最新推荐文章于 2024-07-21 22:06:29 发布

YarBor

最新推荐文章于 2024-07-21 22:06:29 发布

阅读量129

点赞数

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/weixin_73062623/article/details/132561954

版权

智能指针

为什么不用裸指针

裸指针在声明中并没有指出，裸指针指涉到的是单个对象还是一个数组。
裸指针在声明中也没有提示在使用完指涉的对象以后，是否需要析构它。换言之，你从声明中看不出来指针是否拥有(own)其指涉的对象。
即使知道需要析构指针所指涉的对象，也不可能知道如何析构才是适当的。是应该使用delete运算符呢，还是别有它途（例如，可能需要把指针传入一个专门的、用千析构的函数）
即使知道了应该使用delete运算符，参见理由1’还是会发生到底应该用单个对象形式(“delete”)还是数组形式(delete[])的疑问。一旦用错，就会导致未定义行为。
没有什么正规的方式能检测出指针是否空悬(dangle)，也就是说，它指涉的内存是否已经不再持有指针本应该指涉的对象。如果一个对象已经被析构了，而某些指针仍然指涉到它，就会产生空悬指针。

c++ 中的智能指针

C++ll 中共有四种智能指针：

std::auto_ptr (弃用)
std::unique_ptr
std::shared_ptr
std::weak_ptr
所有这些智能指针都是为管理动态分配对象的生命期而设计的，
换言之，通过保证这样的对象在适当的时机以适当的方式析构（包括发生异常的场合），
来防止资源泄漏。

专属所有权 unique_ptr

std::unique_ptr实现的是专属所有权语义。一个非空的std::unique_ptr总是拥有其所指涉到的资源。移动一个std::unique_ptr会将所有权从源指针移至目标指针（源指针被置空）。
std::unique_ptr不允许复制，因为如果复制了一个std::unique_ptr,就会得到两个指涉到同一资源的std::unique_ptr,而这两者都认为且已拥有（因此应当析构）该资源。因而，std::unique_ptr是个只移型别。在执行析构操作时，由非空的std::unique_ptr析构其资源。默认地，资源的析构是通过对std::unique_ptr内部的裸指针实施delete完成的。

unique_ptr 是可以自定义析构函数的

      /// Destructor, invokes the deleter if the stored pointer is not null.
      ~unique_ptr() noexcept
      {
	static_assert(__is_invocable<deleter_type&, pointer>::value,
		      "unique_ptr's deleter must be invocable with a pointer");
	auto& __ptr = _M_t._M_ptr();
	if (__ptr != nullptr)
	  get_deleter()(std::move(__ptr)); 
      /* 这里比较奇怪(看起来)  
      实际上是get_deleter()返回构造时传入的可调用对象 
      然后对可调用对象进行调用 
      这里的__ptr的类型是auto将由编译时编译器自行推断  */
	__ptr = pointer();
      }

在这个析构函数中，首先使用static_assert进行断言检查，确保deleter_type类型的对象可以通过指针调用。如果无法调用，则会触发编译错误。
接下来，通过引用_M_t._M_ptr()获取存储的指针，并将其赋值给__ptr变量。然后检查__ptr是否为nullptr，即指针是否为空。
如果__ptr不为空，则调用get_deleter()函数获取deleter对象，并将__ptr作为参数传递给它。这里使用std::move(__ptr)将__ptr转移所有权，以确保在调用完毕后__ptr被置空。
最后，将__ptr赋值为pointer()，即将其置为空指针。

如果由 makelnvestment 创建的对象不应被直接删除，而是应该先写入一条日志，那么 makelnvestment 可以像下面这样实现

这里的传入的是一个可调用对象 lambda OR class() OR func()

在使用默认析构器（即 delete 运算符）的前提下，std::unique_ptr 和裸指针尺寸相同。自定义析构器现身以后，情况便有所不同了。若析构器是函数指针，那么 std::unique_ptr 的尺寸一般会增加一到两个字长 (word) 。而若析构器是函数对象，则带来的尺寸变化取决千该函数对象中存储了多少状态。无状态的函数对象（例如，无捕获的 lambda 表达式）不会浪费任何存储尺寸。

共享所有权 shared_ptr

通过std::shared_ptr这种智能指针访问的对象采用共享所有权来管理其生存期。没有哪个特定的std::shared_ptr拥有该对象。取而代之的是，所有指涉到它的std::shared_ptr共同协作，确保在不再需要该对象的时刻将其析构。当最后一个指涉到某对象的std::shared_ptr不再指涉到它时（例如，由于是该std::shared_ptr被析构，或使其指涉到另一个不同的对象），该std::shared_ptr会析构其指涉到的对象。

std::shared_ptr 的构造函数会使该计数递增（通常如此），而其析构函数会使该计数递减，而复制赋值运算符同时执行两种操作;

引用计数的存在会带来一些性能影响：

内存内存是裸指针的两倍
引用技术需要动态分配
计数的递增和递减必须是原子操作 (慢于非原子操作即使计数只有一个字节)

析构

和 unique_ptr 相似 shared_ptr 同样支持自定义析构器
但支持的方式和unique_ptr并不相同
对于 unique_ptr 而言，析构器的型别是智能指针型别的一部分。

内存

关于 shared_ptr 上述内存何时创建

std::make_shared 总是创建一个控制块.
从具备专属所有权的指针（即std::unique_ptr或std::auto_ptr指针）出发构造一个std::shared_ptr时，会创建—个控制块。

构造后专属所有权的指针的所有权转移其被置空
当 std::shared_ptr 构造函数使用裸指针作为实参来调用时

使用裸指针创建时要注意以免两个sharePtr指向同一内存
进行错误析构进而野指针

注意

在类内不要使用this去构造shared_ptr

使用
class M : public std::enable_shared_from_this<M> 进行继承操作
并使用成员函数 shared_from_this() 获取此对象的 shared_ptr

如上所示
上述仅仅作为演示

2. 关于 weak_ptr

关于 weak_ptr 的使用场景
校验指针是否悬空
弱回调
缓存及其观察者
避免shared_ptr循环引用

非必要则使用std::make_ptr
优先选用 std::make_unique 和 std::make_shared, 而非直接使用 new
```
 void processWidget(std::shared_ptr<Widget> sqw,int priority){
   // .....
 }
 int computerPriority(){
   // ....
   return 1;
 }

 int func(){
   processWidget(std::make_shared< Widget>( new Widget),
   computerPriority()); // 潜在的内存(资源)泄漏
 }
```
原因与编译器从源代码到目标代码的翻译有关。在运行期，传递给函数的实参必须在函数调用被发起之前完成评估求值。下列事件必须在 processWidget 开始执行前发生：
- 表达式 “new Widget" 必须先完成评估求值，即，一个 Widget 对象必须先在堆上创建。
- 由 new 产生的裸指针的托管对象 std::shared_ptr 的构造函数必须执行。
- computePriority 必须运行。
编译器不必按上述顺序来生成代码。
其有可能生成
1. 实施 “ new Widget" 。
2. 执行 computePriority 。
3. 运行 std::shared_ptr 构造函数。
如果生成了这样的代码，并且在运行期 computePriority 产生了异常，那么由第一步动态分配的Widget会被泄漏，因为它将永远不会被存储到在第三步才接管的std::shared_ptr中去。

使用 std::make_shared 可以避免该问题。

产生这种歧义的原因可能是编译优化时进行评估求知? 咱也不知道QAQ

BUT
- 相对于直接使用 new 表达式，优先选用 make 函数但是所有的make函数不能自定析构器需要自定析构器的智能指针还是得 std::shared_ptr<T>(new T, ...)
- 关于列表构造
  std::make_shared<std::vector<int>> (10,20)
  std::make_shared<std::vector<int>> {10,20}
  其构造的是 [10,20] 还是 [20,20,20,20,20…]
  答案是
  1. std::make_shared<std::vector<int>> {10,20} 编译不通过
  2. std::make_shared<std::vector<int>> (10,20) 构造的是[20,20,20,20,20…]
  为了使用列表构造+make函数
  我们可以
```
auto i = {10,20};
std::make_shared<std::vector<int>> (i);
```

std::shared_ptr 的 API 仅被设计用来处理指涉到单个对象的指针但unique_ptr 可以是数组

关于 shared_ptr 是 make 构造还是 new 构造时关于 weak_ptr 的一些差别

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() {
        std::cout << "Resource acquired." << std::endl;
    }
    ~Resource() {
        std::cout << "Resource released." << std::endl;
    }
    int value = 10;
};
int main() {
    std::weak_ptr<Resource> weakPtr;
    Resource * i = nullptr;
    {
        auto sharedPtr = std::make_shared<Resource>();
        weakPtr = sharedPtr;
        i = sharedPtr.get();
        if (auto lockedPtr = weakPtr.lock()) {
            std::cout << "Resource is still available." << std::endl;
        } else {
            std::cout << "Resource has been released." << std::endl;
        }
    }

    std::cout << i->value << std::endl;

    if (auto lockedPtr = weakPtr.lock()) {
        std::cout << "Resource is still available." << std::endl;
    } else {
        std::cout << "Resource has been released." << std::endl;
    }

    std::cout << i->value << std::endl;

    return 0;
}

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() {
        std::cout << "Resource acquired." << std::endl;
    }
    ~Resource() {
        std::cout << "Resource released." << std::endl;
    }
    int value = 10;
};
int main() {
    std::weak_ptr<Resource> weakPtr;

    Resource * i = nullptr;
    {
        std::shared_ptr<Resource> sharedPtr (new Resource);
        weakPtr = sharedPtr;
        i = sharedPtr.get();
        if (auto lockedPtr = weakPtr.lock()) {
            std::cout << "Resource is still available." << std::endl;
        } else {
            std::cout << "Resource has been released." << std::endl;
        }
    }

    std::cout << i->value << std::endl;

    if (auto lockedPtr = weakPtr.lock()) {
        std::cout << "Resource is still available." << std::endl;
    } else {
        std::cout << "Resource has been released." << std::endl;
    }

    std::cout << i->value << std::endl;

    return 0;
}

运行上面的例子可知:
通过 std::make_shared(…)创建shared_ptr真正free内存的时机是 ---- 引用计数和弱引用计数全部为0时
通过 std::shared_ptr(new T(…))创建shared_ptr真正free内存的时机是 ---- 引用计数为0时

YarBor

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
智能指针C++详解 C++11

为什么不用裸指针裸指针在声明中并没有指出，裸指针指涉到的是单个对象还是一个数组。裸指针在声明中也没有提示在使用完指涉的对象以后，是否需要析构它。换言之，你从声明中看不出来指针是否拥有(own)其指涉的对象即使知道需要析构指针所指涉的对象，也不可能知道如何析构才是适当的。是应该使用delete运算符呢，还是别有它途（例如，可能需要把指针传入一个专门的、用千析构的函数）即使知道了应该使用delete运算符，参见理由1'还是会发生到底应该用单个对象形式("`delete`")还是 (`delete[]`)
复制链接

扫一扫