c++面试三 -- 智能指针--7000字

一、智能指针

        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.智能指针

C++现代实用教程:智能指针_哔哩哔哩_bilibili

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 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 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 u_c_p4 =make_unique();
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 
 
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<// 打印值

3.2 unique_ptr和函数调用    (资源的所属权问题）

3.2.1 Passing by value  通过值传递

void do_with_cat_pass_value(std::unique_ptr c){
    c->cat_info();
}
 
int main(){
 
    std::unique_ptr c1 = make_unique("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());  // move
 
}
    

3.2.2 Passing by reference  通过引用传递，可以修改值

void do_with_cat_pass_ref(std::unique_ptr &c){
    c->set_cat_name("oo");
    c->cat_info();
    c.reset();   // 释放先前所拥有的对象，不再指向任何对象
}
 
int main(){
 
    std::unique_ptr c2 = make_unique("ff");
    // 不用使用move，直接c2
    do_with_cat_pass_value(c2);
    
}

void do_with_cat_pass_ref(const std::unique_ptr &c){
    c->set_cat_name("oo");
    c->cat_info();
   // c.reset();   // 释放先前所拥有的对象，不再指向任何对象   不能使用了
}
 
int main(){
 
    std::unique_ptr c2 = make_unique("ff");
    // 不用使用move，直接c2
    do_with_cat_pass_value(c2);
    c2 ->cat->info();
    
}

3.3.3  Return by Value

std::unique_ptr get_unique_ptr(){
    std::unique_ptr p_dog = std:: make_unique("Local cat");
    cout <get()<
    cout <<&p_dog <
    return p_dog;
}
// 链式
 
get_unique_ptr->cat_info();

1. p_dog.get(): 这个表达式返回指向 std::unique_ptr 管理的对象的原始指针。get() 函数是 std::unique_ptr 类的成员函数，它返回一个指向被管理对象的原始指针。使用 get() 可以获取 std::unique_ptr 所拥有的对象的原始指针，但是请注意，这个原始指针不包含所有权信息，因此需要谨慎使用，特别是不要手动释放内存。

2. &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 i_p_2 =make_shared{new int(10)};
 
 
    // copy
    std::shared_ptr<int> i_p_2 =i_p_1;
    cout<< "use cout :" << *i_p_1.use_cout() <// 1
    cout<< "use cout :" << *i_p_2.use_cout() <// 1
 
 
    // change   两个指针指向同一个内存
    *i_p_2 =30;
 
    cout<< ":" << *i_p_1 <// 30
    cout<< ":" << *i_p_2 <// 30
 
 
    // 将i_p_2置为nullptr
    i_p_2=nullptr
    cout<< "use cout :" << *i_p_1.use_cout() <// 1
    cout<< "use cout :" << *i_p_2.use_cout() <// 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() <// 0
    cout<< "use cout :" << *i_p_2.use_cout() <// 2
     cout<< "use cout :" << *i_p_3.use_cout() <// 2
 
    cout<< "value:" << *i_p_1 <
    cout<< "use cout :" << *i_p_1.use_cout() <
    return 0;
}

3.3.2 自定义类型

// 自定义类型
std::shared_ptr c_p_1 =make_shared();
 
cout<< "c_p_1 use cout :" << c_p_1.use_count() << endl;
 
 
std::shared_ptr c_p_2 =c_p_1;
std::shared_ptr 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 ptr;//ptr 的意义就相当于一个 NULL 指针
2.shared_ptr ptr(new T());//从new操作符的返回值构造
3.shared_ptr ptr2(ptr1);    // 使用拷贝构造函数的方法，会让引用计数加 1
                               //shared_ptr 可以当作函数的参数传递，或者当作函数的返回值返回，这个时候其实也相当于使用拷贝构造函数。
4./*假设B是A的子类*/
shared_ptr ptrb(new B());
shared_ptr ptra( dynamic_pointer_cast(ptrb) );//从 shared_ptr 提供的类型转换 (cast) 函数的返回值构造
5./* shared_ptr 的“赋值”*/
shared_ptr a(new T());
shared_ptr 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 ptr(new T());
ptr.reset(new T()); // 原来所指的对象会被销毁

std::shared_ptr<int> foo = std::make_shared<int> (10);

void cat_by_value( std::shared_ptr cat){
 cout << "cat use coout "<< cat.use_cout() << endl; // 2 
}
 
 
void cat_by_ref( std::shared_ptr &cat){
    // cat.reset(new Cat());  // 先创建新对象，将原先cat对象内容覆盖，然后reset
 cout << "cat use coout "<< cat.use_cout() << endl; // 2 
}
 
std::shared_ptr get_shared_ptr(){
    std::shared_ptr cat_p= std::make_shared("dd);
}
int main(){
    std::shared_ptr c1 =make_shared("dd");
    cat_by_value(c1);
    cout << "c1 use coout "<< c1.use_cout() << endl; // 1
    
    cat_by_ref(c1);
     std::shared_ptr c_p =get_shared_ptr();
      get_shared_ptr->cat_info();  
}