本文详细介绍了C++中的智能指针概念，包括悬挂指针、野指针，重点讲解了unique_ptr和shared_ptr的用法、内存管理和特性，以及如何解决循环引用问题的weak_ptr。
一、智能指针
C++ 中的智能指针是一种用于管理动态分配的内存的对象，它们可以自动进行内存管理，避免内存泄漏和悬挂指针等问题。
1. 悬挂指针
悬挂指针（dangling pointer）是指在程序中仍然存在但已经不再指向有效内存地址的指针。悬挂指针通常是由于以下情况引起的：
1. 释放内存后未将指针置空：
当使用 delete 或 free 等方法释放了指针指向的内存后，如果未将指针置空（即将指针设置为 nullptr 或 NULL），则该指针仍然保留之前的内存地址，成为悬挂指针。
int* ptr = new int(42);
delete ptr;
// ptr现在成为悬挂指针，它指向的内存已经被释放
2. 超出作用域的引用：
当指针指向的对象超出了其作用域（例如指向了一个局部变量），并且该对象的内存被释放，那么指针就会成为悬挂指针。
int* danglingPtr;
{
int value = 42;
danglingPtr = &value;
} // value的作用域结束，danglingPtr成为悬挂指针
3. 指向已经被销毁的对象：
如果指针指向的对象在其生命周期内被销毁了，那么指针就成为悬挂指针。
int* danglingPtr;
{
std::unique_ptr<int> ptr = std::make_unique<int>(42);
danglingPtr = ptr.get();
} // ptr超出作用域，其指向的对象被销毁，danglingPtr成为悬挂指针
2.野指针
野指针是指指针指向的内存地址是随机的、未初始化的，或者指向的内存区域未经过分配。野指针可能是在创建指针后没有给它赋值（即未初始化指针），或者是在释放内存后未将指针置空，但继续使用该指针。
野指针指向的内存地址通常是随机的，因此访问野指针可能会导致程序崩溃、数据损坏或安全漏洞。
悬挂指针是指针仍然保留着之前指向的地址，但该地址已经不再有效；而野指针是指针指向的地址是随机的或未经过初始化。在编程中，应该尽量避免出现悬挂指针和野指针。
3.智能指针
3.1 unique_ptr指针
3.1.1 特点：
3.1.2 创建
栈上：出作用域之后会自动调用析构函数
//stack
Cat c1("OK");
c1.cat_info();
{
Cat c1("OK");
c1.cat_info();
}堆上：需要手动delete释放（不安全)
Cat *c_p1 = new Cat("yy");
int *i_p1 = new int(100);
c_p1->cat_info();
{
int *i_p1 = new int(200); // 重新声明，但是是在局部作用域中，与外部不同，结果为100。需要delete两次
Cat *c_p1 new Cat("yy_scope");
c_p1->cat_info();
delete c_p1;
delete i_pi;
}
delete c_p1;
delete i_pi;Cat *c_p1 = new Cat("yy");
int *i_p1 = new int(100);
c_p1->cat_info();
{
i_p1 = new int(200); // 不重新声明，只是修改了值，结果为200 ，只用delete一次
Cat *c_p1 = new Cat("yy_scope");
c_p1->cat_info();
delete c_p1;
delete i_pi;
}
delete c_p1;
unique_ptr创建的三种方式：
1. 通过原始指针创建
Cat *c_p2 =new Cat("yz");
std::unique_ptr<Cat> u_c_p2(c_p2};
// 此时原始指针还能用，需要进行销毁，否则不满足独占指针要求,否则如下
//c_p2->cat_info();
//u_c_p2->cat_info();
//c_p2->set_cat_name("ok");
//u_c_p2->cat_info();
// 销毁
c_p2 = nullptr;
c_p2 =nullptr;
u_c_p2->cat_info();
2. 使用new创建
std::unique_ptr<Cat> u_c_p3{new Cat("dd")};
u_c_p3->cat_info();
u_c_p3->set_cat_name("oo");
u_c_p3->cat_info();
3.使用std::make_unique
std::unique_ptr<Cat> u_c_p4 =make_unique<Cat>();
u_c_p4->cat_info();
u_c_p4->set_cat_name("po");
u_c_p4->cat_info();
4. 移动语义创建
可以通过使用移动语义将一个已有的 std::unique_ptr 赋值给另一个 std::unique_ptr。
#include <memory>
std::unique_ptr<int> u_c_p5 = std::move(u_c_p4 );
3.1.3 get()和常量类型
std::unique_ptr<int> u_i_p4 =make_unique<int>(200);
cout << "int address" << u_i_p4 .get() << endl; //get 获取原始指针或者地址
cout<< * u_i_p4<<endl; // 打印值3.2 unique_ptr和函数调用 (资源的所属权问题）
3.2.1 Passing by value 通过值传递
void do_with_cat_pass_value(std::unique_ptr<Cat> c){
c->cat_info();
}
int main(){
std::unique_ptr<Cat> c1 = make_unique<Cat>("ff");
// 1. 使用 std::move 转移资源的所有权给函数，此时c1不再拥有资源的所有权了
do_with_cat_pass_value(std::move(c1));
// 2. 直接将参数传入make_unique ,将自动转换成move
do_with_cat_pass_value(std::make_unique<Cat>()); // move
}
3.2.2 Passing by reference 通过引用传递，可以修改值
void do_with_cat_pass_ref(std::unique_ptr<Cat> &c){
c->set_cat_name("oo");
c->cat_info();
c.reset(); // 释放先前所拥有的对象，不再指向任何对象
}
int main(){
std::unique_ptr<Cat> c2 = make_unique<Cat>("ff");
// 不用使用move，直接c2
do_with_cat_pass_value(c2);
}void do_with_cat_pass_ref(const std::unique_ptr<Cat> &c){
c->set_cat_name("oo");
c->cat_info();
// c.reset(); // 释放先前所拥有的对象，不再指向任何对象 不能使用了
}
int main(){
std::unique_ptr<Cat> c2 = make_unique<Cat>("ff");
// 不用使用move，直接c2
do_with_cat_pass_value(c2);
c2 ->cat->info();
}3.3.3 Return by Value
std::unique_ptr<Cat> get_unique_ptr(){
std::unique_ptr<Cat> p_dog = std:: make_unique<Cat>("Local cat");
cout <<p_dog.get()<<endl;
cout <<&p_dog <<endl;
return p_dog;
}
// 链式
get_unique_ptr->cat_info();-
p_dog.get(): 这个表达式返回指向std::unique_ptr管理的对象的原始指针。get()函数是std::unique_ptr类的成员函数，它返回一个指向被管理对象的原始指针。使用get()可以获取std::unique_ptr所拥有的对象的原始指针，但是请注意，这个原始指针不包含所有权信息，因此需要谨慎使用，特别是不要手动释放内存。 -
&p_dog: 这个表达式返回的是指向std::unique_ptr对象本身的指针，即指向std::unique_ptr对象的地址。&是取地址运算符，它返回变量的地址。std::unique_ptr是一个对象，因此&p_dog返回的是指向std::unique_ptr对象的指针
3.3 shared_ptr 计数指针/共享指针
在实际的 C++ 开发中，我们经常会遇到诸如程序运行中突然崩溃、程序运行所用内存越来越多最终不得不重启等问题，这些问题往往都是内存资源管理不当造成的。比如：
有些内存资源已经被释放，但指向它的指针并没有改变指向（成为了野指针），并且后续还在使用；
有些内存资源已经被释放，后期又试图再释放一次（重复释放同一块内存会导致程序运行崩溃）；
没有及时释放不再使用的内存资源，造成内存泄漏，程序占用的内存资源越来越多。
智能指针shared_ptr 是存储动态创建对象的指针，其主要功能是管理动态创建对象的销毁，从而帮助彻底消除内存泄漏和悬空指针的问题。
shared_ptr的原理和特点
基本原理:就是记录对象被引用的次数，当引用次数为 0 的时候，也就是最后一个指向该对象的共享指针析构的时候，共享指针的析构函数就把指向的内存区域释放掉。
特点:它所指向的资源具有共享性，即多个shared_ptr可以指向同一份资源，并在内部使用引用计数机制来实现这一点。
共享指针内存：每个 shared_ptr 对象在内部指向两个内存位置：
指向对象的指针；
用于控制引用计数数据的指针。
1.当新的 shared_ptr 对象与指针关联时，则在其构造函数中，将与此指针关联的引用计数增加1。2.当任何 shared_ptr 对象超出作用域时，则在其析构函数中，它将关联指针的引用计数减1。如果引用计数变为0，则表示没有其他 shared_ptr 对象与此内存关联，在这种情况下，它使用delete函数删除该内存。
shared_ptr像普通指针一样使用，可以将*和->与 shared_ptr 对象一起使用，也可以像其他 shared_ptr 对象一样进行比较;
3.3.1 常量类型
int main(){
std::shared_ptr<int> i_p_1 =make_shared<int>(10);
// std::shared_ptr<int> i_p_2 =make_shared<int>{new int(10)};
// copy
std::shared_ptr<int> i_p_2 =i_p_1;
cout<< "use cout :" << *i_p_1.use_cout() <<endl; // 1
cout<< "use cout :" << *i_p_2.use_cout() <<endl; // 1
// change 两个指针指向同一个内存
*i_p_2 =30;
cout<< ":" << *i_p_1 <<endl; // 30
cout<< ":" << *i_p_2 <<endl; // 30
// 将i_p_2置为nullptr
i_p_2=nullptr
cout<< "use cout :" << *i_p_1.use_cout() <<endl; // 1
cout<< "use cout :" << *i_p_2.use_cout() <<endl; // 0
// 将i_p_1置为nullptr
std::shared_ptr<int> i_p_3 =i_p_1;
i_p_1=nullptr
cout<< "use cout :" << *i_p_1.use_cout() <<endl; // 0
cout<< "use cout :" << *i_p_2.use_cout() <<endl; // 2
cout<< "use cout :" << *i_p_3.use_cout() <<endl; // 2
cout<< "value:" << *i_p_1 <<endl;
cout<< "use cout :" << *i_p_1.use_cout() <<endl;
return 0;
}3.3.2 自定义类型
// 自定义类型
std::shared_ptr<Cat> c_p_1 =make_shared<Cat>();
cout<< "c_p_1 use cout :" << c_p_1.use_count() << endl;
std::shared_ptr<Cat> c_p_2 =c_p_1;
std::shared_ptr<Cat> c_p_3 =c_p_1;
cout<< "c_p_1 use cout :" << c_p_1.use_count() << endl;
cout<< "c_p_2 use cout :" << c_p_2 .use_count() << endl;
cout<< "c_p_3 use cout :" << c_p_3 .use_count() << endl;3.3.3 make_shared的构建方法
（1）.构造函数创建
1.shared_ptr<T> ptr;//ptr 的意义就相当于一个 NULL 指针
2.shared_ptr<T> ptr(new T());//从new操作符的返回值构造
3.shared_ptr<T> ptr2(ptr1); // 使用拷贝构造函数的方法，会让引用计数加 1
//shared_ptr 可以当作函数的参数传递，或者当作函数的返回值返回，这个时候其实也相当于使用拷贝构造函数。
4./*假设B是A的子类*/
shared_ptr<B> ptrb(new B());
shared_ptr<A> ptra( dynamic_pointer_cast<A>(ptrb) );//从 shared_ptr 提供的类型转换 (cast) 函数的返回值构造
5./* shared_ptr 的“赋值”*/
shared_ptr<T> a(new T());
shared_ptr<T> b(new T());
a = b; // 此后 a 原先所指的对象会被销毁，b 所指的对象引用计数加 1
//shared_ptr 也可以直接赋值，但是必须是赋给相同类型的 shared_ptr 对象，而不能是普通的 C 指针或 new 运算符的返回值。
//当共享指针 a 被赋值成 b 的时候，如果 a 原来是 NULL, 那么直接让 a 等于 b 并且让它们指向的东西的引用计数加 1;
// 如果 a 原来也指向某些东西的时候，如果 a 被赋值成 b, 那么原来 a 指向的东西的引用计数被减 1, 而新指向的对象的引用计数加 1。
6./*已定义的共享指针指向新的new对象————reset()*/
shared_ptr<T> ptr(new T());
ptr.reset(new T()); // 原来所指的对象会被销毁（2）make_shared辅助函数创建
std::shared_ptr<int> foo = std::make_shared<int> (10);3.3.4 shared_ptr 与函数
void cat_by_value( std::shared_ptr<Cat> cat){
cout << "cat use coout "<< cat.use_cout() << endl; // 2
}
void cat_by_ref( std::shared_ptr<Cat> &cat){
// cat.reset(new Cat()); // 先创建新对象，将原先cat对象内容覆盖，然后reset
cout << "cat use coout "<< cat.use_cout() << endl; // 2
}
std::shared_ptr<Cat> get_shared_ptr(){
std::shared_ptr<Cat> cat_p= std::make_shared<Cat>("dd);
}
int main(){
std::shared_ptr<Cat> c1 =make_shared<Cat>("dd");
cat_by_value(c1);
cout << "c1 use coout "<< c1.use_cout() << endl; // 1
cat_by_ref(c1);
std::shared_ptr<Cat> c_p =get_shared_ptr();
get_shared_ptr->cat_info();
}3.4 shared_ptr 和 unique_ptr转换
3.5 weak_ptr 弱引用指针
std::weak_ptr 是 C++11 引入的一个智能指针类，用于解决 std::shared_ptr 的循环引用问题。它是一个弱引用指针，不会增加指向对象的引用计数，也不会拥有对象的所有权，因此不会影响对象的生命周期。
std::weak_ptr 主要用于解决以下两个问题：
-
循环引用问题：当两个或多个对象相互持有对方的
std::shared_ptr，就会形成循环引用，导致对象无法被正确释放，从而产生内存泄漏。使用std::weak_ptr可以打破循环引用，避免内存泄漏的发生。 -
避免悬挂指针：当对象的
std::shared_ptr被释放后，指向该对象的std::weak_ptr仍然可以继续存在，但是无法访问对象。因此，使用std::weak_ptr可以避免悬挂指针的出现，从而提高程序的稳定性。
使用 std::weak_ptr 需要配合 std::shared_ptr 使用，通过 std::shared_ptr 对象的 weak_ptr 方法来创建 std::weak_ptr 对象。std::weak_ptr 可以通过 lock 方法获取一个有效的 std::shared_ptr 对象，用于访问所指向的对象，但是需要注意，获取的 std::shared_ptr 可能为空，需要进行有效性检查。
// 产生循环依赖问题
// 使用weak_ptr
1746
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
