c++内存管理系统之智能指针

1.c++内存管理

1.代码区

也称Text Segment，存放可执行程序的机器码。

2 数据区：

存放已初始化的全局和静态变量， 常量数据（如字符串常量）。

存放未初始化的全局和静态变量

无疑解释静态变量的来源：

局部静态变量： 

存储在静态存储区，函数调用结束后不会销毁，下次调用函数时会保留上一次的值。

3.栈：

从高地址向低地址增长。由编译器自动管理分配。程序中的局部变量、函数参数值、返回变量等存在此区域。

4.堆

从低地址向高地址增长。容量大于栈，程序中动态分配的内存在此区域

2.new和delete问世 2.1对比 malloc new的优势

自动调用构造函数和析构函数：new 在分配内存后会自动调用对象的构造函数进行初始化，delete 在释放内存前会自动调用对象的析构函数进行清理工作，这对于管理复杂对象（如包含动态分配资源的对象）非常方便，能确保资源的正确初始化和释放。

这个无疑是new 能复制对象

类型安全：new 会根据对象的类型自动计算所需的内存大小，返回的指针类型也是正确的，不需要进行强制类型转换，减少了因类型转换错误导致的潜在问题。

malloc返回的是 void* 它得强转

操作符重载：在 C++ 中，new 和 delete 是操作符，可以被重载，允许用户自定义内存分配和释放的行为，以满足特定的需求。

操作方便

2.2代码实现 #include <iostream> using namespace std; class A { public: A() { std::cout << "A 的构造函数被调用" << std::endl; } ~A() { std::cout << "A 的析构函数被调用" << std::endl; } }; int main() { // 单个变量 int *p= new int; *p=32; std::cout << *p << std::endl; delete p; //数组 int a[4]={1,23,3,31};//不能赋值 int *ptr=new int[4]{1,2,3};// cout<<ptr[1]<<endl; delete [] ptr; //类 A*ptr_class=new A; delete ptr_class; //类数组 A* ptr_classArray=new A[3]; delete [] ptr_classArray; }

基本格式为 变量类型* ptr = new 变量类型 (数组加[size])

可以重载：

#include <iostream> #include <cstdlib> class MyClass { public: // 重载全局 new 操作符 static void* operator new(size_t size) { std::cout << "自定义 new 操作符被调用，分配 " << size << " 字节" << std::endl; return std::malloc(size); } // 重载全局 delete 操作符 static void operator delete(void* ptr) { std::cout << "自定义 delete 操作符被调用" << std::endl; std::free(ptr); } MyClass() { std::cout << "MyClass 构造函数被调用" << std::endl; } ~MyClass() { std::cout << "MyClass 析构函数被调用" << std::endl; } }; int main() { MyClass* obj = new MyClass; delete obj; return 0; } 3.智能指针问世

原因 因为你new 和 delete 是搭配使用的,等你返回，忘记删去怎么办！！！

#include <iostream> int main() { int *ptr=new int[4]{1,2,3,4}; for(int i =0;i<4;i++) { if(i=2) { return ptr[i]; } } delete []ptr; return 1; } 3.1 unique_ptr

特性

独占所有权：std::unique_ptr 对其所指向的资源拥有独占所有权，同一时间只能有一个 std::unique_ptr 指向该资源。这保证了资源管理的清晰性，避免多个指针同时操作同一资源导致的混乱。

自动释放：当 std::unique_ptr 对象超出其作用域时，其析构函数会自动调用，从而释放其所指向的资源。

代码理解：

#include <iostream> #include <memory> using namespace std; class MyClass { public: MyClass() { std::cout << "MyClass 构造函数" << std::endl; } ~MyClass() { std::cout << "MyClass 析构函数" << std::endl; } }; int main() { { // init 第一个利用make_unique<> () std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>(); // 当 ptr 离开此作用域时，会自动释放资源 } { unique_ptr<MyClass>ptr=make_unique<MyClass>(); //不能赋值unique_ptr<MyClass>ptr1=ptr unique_ptr<MyClass>ptr1=std::move(ptr);//能右赋值 } std::cout << "ptr 已释放资源" << std::endl; return 0; } 3.2 shared_ptr

特性

共享所有权：std::shared_ptr 可以被多个 std::shared_ptr 对象共享同一个资源。它使用引用计数机制来跟踪有多少个 std::shared_ptr 指向同一资源。

