0%

专题知识点1：指针专题

发表于 更新于 分类于 阅读次数：
本文字数： 4.6k 阅读时长 ≈ 4 分钟

2020年4月6日 下午9:14

C/C++ 中指针和引用的区别？

  1. c++中，引用和指针的区别是什么？ - 知乎
    1. 从对象的角度来解释：
      1. 从对象开始讲起：
        1. 对象是指一块能存储数据并具有某种类型的内存空间
        2. 一个对象a，它有值和地址&a
      2. 指针p也是对象
        1. 它同样有地址&p和存储的值p，只不过，p存储的数据类型是数据的地址。
      3. 对象有常量（const）和变量之分
        1. 指针常量是指，指针这个对象所存储的地址是不可以改变的
        2. 而指向常量的指针的意思是，不能通过该指针来改变这个指针所指向的对象。
    2. 从常量指针引出到引用：
      1. 可以把引用看做是通过一个常量指针来实现的，它只能绑定到初始化它的对象上
    3. 如何选择：
      1. 引用的一个优点是它一定不为空，因此相对于指针，它不用检查它所指对象是否为空，这增加了效率
  2. 散乱版本，根本记不住：
    1. 指针有自己的一块空间，是一种类型，而引用只是一个别名；
    2. 初始化：
      1. 指针可以被初始化为NULL，而引用必须被初始化且必须是一个已有对象 的引用；
    3. 赋值：
      1. 指针在使用中可以指向其它对象，但是引用只能是一个对象的引用，不能被改变；
      2. C++中引用不能重新赋值的理解_c/c++_liujianfei526的专栏-CSDN博客
    4. 参数传递：
      1. 作为参数传递时，指针需要被解引用才可以对对象进行操作，而直接对引用的修改都会改变引用所指向的对象；
    5. sizeof :
      1. 使用sizeof看一个指针的大小是4，而引用则是被引用对象的大小；
    6. const:
      1. 可以有const指针
      2. const引用和非const引用
        1. const引用是必须指向const对象的引用
    7. 指针可以有多级指针（p），而引用至于一级；
    8. 指针和引用使用++运算符的意义不一样；
    9. 如果返回动态内存分配的对象或者内存，必须使用指针，引用可能引起内存泄露。

