C++语法|C++八股|C++新特性之auto关键字、智能指针shared_ptr、unique_ptr、weak_ptr

Che3rry

已于 2024-08-29 20:44:49 修改

阅读量841

点赞数 15

分类专栏： # C/C++ 文章标签： c++ 开发语言

于 2024-03-25 21:36:27 首次发布

本文链接：https://blog.csdn.net/caiziming_001/article/details/137024488

版权

C/C++ 专栏收录该内容

85 篇文章 2 订阅

订阅专栏

文章目录

auto关键字
智能指针

auto关键字

基本用法

auto x = 5; // x 被推导为 int
auto y = 3.14; // y 被推导为 double
auto z = "Hello, world!"; // z 被推导为 const char*

实际应用

auto往往用于容器和迭代器中，auto的引入特别有利于简化STL容器和迭代器的使用。在C++11之前，声明迭代器类型需要手动书写完整的类型，有时会显得非常繁琐。


std::vector<int> v = {1, 2, 3, 4, 5};

// C++98/03中的迭代器声明
for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
    std::cout << *it << std::endl;
}

// C++11中使用auto关键字
for (auto it = v.begin(); it != v.end(); ++it) {
    std::cout << *it << std::endl;
}

注意事项

使用auto时，变量必须在声明时初始化，这是因为编译器需要初始化表达式来推导变量的类型。
auto能够正确推导出大多数类型，但在一些特殊场景下（如初始化列表或NULL指针）可能需要显式指定类型。
auto声明的变量类型一旦确定，就不能被赋予其他类型的值，这与动态类型语言不同。

智能指针

shared_ptr

基本使用

shared_ptr用于管理具有引用计数的动态分配的对象。当一个shared_ptr对象被销毁（例如，离开作用域）时，它所管理的对象引用计数会减少。当引用计数变为0时，对象会被自动删除。这样，shared_ptr可以帮助防止内存泄漏，并简化内存管理。
直观来说，共享指针会记录有多少个共享指针指向同一个对象，当这个数字降为零的时候，程序将会自动释放内存，省去手动delete的烦恼。

#include <memory>
#include <iostream>

int main() {
    // 创建shared_ptr,使用make_shared定义一个shared_ptr p1
    //make_shared会动态分配一块内存，创建对应的资源
    std::shared_ptr<int> p1 = std::make_shared<int>(10);
    // 使用
    std::cout << *p1 << std::endl;  // 输出: 10
    
    // 复制shared_ptr，引用计数增加
    std::shared_ptr<int> p2 = p1;
    std::cout << p1.use_count() << std::endl;  // 输出: 2
  
    // 离开作用域时，引用计数减少，当引用计数为0时，自动删除对象
}

入上例所示，shared_ptr是一个模版指针，可以接受一个类型和对应的初始化参数。

分别通过new和make_shared构造shared_ptr

在C++中，std::shared_ptr的构造函数是用来创建一个std::shared_ptr对象的，它可以接受一个裸指针作为参数。当我们说“在new之后、赋值操作之前抛出异常”时，主要是指在直接使用new操作符分配内存并用这个内存地址初始化一个std::shared_ptr时，这个过程实际上包括两步：首先是调用new操作符动态分配内存，然后是将分配得到的裸指针传递给std::shared_ptr的构造函数来创建std::shared_ptr对象。

shared_ptr<int> p {new int(100)};

但是，通过make_shared创建shared_ptr有更多好处：

效率和内存使用：
std::make_shared在单个内存分配中同时分配了对象和其引用计数的控制块（control block），而使用new操作符则通常会导致两次内存分配——一次是为对象本身，另一次是为控制块。std::make_shared这种一次性分配减少了内存使用量，也提高了程序的效率，因为减少了内存分配的次数。
异常安全：
std::make_shared提供更强的异常安全保障。在使用new和std::shared_ptr构造函数的组合时，如果std::shared_ptr的构造函数在new之后、赋值操作之前抛出异常（例如，由于内存不足），那么通过new分配的内存将无法被释放，因为std::shared_ptr对象尚未被成功构造，也就没有机会接管这块内存的管理权，从而导致内存泄露。那么已经通过new创建的对象将无法被删除，从而导致内存泄露。而std::make_shared作为一个单一操作，可以保证即使在发生异常的情况下也不会泄露资源。
代码简洁：
使用std::make_shared可以使代码更加简洁明了。它避免了显式使用new操作符，使得代码更容易理解和维护。