自动释放：当引用计数变为 0 时，即没有任何 std::shared_ptr 指向该资源时，资源会被自动释放(还有离开作用域自身减一  一般一对大括号）

#include <iostream> #include <memory> using namespace std; class MyClass { public: MyClass() { std::cout << "MyClass 构造函数" << std::endl; } ~MyClass() { std::cout << "MyClass 析构函数" << std::endl; } }; int main() { /* { shared_ptr<MyClass>ptr1=make_shared<MyClass>(); } //error: ‘ptr1’ was not declared in this scope */ shared_ptr<MyClass>ptr1=make_shared<MyClass>(); cout<<ptr1.use_count()<<endl; shared_ptr<MyClass>ptr2=ptr1;//这个拷贝 cout<<ptr2.use_count()<<endl; shared_ptr<MyClass>ptr3(new MyClass);//这个全新的 cout<<ptr3.use_count()<<endl; } /* MyClass 构造函数 1 2 MyClass 构造函数 1 MyClass 析构函数 MyClass 析构函数 */ 结果 3.3 weak_ptr

特性

弱引用：std::weak_ptr 是一种不控制资源生命周期的智能指针，它对 std::shared_ptr 管理的资源进行弱引用，不增加引用计数。

防止循环引用：主要用于解决 std::shared_ptr 可能出现的循环引用问题，避免资源无法正常释放。

错误用法：

#include <iostream> #include <string> #include <memory> using namespace std; class Boy { public: Boy() { cout << "Boy 构造函数" << endl; } ~Boy() { cout << "~Boy 析构函数" << endl; } void setGirlFriend(shared_ptr<Girl> _girlFriend) { this->girlFriend = _girlFriend; } private: shared_ptr<Girl> girlFriend; }; class Girl { public: Girl() { cout << "Girl 构造函数" << endl; } ~Girl() { cout << "~Girl 析构函数" << endl; } void setBoyFriend(shared_ptr<Boy> _boyFriend) { this->boyFriend = _boyFriend; } private: shared_ptr<Boy> boyFriend; }; void useTrap() { shared_ptr<Boy> spBoy(new Boy()); shared_ptr<Girl> spGirl(new Girl()); // 陷阱用法 spBoy->setGirlFriend(spGirl); spGirl->setBoyFriend(spBoy); // 此时boy和girl的引用计数都是2 } int main(void) { useTrap(); system("pause"); return 0; }

如下图： 当我们执行useTrap函数时，注意，是没有结束此函数，boy和girl指针其实是被两个智能指针托管的，所以他们的引用计数是2

 解析:

对象创建： shared_ptr<Boy> spBoy(new Boy()); 创建了一个 Boy 对象，并使用 spBoy 来管理它，此时 Boy 对象的引用计数为 1。shared_ptr<Girl> spGirl(new Girl()); 创建了一个 Girl 对象，并使用 spGirl 来管理它，此时 Girl 对象的引用计数为 1。 相互引用： spBoy->setGirlFriend(spGirl); 使得 spBoy 内部的 girlFriend 成员（std::shared_ptr<Girl> 类型）指向 spGirl 所管理的 Girl 对象，Girl 对象的引用计数变为 2。spGirl->setBoyFriend(spBoy); 使得 spGirl 内部的 boyFriend 成员（std::shared_ptr<Boy> 类型）指向 spBoy 所管理的 Boy 对象，Boy 对象的引用计数变为 2。 2. 函数作用域结束时的情况

当 useTrap 函数执行结束，spBoy 和 spGirl 离开作用域，它们会被销毁。按照引用计数的规则，这会使得 Boy 和 Girl 对象的引用计数各自减 1。

 

然而，由于循环引用的存在：

  Boy 对象仍然被 spGirl 中的 boyFriend 成员引用，所以 Boy 对象的引用计数从 2 减为 1。Girl 对象仍然被 spBoy 中的 girlFriend 成员引用，所以 Girl 对象的引用计数从 2 减为 1。  

因为引用计数没有变为 0，std::shared_ptr 不会释放 Boy 和 Girl 对象所占用的内存，从而造成了内存泄漏。

 感觉girlfrend和boyfriend反了 才更好理解

真正的：

#include <iostream> #include <memory> using namespace std; class Boy; class Girl { public: Girl() { cout << "Girl 构造函数" << endl; } ~Girl() { cout << "~Girl 析构函数" << endl; } void setBoyFriend(shared_ptr<Boy> _boyFriend) { this->boyFriend = _boyFriend; } private: weak_ptr<Boy> boyFriend; }; class Boy { public: Boy() { cout << "Boy 构造函数" << endl; } ~Boy() { cout << "~Boy 析构函数" << endl; } void setGirlFriend(shared_ptr<Girl> _girlFriend) { this->girlFriend = _girlFriend; } private: weak_ptr<Girl> girlFriend; }; void useTrap() { shared_ptr<Boy> spBoy(new Boy()); shared_ptr<Girl> spGirl(new Girl()); spBoy->setGirlFriend(spGirl); spGirl->setBoyFriend(spBoy); } int main() { useTrap(); return 0; }

 解析：

使用 std::weak_ptr 作为类的成员变量，主要是为了打破 std::shared_ptr 之间可能出现的循环引用问题。当 Boy 对象的 girlFriend 成员使用 std::weak_ptr 时，它对 Girl 对象的引用不会增加 Girl 对象的引用计数，从而避免了循环引用导致的内存泄漏问题。

综上所述，虽然 std::weak_ptr 和 std::shared_ptr 是不同的智能指针类型，但 std::weak_ptr 提供了相应的构造和赋值机制，允许使用 std::shared_ptr 来初始化或赋值，这在解决循环引用问题时非常有用。

其他用法：

#include <iostream> #include <memory> // 打印 weak_ptr 相关信息的函数 void printWeakPtrInfo(const std::weak_ptr<int>& weak) { std::cout << "当前 weak_ptr 的引用计数为: " << weak.use_count() << std::endl; if (weak.expired()) { std::cout << "weak_ptr 所指向的对象已被销毁。" << std::endl; } else { // 使用 lock 函数获取 shared_ptr std::shared_ptr<int> shared = weak.lock(); if (shared) { std::cout << "Value: " << *shared << std::endl; } } } int main() { // 创建一个 shared_ptr 并初始化为 42 std::shared_ptr<int> shared = std::make_shared<int>(42); // 创建一个 weak_ptr 并关联到 shared_ptr std::weak_ptr<int> weak = shared; std::cout << "第一次调用 printWeakPtrInfo 函数：" << std::endl; printWeakPtrInfo(weak); // 释放 shared_ptr 管理的对象 shared.reset(); std::cout << "\n第二次调用 printWeakPtrInfo 函数：" << std::endl; printWeakPtrInfo(weak); return 0; }