c++中的smart pointer四个智能指针： shared_ptr,unique_ptr,weak_ptr,auto_ptr

  1. C++里面的四个智能指针: auto_ptr, shared_ptr, weak_ptr, unique_ptr 其中后三个是c++11支持，并且第一个已经被11弃用。
  2. 为什么要使用智能指针：
    1. 智能指针的作用是管理一个指针，因为存在以下这种情况：申请的空间在函数结束时忘记释放，造成内存泄漏。使用智能指针可以很大程度上的避免这个问题，因为智能指针就是一个类，当超出了类的作用域是，类会自动调用析构函数，析构函数会自动释放资源。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。
  3. auto_ptr（c++98的方案，cpp11已经抛弃）
    1. 采用所有权模式。
      1
      2
      3
      auto_ptr< string> p1 (new string (“I reigned lonely as a cloud.”));
      auto_ptr<string> p2;
      p2 = p1; //auto_ptr不会报错.
    2. 此时不会报错，p2剥夺了p1的所有权，但是当程序运行时访问p1将会报错。所以auto_ptr的缺点是：存在潜在的内存崩溃问题！
  4. unique_ptr（替换auto_ptr）
    1. unique_ptr实现独占式拥有或严格拥有概念，保证同一时间内只有一个智能指针可以指向该对象。它对于避免资源泄露(例如“以new创建对象后因为发生异常而忘记调用delete”)特别有用。
    2. 采用所有权模式，还是上面那个例子
      1
      2
      3
      unique_ptr<string> p3 (new string (“auto”));   //#4
      unique_ptr<string> p4；                       //#5
      P4 = p3;//此时会报错！！
    3. 编译器认为p4=p3非法，避免了p3不再指向有效数据的问题。因此，unique_ptr比auto_ptr更安全。
    4. 另外unique_ptr还有更聪明的地方：当程序试图将一个 unique_ptr 赋值给另一个时，如果源 unique_ptr 是个临时右值，编译器允许这么做；如果源 unique_ptr 将存在一段时间，编译器将禁止这么做，比如：
      1
      2
      3
      4
      5
      unique_ptr<string> pu1(new string (“hello world”));
      unique_ptr<string> pu2;
      pu2 = pu1;                                      // #1 not allowed
      unique_ptr<string> pu3;
      pu3 = unique_ptr<string>(new string (“You”));   // #2 allowed
    5. 其中# 1留下悬挂的unique_ptr(pu1)，这可能导致危害。而 # 2不会留下悬挂的unique_ptr，因为它调用 unique_ptr 的构造函数，该构造函数创建的临时对象在其所有权让给 pu3 后就会被销毁。这种随情况而已的行为表明，unique_ptr 优于允许两种赋值的auto_ptr 。
    6. 注：如果确实想执行类似与#1的操作，要安全的重用这种指针，可给它赋新值。C++有一个标准库函数std::move()，让你能够将一个unique_ptr赋给另一个。例如：
      1
      2
      3
      4
      5
      unique_ptr<string> ps1, ps2;
      ps1 = demo(“hello”);
      ps2 = move(ps1);
      ps1 = demo(“Alexia”);
      cout << *ps2 << *ps1 << endl;
  5. shared_ptr
    1. shared_ptr实现共享式拥有概念。多个智能指针可以指向相同对象，该对象和其相关资源会在“最后一个引用被销毁”时候释放。从名字share就可以看出了资源可以被多个指针共享，它使用计数机制来表明资源被几个指针共享。可以通过成员函数use_count()来查看资源的所有者个数。除了可以通过new来构造，还可以通过传入auto_ptr, unique_ptr,weak_ptr来构造。当我们调用release()时，当前指针会释放资源所有权，计数减一。当计数等于0时，资源会被释放。
    2. shared_ptr 是为了解决 auto_ptr 在对象所有权上的局限性(auto_ptr 是独占的), 在使用引用计数的机制上提供了可以共享所有权的智能指针。
    3. 成员函数：
      1. use_count 返回引用计数的个数
      2. unique 返回是否是独占所有权( use_count 为 1)
      3. Swap 交换两个 shared_ptr 对象(即交换所拥有的对象)
      4. Reset 放弃内部对象的所有权或拥有对象的变更, 会引起原有对象的引用计数的减少
      5. Get 返回内部对象(指针), 由于已经重载了()方法, 因此和直接使用对象是一样的.如 shared_ptr sp(new int(1)); sp 与 sp.get()是等价的
  6. weak_ptr
    1. weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象. 进行该对象的内存管理的是那个强引用的 shared_ptr.
    2. weak_ptr只是提供了对管理对象的一个访问手段。
    3. weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。
    4. weak_ptr是用来解决shared_ptr相互引用时的死锁问题,如果说两个shared_ptr相互引用,那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。它是对对象的一种弱引用，不会增加对象的引用计数，和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给它，它可以通过调用lock函数来获得shared_ptr。
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      class B;
      class A
      {
      	public:
      	shared_ptr<B> pb_;
      	~A()
      	{
      	cout<<“A delete\n”;
      	}
      };

      class B
      {
      	public:
      	shared_ptr<A> pa_;
      	~B()
      	{
      	cout<<“B delete\n";
      	}
      };

      void fun()
      {
      	shared_ptr<B> pb(new B());
      	shared_ptr<A> pa(new A());
      	pb->pa_ = pa;
      	pa->pb_ = pb;
      	cout<<pb.use_count()<<endl;
      	cout<<pa.use_count()<<endl;
      }

      int main()
      {
      	fun();
      	return 0;
      }
    5. 可以看到fun函数中pa ，pb之间互相引用，两个资源的引用计数为2，当要跳出函数时，智能指针pa，pb析构时两个资源引用计数会减一，但是两者引用计数还是为1，导致跳出函数时资源没有被释放（A B的析构函数没有被调用）
    6. 如果把其中一个改为weak_ptr就可以了，我们把类A里面的shared_ptr pb_; 改为weak_ptr pb_; 运行结果如下，这样的话，资源B的引用开始就只有1，当pb析构时，B的计数变为0，B得到释放，B释放的同时也会使A的计数减一，同时pa析构时使A的计数减一，那么A的计数为0，A得到释放。
    7. 注意的是我们不能通过weak_ptr直接访问对象的方法，比如B对象中有一个方法print(),我们不能这样访问，pa->pb_->print();英文pb_是一个weak_ptr，应该先把它转化为shared_ptr,如：shared_ptr p = pa->pb_.lock(); p->print();

智能指针的内存泄漏如何解决

  1. 智能指针的内存泄露是指？
    1. shared_ptr的循环引用
  2. 为了解决循环引用导致的内存泄漏，引入了weak_ptr弱指针
    1. weak_ptr的构造函数不会修改引用计数的值，从而不会对对象的内存进行管理，其类似一个普通指针，但不指向引用计数的共享内存，但是其可以检测到所管理的对象是否已经被释放，从而避免非法访问。

野指针是什么？

  • 野指针就是指向一个已删除的对象或者未申请访问受限内存区域的指针

函数指针

  1. 定义
    1. 函数指针是指向函数的指针变量。
    2. 函数指针本身首先是一个指针变量，该指针变量指向一个具体的函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。
    3. C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是大体一致的。
  2. 用途：
    1. 调用函数和做函数的参数，比如回调函数。
  3. 示例：
    1
    2
    3
    4
    char * fun(char * p)  {…}       // 函数fun
    char * (*pf)(char * p);             // 函数指针pf
    pf = fun;                        // 函数指针pf指向函数fun
    pf(p);                        // 通过函数指针pf调用函数fun