shared_ptr的线程安全问题

std::shared_ptr保证了对引用计数的修改是线程安全的，但它不保证用户对共享对象的并发访问是线程安全的，需要用户根据实际情况采取适当的同步措施。

对单个std::shared_ptr实例的操作是线程安全的：如果你在不同的线程中操作同一个std::shared_ptr实例（例如改变它所指向的对象），这些操作是互斥的。这意味着，对引用计数的增加和减少是原子操作，不会导致数据竞争或不一致的状态。
不同的std::shared_ptr实例指向相同对象的操作也是线程安全的：这包括用同一个原始指针构造多个std::shared_ptr实例，或者是拷贝std::shared_ptr实例。因为这涉及到对同一对象的引用计数的修改，这些操作也是线程安全的。

然而，需要注意的是：

虽然std::shared_ptr提供了对共享对象引用计数的线程安全管理，但这并不意味着它所指向的对象本身就是线程安全的。如果有多个线程需要访问std::shared_ptr所管理的对象，并对其进行修改，那么你需要自己保证这种访问是线程安全的，例如通过互斥锁（std::mutex）等同步机制。
对不同的std::shared_ptr实例的操作是线程安全的，意味着如果每个线程操作的是不同的std::shared_ptr实例，即便这些实例指向相同的对象，操作也是线程安全的。但是，对同一个std::shared_ptr实例的并发读写（例如，一个线程在读取shared_ptr，同时另一个线程修改它）需要用户自己保证线程安全。

小总结（面试背这个即可）

（1）同⼀个shared_ptr被多个线程“读”是安全的;
（2）同⼀个shared_ptr被多个线程“写”是不安全的;
（3）指向相同对象的不同std::shared_ptr实例被多个线程“写”是安全的(当然了，共享对象本身是需要加锁保护的)。

unique_ptr

它拥有其所指向的对象，并保证被管理的对象的唯一性。当std::unique_ptr超出作用域或被显式删除时，它所管理的对象也会被自动删除。这样可以有效避免内存泄漏，提高代码的安全性和健壮性。 unique_ptr是不可复制的，但可以移动，这确保了对象的唯一所有权。

基本使用

#include <memory>

struct MyClass {
    int value;
    MyClass(int val) : value(val) {}
    ~MyClass() { /* 资源释放 */ }
};

int main() {
    // 使用std::make_unique（推荐）
    std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>(10);
    
    // 直接使用new操作符
    std::unique_ptr<MyClass> ptr2(new MyClass(20));
    
    // 使用std::move转移所有权
    std::unique_ptr<MyClass> ptr3 = std::move(ptr2);
 
    return 0;
}

转移unique_ptr所有权

直接转移所有权

转移std::unique_ptr的所有权更推荐直接使用移动语义，而不是先release和reset。

std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
std::unique_ptr<int> ptr2;

// 直接使用std::move转移所有权
ptr2 = std::move(ptr1); // ptr1被置为空，ptr2接管了对象的所有

使用release转移所有权

release方法用于释放std::unique_ptr对对象的所有权，返回裸指针，并将unique_ptr本身置为空。请注意，一旦调用了release，原unique_ptr不再拥有对象，也就不再负责释放该对象。因此，你需要确保以某种方式管理这个裸指针，避免内存泄露。

std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
int* rawPtr = ptr1.release(); // ptr1释放所有权，现在指向nullptr

// 你需要负责rawPtr指向对象的释放
delete rawPtr;

使用reset转移所有权

reset方法用于重置std::unique_ptr实例，它有两种用法。第一种，不带参数调用，它会删除unique_ptr当前拥有的对象（如果有的话）并将unique_ptr置为空。第二种，带有一个裸指针参数调用，它会删除当前对象，并接管新提供的裸指针的所有权。

std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
std::unique_ptr<int> ptr2;

// 使用reset转移所有权
// 首先，释放ptr1对对象的所有权，并获取裸指针
int* rawPtr = ptr1.release();

