首页手记 C++智能指针学习：从入门到实践

C++智能指针学习：从入门到实践

标签：

C++

概述

本文详细介绍了C++智能指针的学习，涵盖了智能指针的基本概念、作用和优势，标准库中的主要类型以及它们的使用方法和应用场景。此外，文章还探讨了智能指针在资源管理、避免内存泄漏和悬挂指针等方面的重要作用。通过实例代码进一步说明了unique_ptr, shared_ptr, 和 weak_ptr的使用技巧和注意事项。

智能指针简介

什么是智能指针

智能指针是指能够自动管理内存的指针对象。在C++中，智能指针通常用于代替裸指针（即普通指针）来管理动态分配的对象。裸指针的使用通常需要手动进行内存管理，例如通过new和delete操作符来进行对象的分配和释放。这种手动管理内存的方式容易导致内存泄漏或悬挂指针（即指向已释放内存的指针）等错误。

智能指针通过引用计数、所有权转移等机制来自动管理内存，从而减少了内存管理的复杂性和错误发生的可能性。在C++11及以后的标准库中引入了三个主要的智能指针类型：unique_ptr, shared_ptr, 和 weak_ptr。

智能指针的作用和优势

内存自动释放：智能指针在对象不再被需要时自动释放内存，避免了手动调用delete操作符的需要。
资源管理：智能指针可以管理除内存以外的其他资源，例如文件句柄、数据库连接等。
避免内存泄漏：由于内存管理由智能指针自动处理，因此避免了手动释放内存可能导致的内存泄漏问题。
避免悬挂指针：智能指针能够保证指针在对象释放后不会被继续使用，从而避免悬挂指针问题。
所有权转移：智能指针支持在不同对象之间传递所有权，避免资源管理混乱。

C++标准库中的智能指针

C++标准库提供了三个主要的智能指针类型：unique_ptr, shared_ptr, 和 weak_ptr。这些类型的智能指针各自有不同的特性，适用于不同的应用场景。

unique_ptr：提供了独占所有权的智能指针，适用于只需要单个所有权和独占访问的对象。
shared_ptr：提供了多个共享所有权的智能指针，适用于需要多个对象共享所有权的场景。
weak_ptr：提供了观察所有权的智能指针，用于解决循环引用问题。

下面分别介绍这些智能指针的使用方法和应用场景。

unique_ptr的使用

unique_ptr的基本用法

unique_ptr是一种独占所有权的智能指针，适用于只需要单个所有权和独占访问的对象。unique_ptr通过移动语义（即所有权转移）来管理对象的生命周期。其主要特性如下：

独占所有权：在任何时刻，只有一个unique_ptr持有对象的所有权。
移动语义：对象的所有权可以通过赋值或复制构造函数从一个unique_ptr转移到另一个unique_ptr。
自动释放：当unique_ptr析构时，它会自动释放所管理的对象。

下面通过代码示例来演示unique_ptr的基本用法：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor called." << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called." << std::endl;
    }
};

int main() {
    // 使用new分配对象并将其所有权转移到unique_ptr
    std::unique_ptr<MyClass> ptr(new MyClass());

    // 所有权转移
    std::unique_ptr<MyClass> ptr2;
    ptr2 = std::move(ptr);

    // 输出指针是否为空
    if (ptr == nullptr) {
        std::cout << "ptr is null." << std::endl;
    }

    // 这里不会调用MyClass的析构函数，析构函数会在ptr2离开作用域时自动调用
    return 0;
}

unique_ptr的移动语义

unique_ptr通过移动语义来管理对象的所有权。移动语义是指对象的所有权可以从一个unique_ptr转移到另一个unique_ptr，并且在转移过程中不会复制实际的对象，而是将所有权标记从一个对象转移到另一个对象。这使得unique_ptr在所有权转移时更加高效。

下面通过代码示例来演示unique_ptr的移动语义：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor called." << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called." << std::endl;
    }
};

