C++面试总结-----指针

指针

1.指针常量、常量指针，常指针常量

(1)指针：是一个变量，但是这个变量存储的是另一个变量的地址，我们可以通过访问这个地址来修改变量。
(2):指针常量、常量指针，常指针常量
  指针常量:是一个指针，其指向的地址值不能被改变，但其所指向的值可以被改变。
  常量指针:是一个指针，其所指向的值不能被改变，但其指向的地址值可以被改变。
  常指针常量:是一个指针，其指向的地址值和所指向的值都不能被改变。

const int* ptr; // 指向整型常量的指针
int* const ptr; // 指针常量，指向的地址不能修改
const int* const ptr; // 指向整型常量的指针常量
 

  当我们使用指针常量时，可以通过解引用操作来修改它指向的变量的值，但不能修改它指向的地址的值。例如：

int num = 10;
int* const ptr = # // ptr为指针常量，指向num的地址
*ptr = 20; // 可以修改num的值为20
ptr = &anotherNum; // 不允许修改ptr指向的地址
 

   常量指针，指针本身是可变的，但指向的对象是不可变的。常量指针的声明方式为：const int* ptr。在该声明中，ptr是一个指向常量整数的指针。通过这个声明，我们可以修改指针指向的位置，但不能修改该位置上的值。
   此外，我们还可以使用int* const ptr的方式声明常量指针。在该声明中，ptr本身是不可变的，但指向的对象是可变的。例如：

const int a = 5;
const int* ptr = &a;
*ptr = 6; // 错误，由于指针指向的是常量，因此不能修改该位置上的值
ptr++;    // 正确，指针本身是可变的


int a = 5;
int* const ptr = &a;
*ptr = 6; // 正确，由于指针指向的是可变的，因此可以修改该位置上的值
ptr++;    // 错误，由于指针本身是常量，因此不能修改指针指向的位置

   常指针常量指的是一个指针变量，它的值不能被修改，并且所指向的内存空间中的值也不能被修改。即指针本身不能改变指向的位置，指向的位置中的值也不能改变。其声明方式为：

const int * const ptr = &value;

//const int * 表示指针指向的是一个常量，即该指针所指向的内存空间的值不能被修改。
//而 const 在 * 前面表示该指针本身是一个常量，即指针的值（即指针指向的地址）不能被修改。
//因此，ptr 是一个常指针常量，指向的内存空间中的值不能被修改，同时指针本身也不能被修改。

2.智能指针

std::shared_ptr：共享的智能指针
std::unique_ptr：独占的智能指针
std::weak_ptr：弱引用的智能指针，它不共享指针，不能操作资源，是用来监视shared_ptr

（1）三者的区别:

1. 所有权：shared_ptr允许多个指针共享同一个对象，通过引用计数来跟踪对象的引用数量，并在所有引用都释放后删除对象。unique_ptr拥有独占性所有权，同一时间只能有一个指针指向对象，当指针被销毁或重置时，对象也被删除。weak_ptr是弱引用，可以引用shared_ptr所管理的对象，但不会增加对象的引用计数，当所有的shared_ptr释放后，weak_ptr自动失效。
2. 内存管理：shared_ptr使用引用计数来管理对象的生命周期，每次复制shared_ptr时，引用计数会递增；当引用计数为0时，对象被删除。unique_ptr使用独占性所有权，它不使用引用计数，而是通过将对象的所有权从一个unique_ptr转移到另一个unique_ptr来管理对象的生命周期。weak_ptr不对对象进行内存管理，它仅仅是提供对shared_ptr管理对象的访问权限。
3. 空指针检查：shared_ptr和weak_ptr提供了对空指针的检查，可以通过检查shared_ptr.get()是否为nullptr来确定所指向的对象是否存在。unique_ptr没有提供直接的空指针检查方法，但可以通过检查unique_ptr是否有效（即不为空）来确定所指向的对象是否存在。
4. 性能开销：shared_ptr由于引用计数的开销，通常比unique_ptr更重量级。unique_ptr相对较轻量，但在转移所有权时需要移动对象的指针。weak_ptr的开销较小，由于它不增加引用计数，可以用来避免shared_ptr之间的循环引用。