// 然后，通过reset让ptr2接管这个裸指针的所有权
ptr2.reset(rawPtr); // 现在ptr2拥有对象的所有权，ptr1为空

如何将unique_ptr传递给一个函数

函数不需要取得所有权：通过引用传递
在这种情况下，你可以简单地将·std::unique_ptr·作为引用传递给函数。这样函数可以使用指针所指向的对象，但不会获得其所有权，也就是说，函数执行完毕后，调用方仍然保持对对象的所有权。

#include <iostream>
#include <memory>

void useObjectWithoutTakingOwnership(const std::unique_ptr<int>& ptr) {
    std::cout << "Value: " << *ptr << std::endl;
    // 函数结束后，ptr的所有权没有改变
}

int main() {
    std::unique_ptr<int> myPtr = std::make_unique<int>(42);
    useObjectWithoutTakingOwnership(myPtr);
    // 我们仍然拥有myPtr的所有权，并且可以继续使用它
    if (myPtr) {
        std::cout << "myPtr still owns the object." << std::endl;
    }
    return 0;
}

函数需要取得所有权：通过std::move传递
如果函数需要取得std::unique_ptr的所有权，那么你应该使用std::move将所有权转移到函数中。这样，调用方将失去对对象的所有权，而函数则获得了所有权。这通常用在函数需要长期持有或管理该对象的场景。

#include <iostream>
#include <memory>

void takeOwnership(std::unique_ptr<int> ptr) {
    std::cout << "Value after taking ownership: " << *ptr << std::endl;
    // 函数结束后，ptr将被自动销毁，对象也随之释放
}

int main() {
    std::unique_ptr<int> myPtr = std::make_unique<int>(99);
    takeOwnership(std::move(myPtr));
    // myPtr现在为空，因为它的所有权已经转移
    if (!myPtr) {
        std::cout << "myPtr no longer owns the object." << std::endl;
    }
    return 0;
}

weak_ptr

设计用来解决std::shared_ptr带来的潜在循环引用问题。weak_ptr持有对shared_ptr管理对象的非拥有（弱）引用，即它不增加对象的引用计数。这意味着，尽管weak_ptr可以访问对象，但它的存在不会阻止对象被销毁。

重要内容

关于std::weak_ptr访问对象
weak_ptr本身不提供直接访问其所指对象的方法，因为它的设计初衷是不拥有对象。我们应该通过通过 std::weak_ptr::lock() 可以⼀个 std::shared_ptr 来访问资源。如果原对象已经不存在（即weak_ptr已经过期），lock()将返回一个空的std::shared_ptr对象。应该通过通过检查这个返回的shared_ptr是否为空来判断原对象是否还存在

auto sptr = weakPtr.lock();
if (sptr) {
    // 对象仍然存在，可以安全使用sptr访问对象
} else {
    // 对象已经被销毁，sptr为空
}

解决循环引用问题：
当两个或多个std::shared_ptr相互引用时，会形成循环引用，导致引用计数永远不会达到0，进而导致内存泄露。通过将其中一个或多个shared_ptr替换为weak_ptr，可以打破循环，允许对象被正确回收。
假设有两个类A和B，它们相互引用对方。如果我们使用std::shared_ptr来相互持有引用，那么就会产生循环引用，导致内存泄露。为了解决这个问题，我们可以让其中一个类（比如B）使用std::weak_ptr来引用另一个类（A），这样就不会增加引用计数，从而避免循环引用。

#include <iostream>
#include <memory>

class B; // 前置声明

class A {
public:
    std::shared_ptr<B> bPtr; // A持有B的强引用
    ~A() { std::cout << "A destroyed\n"; }
};

class B {
public:
    std::weak_ptr<A> aPtr; // B持有A的弱引用
    ~B() { std::cout << "B destroyed\n"; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    
    a->bPtr = b; // A类持有B的一个强引用
    b->aPtr = a; // B类持有A的一个弱引用
    
    // 当main结束时，由于B对A的引用是弱引用，它不会阻止A被销毁。
    // 因此A和B都会被正确销毁，避免了循环引用导致的内存泄露问题。
    return 0;
}