int main() {
    // 创建一个unique_ptr并分配对象
    std::unique_ptr<MyClass> ptr(new MyClass());

    // 移动所有权
    std::unique_ptr<MyClass> ptr2 = std::move(ptr);

    // 输出ptr是否为空
    if (ptr == nullptr) {
        std::cout << "ptr is null." << std::endl;
    }

    // 这里不会调用MyClass的析构函数，析构函数会在ptr2离开作用域时自动调用
    return 0;
}

unique_ptr的常见应用场景

独占所有权的资源管理：例如，文件句柄、数据库连接等需要独占访问的资源。
避免多重所有权：避免使用多个指针指向同一个对象，以防止资源管理混乱。
减少内存泄漏：通过自动释放对象，减少手动管理内存可能导致的内存泄漏问题。

#include <iostream>
#include <memory>

class FileHandle {
public:
    FileHandle() {
        std::cout << "FileHandle created." << std::endl;
    }
    ~FileHandle() {
        std::cout << "FileHandle destroyed." << std::endl;
    }
};

int main() {
    // 使用unique_ptr管理文件句柄
    std::unique_ptr<FileHandle> handle(new FileHandle());
    return 0;
}

shared_ptr的使用

shared_ptr的基本概念

shared_ptr是一种共享所有权的智能指针，适用于需要多个对象共享所有权的场景。当所有持有shared_ptr的对象都销毁时，所管理的对象才会被释放。shared_ptr通过引用计数来管理对象的生命周期。

共享所有权：多个shared_ptr可以共享同一个对象的所有权。
引用计数：每个shared_ptr都有一个引用计数，当引用计数降为0时，所管理的对象会被释放。
自动释放：当所有持有shared_ptr的对象销毁时，所管理的对象会被自动释放。

下面通过代码示例来演示shared_ptr的基本用法：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor called." << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called." << std::endl;
    }
};

int main() {
    // 创建两个shared_ptr共享同一个对象
    std::shared_ptr<MyClass> ptr1(new MyClass());
    std::shared_ptr<MyClass> ptr2 = ptr1;

    // 输出引用计数
    std::cout << "ptr1 use count: " << ptr1.use_count() << std::endl;
    std::cout << "ptr2 use count: " << ptr2.use_count() << std::endl;

    // 这里不会调用MyClass的析构函数，析构函数会在所有shared_ptr销毁后调用
    return 0;
}

shared_ptr的引用计数机制

shared_ptr通过引用计数机制来管理对象的生命周期。每个shared_ptr都有一个内部引用计数，表示有多少个shared_ptr在共享同一个对象的所有权。当一个shared_ptr的引用计数变为0时，所管理的对象会被释放。

下面通过代码示例来演示shared_ptr的引用计数机制：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor called." << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called." << std::endl;
    }
};

int main() {
    // 创建两个shared_ptr共享同一个对象
    std::shared_ptr<MyClass> ptr1(new MyClass());
    std::shared_ptr<MyClass> ptr2 = ptr1;

    // 输出引用计数
    std::cout << "ptr1 use count: " << ptr1.use_count() << std::endl;
    std::cout << "ptr2 use count: " << ptr2.use_count() << std::endl;

    // 移除一个shared_ptr
    ptr2.reset();

    // 输出引用计数
    std::cout << "ptr1 use count: " << ptr1.use_count() << std::endl;

    // 这里不会调用MyClass的析构函数，析构函数会在所有shared_ptr销毁后调用
    return 0;
}

shared_ptr的常见应用场景

多个对象共享同一个资源：例如，多个线程共享同一个文件句柄或数据库连接。
避免多重所有权：避免使用多个指针指向同一个对象，以防止资源管理混乱。
减少内存泄漏：通过自动释放对象，减少手动管理内存可能导致的内存泄漏问题。

#include <iostream>
#include <memory>
#include <thread>
#include <vector>

class DatabaseConnection {
public:
    DatabaseConnection() {
        std::cout << "DatabaseConnection created." << std::endl;
    }
    ~DatabaseConnection() {
        std::cout << "DatabaseConnection destroyed." << std::endl;
    }
};