（2）初始化方法：

  在C++中，可以使用以下方法来初始化shared_ptr、unique_ptr和weak_ptr。

  1. shared_ptr初始化方法：

• 使用make_shared函数：这是一种推荐的方法，可以减少动态内存分配和管理的负担。例如：

  auto ptr = std::make_shared<int>(42);
  

• 使用普通的new操作符：使用普通的new操作符，然后将指针传递给shared_ptr的构造函数。例如：

  int* rawPtr = new int(42);
  std::shared_ptr<int> ptr(rawPtr);
  

• 使用weak_ptr.lock()：从已有的shared_ptr或weak_ptr对象转换而来。例如：

  std::shared_ptr<int> sharedPtr(new int(42));
  std::weak_ptr<int> weakPtr(sharedPtr);
  std::shared_ptr<int> ptr = weakPtr.lock();
  

2. unique_ptr初始化方法：

   • 使用普通的new操作符：使用普通的new操作符，然后将指针传递给unique_ptr的构造函数。例如：

     int* rawPtr = new int(42);
     std::unique_ptr<int> ptr(rawPtr);
     

   • 使用std::move函数：将一个已有的unique_ptr对象转移给另一个unique_ptr对象。例如：

     std::unique_ptr<int> ptr1(new int(42));
     std::unique_ptr<int> ptr2 = std::move(ptr1);
     

3. weak_ptr初始化方法：

   • 从已有的shared_ptr对象转换而来：例如：

     std::shared_ptr<int> sharedPtr(new int(42));
     std::weak_ptr<int> weakPtr(sharedPtr);
     

   • 从已有的weak_ptr对象转换而来：例如：

     std::weak_ptr<int> weakPtr1;
     std::weak_ptr<int> weakPtr2(weakPtr1);
     

   • 使用std::weak_ptr.lock()：从已有的shared_ptr或weak_ptr对象转换而来。例如：

     std::shared_ptr<int> sharedPtr(new int(42));
     std::weak_ptr<int> weakPtr(sharedPtr);
     std::shared_ptr<int> ptr = weakPtr.lock();
     

   在使用这些智能指针时，要避免使用裸指针直接管理内存资源，因为智能指针能够自动释放内存资源并避免内存泄漏或悬挂指针的情况。同时，使用make_XXX函数和std::move函数能够提供更高的效率和安全性。

3.指针与引用的区别

指针和引用都是用来间接访问变量的，但是它们有以下几点不同：

1. 定义和使用方式：指针需要使用符号*来定义和使用，而引用直接使用变量名来定义和使用。

   int x = 10;
   int *ptr = &x; // 定义指针
   int &ref = x;  // 定义引用
   

2. 空值：指针可以具有空值（null），即指向空地址。引用则必须在定义时初始化，并且不能指向空值。

   int *ptr = nullptr; // 指针为空
   int &ref = x;       // 引用不为空
   

3. 再赋值：指针可以再赋值，即可以指向不同的变量或空值。引用一旦初始化后，就不能再指向其他变量。

   int x = 10, y = 20;
   int *ptr = &x;    // 指针指向 x
   ptr = &y;         // 指针重新指向 y
   
   int &ref = x;     // 引用指向 x
   ref = y;          // 修改 x 的值，而不是改变引用指向
   

4. 空间占用：指针通常占用4个或8个字节（根据机器位数决定），而引用不占用额外空间，只是变量的一个别名。

5. const 限定符：指针可以指向 const 或非 const 类型的变量，也可以使用 const 限定符对指针进行限制。而引用可以指向 const 类型的变量，但不可以使用 const 限定符对引用进行限制。

   const int x = 10;
   const int *ptr = &x;   // 指针指向 const int
   int &ref = x;          // 引用指向 const int
   const int &cref = x;   // 引用指向 const int
   

总结：指针可以为空、可以再赋值、需要使用*来定义和使用、占用额外空间；引用必须初始化、不能为空、不能再指向其他变量、直接使用变量名来定义和使用、不占用额外空间。