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

本文详细介绍了C++中的智能指针概念,包括悬挂指针、野指针,重点讲解了unique_ptr和shared_ptr的用法、内存管理和特性,以及如何解决循环引用问题的weak_ptr。
摘要由CSDN通过智能技术生成

一、智能指针

        C++ 中的智能指针是一种用于管理动态分配的内存的对象,它们可以自动进行内存管理,避免内存泄漏和悬挂指针等问题。

1. 悬挂指针

        悬挂指针(dangling pointer)是指在程序中仍然存在但已经不再指向有效内存地址的指针。悬挂指针通常是由于以下情况引起的:

        1. 释放内存后未将指针置空:

        当使用 deletefree 等方法释放了指针指向的内存后,如果未将指针置空(即将指针设置为 nullptrNULL),则该指针仍然保留之前的内存地址,成为悬挂指针。

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<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();
  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<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 主要用于解决以下两个问题:

  1. 循环引用问题:当两个或多个对象相互持有对方的 std::shared_ptr,就会形成循环引用,导致对象无法被正确释放,从而产生内存泄漏。使用 std::weak_ptr 可以打破循环引用,避免内存泄漏的发生。

  2. 避免悬挂指针:当对象的 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 

  • 18
    点赞
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值