void manageConnections() {
    // 创建多个共享的数据库连接
    std::shared_ptr<DatabaseConnection> conn1(new DatabaseConnection());
    std::shared_ptr<DatabaseConnection> conn2 = conn1;

    // 输出当前引用计数
    std::cout << "conn1 use count: " << conn1.use_count() << std::endl;
    std::cout << "conn2 use count: " << conn2.use_count() << std::endl;

    // 释放一个shared_ptr
    conn2.reset();

    // 输出当前引用计数
    std::cout << "conn1 use count: " << conn1.use_count() << std::endl;

    // 这里不会调用DatabaseConnection的析构函数，析构函数会在所有shared_ptr销毁后调用
}

int main() {
    manageConnections();
    return 0;
}

weak_ptr的使用

weak_ptr的作用

weak_ptr是一种观察所有权的智能指针，用于解决循环引用问题。循环引用是指两个或多个shared_ptr相互持有对方的所有权，导致对象永远不会被释放。weak_ptr可以用来观察shared_ptr管理的对象，而不增加引用计数，从而避免循环引用问题。

不增加引用计数：当weak_ptr访问所管理的对象时，不会增加引用计数。
避免循环引用：通过使用weak_ptr，可以避免两个shared_ptr相互持有对方的所有权，从而避免对象无法释放的问题。

下面通过代码示例来演示weak_ptr的基本用法：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor called." << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called." << std::endl;
    }
};

int main() {
    // 创建一个shared_ptr
    std::shared_ptr<MyClass> ptr1(new MyClass());

    // 创建一个weak_ptr观察shared_ptr管理的对象
    std::weak_ptr<MyClass> weakPtr = ptr1;

    // 通过weakPtr访问sharedPtr管理的对象
    if (std::shared_ptr<MyClass> ptr2 = weakPtr.lock()) {
        std::cout << "weakPtr is valid." << std::endl;
    } else {
        std::cout << "weakPtr is invalid." << std::endl;
    }

    // 这里不会调用MyClass的析构函数，析构函数会在所有shared_ptr销毁后调用
    return 0;
}

weak_ptr与shared_ptr的关系

weak_ptr与shared_ptr的关系是观察与被观察的关系。weak_ptr可以观察shared_ptr管理的对象，而不增加引用计数。当shared_ptr销毁时，weak_ptr会失效，无法再访问所管理的对象。

下面通过代码示例来演示weak_ptr与shared_ptr的关系：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor called." << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called." << std::endl;
    }
};

int main() {
    // 创建一个shared_ptr
    std::shared_ptr<MyClass> ptr1(new MyClass());

    // 创建一个weak_ptr观察shared_ptr管理的对象
    std::weak_ptr<MyClass> weakPtr = ptr1;

    // 释放shared_ptr
    ptr1.reset();

    // 通过weakPtr访问sharedPtr管理的对象
    if (std::shared_ptr<MyClass> ptr2 = weakPtr.lock()) {
        std::cout << "weakPtr is valid." << std::endl;
    } else {
        std::cout << "weakPtr is invalid." << std::endl;
    }

    // 这里不会调用MyClass的析构函数，析构函数会在所有shared_ptr销毁后调用
    return 0;
}

weak_ptr的使用场景

避免循环引用：通过使用weak_ptr，可以避免两个shared_ptr相互持有对方的所有权，从而避免对象无法释放的问题。
观察所有权：可以在不增加引用计数的情况下，观察shared_ptr管理的对象。

智能指针的注意事项

资源管理与所有权转移

智能指针的主要功能是自动管理资源，但需要注意的是，资源管理与所有权转移仍然是代码编写中的重要考虑因素。例如，当使用unique_ptr时，必须确保资源的所有权只能由一个unique_ptr持有，否则可能会出现资源管理混乱的问题。

下面通过代码示例来演示资源管理与所有权转移的注意事项：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor called." << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called." << std::endl;
    }
};

int main() {
    // 创建一个unique_ptr
    std::unique_ptr<MyClass> ptr1(new MyClass());

    // 所有权转移
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1);

    // 输出ptr是否为空
    if (ptr1 == nullptr) {
        std::cout << "ptr1 is null." << std::endl;
    }

    // 这里不会调用MyClass的析构函数，析构函数会在ptr2离开作用域时自动调用
    return 0;
}

避免循环引用

循环引用是指两个或多个shared_ptr相互持有对方的所有权，导致对象永远不会被释放。为了避免循环引用，可以使用weak_ptr来观察所有权，而不增加引用计数。

下面通过代码示例来演示如何避免循环引用：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor called." << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called." << std::endl;
    }
};

int main() {
    // 创建两个shared_ptr
    std::shared_ptr<MyClass> ptr1(new MyClass());
    std::shared_ptr<MyClass> ptr2(new MyClass());

    // 使两个shared_ptr相互持有对方的所有权
    ptr1 = ptr2;
    ptr2 = ptr1;

    // 使用weak_ptr避免循环引用
    std::weak_ptr<MyClass> weakPtr = ptr1;

    // 释放ptr1
    ptr1.reset();

    // 通过weakPtr访问sharedPtr管理的对象
    if (std::shared_ptr<MyClass> ptr2 = weakPtr.lock()) {
        std::cout << "weakPtr is valid." << std::endl;
    } else {
        std::cout << "weakPtr is invalid." << std::endl;
    }

    // 这里不会调用MyClass的析构函数，析构函数会在所有shared_ptr销毁后调用
    return 0;
}

智能指针的转换

智能指针之间可以通过reset、get、static_pointer_cast、dynamic_pointer_cast等方法进行转换。

reset：重置智能指针并使它指向新的对象。
get：获取智能指针所管理的对象的裸指针。
static_pointer_cast：进行静态类型转换。
dynamic_pointer_cast：进行动态类型转换。

下面通过代码示例来演示智能指针的转换：

#include <iostream>
#include <memory>

class Base {
public:
    Base() {
        std::cout << "Base constructor called." << std::endl;
    }
    ~Base() {
        std::cout << "Base destructor called." << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructor called." << std::endl;
    }
    ~Derived() {
        std::cout << "Derived destructor called." << std::endl;
    }
};

int main() {
    // 创建一个shared_ptr指向Base对象
    std::shared_ptr<Base> basePtr(new Derived());

    // 使用static_pointer_cast进行类型转换
    std::shared_ptr<Base> basePtr2 = std::static_pointer_cast<Base>(basePtr);

    // 使用dynamic_pointer_cast进行类型转换
    std::shared_ptr<Derived> derivedPtr = std::dynamic_pointer_cast<Derived>(basePtr);

    // 输出类型转换后的结果
    if (derivedPtr) {
        std::cout << "DerivedPtr is valid." << std::endl;
    } else {
        std::cout << "DerivedPtr is invalid." << std::endl;
    }

    // 这里不会调用Base和Derived的析构函数，析构函数会在所有shared_ptr销毁后调用
    return 0;
}

实践案例

智能指针在项目中的应用实例

假设有一个项目需要管理多个数据库连接，每个连接都是通过网络连接到远程服务器的。由于连接可能需要在多个线程之间共享，因此可以使用shared_ptr来管理这些连接。此外，为了防止循环引用问题，可以使用weak_ptr来观察连接的状态。

下面是一个简单的示例代码，演示如何使用shared_ptr和weak_ptr来管理数据库连接：

#include <iostream>
#include <memory>
#include <vector>

class DatabaseConnection {
public:
    DatabaseConnection() {
        std::cout << "DatabaseConnection created." << std::endl;
    }
    ~DatabaseConnection() {
        std::cout << "DatabaseConnection destroyed." << std::endl;
    }
};

void manageConnections() {
    // 创建多个共享的数据库连接
    std::shared_ptr<DatabaseConnection> conn1(new DatabaseConnection());
    std::shared_ptr<DatabaseConnection> conn2 = conn1;

    // 使用weak_ptr观察连接状态
    std::weak_ptr<DatabaseConnection> weakConn = conn1;

    // 输出当前引用计数
    std::cout << "conn1 use count: " << conn1.use_count() << std::endl;
    std::cout << "conn2 use count: " << conn2.use_count() << std::endl;

    // 释放一个shared_ptr
    conn2.reset();

    // 输出当前引用计数
    std::cout << "conn1 use count: " << conn1.use_count() << std::endl;

    // 通过weakPtr访问sharedPtr管理的对象
    if (std::shared_ptr<DatabaseConnection> conn2 = weakConn.lock()) {
        std::cout << "weakConn is valid." << std::endl;
    } else {
        std::cout << "weakConn is invalid." << std::endl;
    }

    // 这里不会调用DatabaseConnection的析构函数，析构函数会在所有shared_ptr销毁后调用
}

int main() {
    manageConnections();
    return 0;
}

常见问题及解决方案

问题1：如何避免shared_ptr导致的循环引用？

解决方案： 使用weak_ptr来观察shared_ptr管理的对象，而不增加引用计数。当shared_ptr销毁时，weak_ptr会失效，无法再访问所管理的对象。

下面是一个示例代码，演示如何使用weak_ptr来避免循环引用：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor called." << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called." << std::endl;
    }
};

void manageObjects() {
    // 创建两个shared_ptr
    std::shared_ptr<MyClass> ptr1(new MyClass());
    std::shared_ptr<MyClass> ptr2(new MyClass());

    // 使两个shared_ptr相互持有对方的所有权
    ptr1 = ptr2;
    ptr2 = ptr1;

    // 使用weak_ptr避免循环引用
    std::weak_ptr<MyClass> weakPtr = ptr1;

    // 释放ptr1
    ptr1.reset();

    // 通过weakPtr访问sharedPtr管理的对象
    if (std::shared_ptr<MyClass> ptr2 = weakPtr.lock()) {
        std::cout << "weakPtr is valid." << std::endl;
    } else {
        std::cout << "weakPtr is invalid." << std::endl;
    }

    // 这里不会调用MyClass的析构函数，析构函数会在所有shared_ptr销毁后调用
}

int main() {
    manageObjects();
    return 0;
}

问题2：如何在多线程环境中使用智能指针？

解决方案： 在多线程环境中使用智能指针时，要注意线程安全问题。可以通过使用std::shared_ptr和std::weak_ptr来管理资源，同时确保在多线程环境中使用智能指针时不会出现资源竞争。

下面是一个示例代码，演示如何在多线程环境中使用智能指针：

#include <iostream>
#include <memory>
#include <thread>
#include <vector>
#include <mutex>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor called." << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor called." << std::endl;
    }
};

std::shared_ptr<MyClass> globalPtr;

void threadFunction() {
    // 使用globalPtr
    if (std::shared_ptr<MyClass> localPtr = globalPtr.lock()) {
        std::cout << "Thread accessing globalPtr." << std::endl;
    } else {
        std::cout << "Thread cannot access globalPtr." << std::endl;
    }
}

int main() {
    // 创建一个shared_ptr并将其赋值给全局变量
    globalPtr = std::make_shared<MyClass>();

    // 创建多个线程
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; i++) {
        threads.push_back(std::thread(threadFunction));
    }

    // 等待所有线程完成
    for (auto& thread : threads) {
        thread.join();
    }

    // 这里不会调用MyClass的析构函数，析构函数会在所有shared_ptr销毁后调用
    return 0;
}

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

翻翻过去那场雪

手记
篇

粉丝

7

获赞与收藏

27

关注作者，订阅最新文章

阅读免费教程

Android Studio 编辑器教程

40个小节 11847 244

后端通用面试教程

41个小节 30583 343

网络编程入门教程

20个小节 12561 237

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空