首页手记 C++智能指针入门教程

C++智能指针入门教程

标签：

C++

概述

本文介绍了C++智能指针入门的相关内容，包括智能指针的基本概念、作用和优势，以及如何使用标准库中的unique_ptr、shared_ptr和weak_ptr。文章还详细讲解了智能指针的初始化与管理方法，以及常见的错误陷阱和解决方案。通过这些内容，读者可以全面了解和掌握C++智能指针入门知识。

智能指针的基本概念

什么是智能指针

智能指针是C++中用于自动管理内存的一种工具。它们通过RAII（资源获取即初始化）技术来自动管理所指向对象的生命周期，从而避免内存泄漏和野指针访问。智能指针分为几种不同的类型，每种类型都有特定的功能和使用场景。

智能指针的作用和优势

智能指针的主要作用是简化内存管理，避免手动管理内存带来的复杂性和潜在的错误。以下是智能指针的一些主要优势：

自动释放资源：当智能指针的生命周期结束时，其所管理的资源会被自动释放，避免了内存泄漏的风险。
防止悬挂指针：通过引用计数等机制，智能指针可以有效管理多个共享对象的生命周期，防止悬挂指针访问。
增强代码可读性：使用智能指针有助于提高代码的可读性和可维护性，降低了代码复杂度。

以下是智能指针作用和优势的具体示例：

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> ptr1(new int(10));
    std::shared_ptr<int> ptr2(new int(20));

    std::cout << "ptr1 points to: " << *ptr1 << std::endl;
    std::cout << "ptr2 points to: " << *ptr2 << std::endl;

    // 使用智能指针自动释放资源
    ptr1.reset();
    ptr2.reset();

    return 0;
}

标准库中的智能指针

unique_ptr

基本用法

std::unique_ptr 是一种独占所有权的智能指针，它确保在同一时间只有一个智能指针持有某个资源的所有权。unique_ptr 不支持拷贝，但可以进行移动操作。

#include <memory>
#include <iostream>

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

    // 访问指针指向的值
    std::cout << "ptr points to: " << *ptr << std::endl;

    // 移动 unique_ptr
    std::unique_ptr<int> ptr2 = std::move(ptr);

    // 尝试访问 ptr 将导致访问一个已释放的指针（未定义行为）
    // std::cout << "ptr points to: " << *ptr << std::endl;

    return 0;
}

特性与限制

独占所有权：unique_ptr 保证在同一时间只有一个智能指针持有资源的所有权。
不允许拷贝：unique_ptr 不支持拷贝，但可以通过移动操作将所有权转移给其他 unique_ptr。
使用场景：适用于独占资源的情况，如单例模式中的资源管理。

shared_ptr

基本用法

std::shared_ptr 是一种支持共享所有权的智能指针。多个 shared_ptr 可以共享同一个资源，并通过引用计数来管理资源的生命周期。

#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> ptr1(new int(5));
    std::shared_ptr<int> ptr2 = ptr1; // 共享同一资源

    // 访问指针指向的值
    std::cout << "ptr1 points to: " << *ptr1 << std::endl;
    std::cout << "ptr2 points to: " << *ptr2 << std::endl;

    // 没有任何 shared_ptr 指向该资源时，资源会被销毁
    return 0;
}

使用场景与注意事项

使用场景：适用于需要共享资源的情况，如资源池管理。
注意事项：
- 多个 shared_ptr 共享同一个资源时，需要注意引用计数管理。
- 使用 shared_ptr 时要注意循环引用问题，可能会导致资源泄露。
- 每次 shared_ptr 调用拷贝构造函数时，引用计数会增加；当 shared_ptr 被销毁时，引用计数会减少，当引用计数降为0时，资源会被释放。

weak_ptr

基本用法

std::weak_ptr 是一种不拥有资源所有权的智能指针，它依赖于 shared_ptr 来管理资源的生命周期。weak_ptr 主要用于避免循环引用问题。

#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> ptr1(new int(5));
    std::weak_ptr<int> weakPtr = ptr1;

    // 检查 weakPtr 是否仍然有效
    if (auto sharedPtr = weakPtr.lock()) {
        std::cout << "weakPtr points to: " << *sharedPtr << std::endl;
    } else {
        std::cout << "weakPtr is expired." << std::endl;
    }

    return 0;
}

使用场景

使用场景：适用于需要检查资源是否有效的情况下，避免循环引用导致的资源泄露。

智能指针的初始化与管理

初始化智能指针

智能指针可以通过多种方式进行初始化：

直接初始化
从裸指针初始化
通过工厂函数初始化

#include <memory>
#include <iostream>

int main() {
    // 直接初始化
    std::unique_ptr<int> ptr1(new int(5));

    // 从裸指针初始化
    int* rawPtr = new int(10);
    std::unique_ptr<int> ptr2(rawPtr);

    // 通过工厂函数初始化
    std::unique_ptr<int> ptr3 = std::unique_ptr<int>(new int(15));

    return 0;
}

智能指针的赋值操作

智能指针支持移动和拷贝操作，但 unique_ptr 不支持拷贝，只支持移动。

#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int> ptr1(new int(5));
    std::unique_ptr<int> ptr2 = std::move(ptr1); // 移动操作

    // 尝试访问 ptr1 将导致未定义行为
    // std::cout << "ptr1 points to: " << *ptr1 << std::endl;

    std::shared_ptr<int> shared1(new int(10));
    std::shared_ptr<int> shared2 = shared1; // 拷贝操作

    return 0;
}

智能指针的生命周期管理

智能指针的生命周期由构造函数和析构函数管理。当智能指针被销毁时，其所管理的资源也会被自动释放。

#include <memory>
#include <iostream>

int main() {
    {
        std::unique_ptr<int> ptr(new int(5));
        std::cout << "ptr points to: " << *ptr << std::endl;
    } // ptr 被销毁时，其所管理的资源被释放

    return 0;
}

智能指针的常见问题与解决方案

常见错误与陷阱

多重删除：错误地对同一个资源多次释放会导致程序崩溃。
内存泄露：未正确管理资源生命周期可能导致内存泄露。
循环引用：多个 shared_ptr 彼此持有对方的引用，导致资源无法释放。

解决方案与最佳实践

避免多重删除：确保每个资源仅被释放一次，可以通过 unique_ptr 和 shared_ptr 管理资源生命周期。
解决内存泄露：使用智能指针自动管理资源生命周期。
避免循环引用：使用 weak_ptr 来避免循环引用问题。

以下是一个循环引用问题的实际示例和解决方法：

#include <memory>
#include <iostream>

struct Resource {
    int value;
    Resource(int v) : value(v) {}

    ~Resource() {
        std::cout << "Resource " << value << " destroyed." << std::endl;
    }
};

int main() {
    {
        std::shared_ptr<Resource> ptr1(new Resource(1));
        std::shared_ptr<Resource> ptr2 = ptr1;

        // 释放 ptr1 时，由于 ptr2 仍然持有资源，资源不会被释放
        // ptr1.reset();

        // 使用 weak_ptr 避免循环引用
        std::weak_ptr<Resource> weakPtr = ptr1;
        if (auto strongPtr = weakPtr.lock()) {
            std::cout << "Resource " << strongPtr->value << " is still alive." << std::endl;
        }
    }

    return 0;
}

智能指针的应用实例

实例代码演示

以下是一个简单的例子，展示了如何使用 shared_ptr 和 weak_ptr 来管理资源的生命周期。

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

class Resource {
public:
    int id;
    Resource(int i) : id(i) {}

    ~Resource() {
        std::cout << "Resource " << id << " destroyed." << std::endl;
    }
};

class ResourcePool {
public:
    void addResource(int id) {
        // 添加资源到池中
        resources.push_back(std::make_shared<Resource>(id));
    }

    void removeResource(int id) {
        // 移除资源
        for (auto it = resources.begin(); it != resources.end(); ++it) {
            if ((*it)->id == id) {
                resources.erase(it);
                break;
            }
        }
    }

    std::weak_ptr<Resource> getWeakPtr(int id) const {
        // 通过 weak_ptr 获取资源
        for (auto& resource : resources) {
            if (resource->id == id) {
                return resource;
            }
        }
        return {};
    }

private:
    std::vector<std::shared_ptr<Resource>> resources;
};

int main() {
    ResourcePool pool;

    pool.addResource(1);
    pool.addResource(2);

    // 通过 weak_ptr 检查资源是否仍然有效
    auto weakPtr1 = pool.getWeakPtr(1);
    auto weakPtr2 = pool.getWeakPtr(2);

    if (auto sharedPtr1 = weakPtr1.lock()) {
        std::cout << "Resource 1 is still alive." << std::endl;
    }

    if (auto sharedPtr2 = weakPtr2.lock()) {
        std::cout << "Resource 2 is still alive." << std::endl;
    }

    // 移除资源
    pool.removeResource(1);

    // 再次检查资源是否仍然有效
    if (auto sharedPtr1 = weakPtr1.lock()) {
        std::cout << "Resource 1 is still alive." << std::endl;
    } else {
        std::cout << "Resource 1 is no longer valid." << std::endl;
    }

    return 0;
}

实际项目中的应用案例

在实际项目中，智能指针可以广泛应用于资源管理、对象池、依赖注入等领域。例如，在一个游戏引擎中，智能指针可以用来管理场景中的各种资源，如模型、贴图和音效等。通过使用 shared_ptr 和 weak_ptr，可以有效地避免资源泄露和循环引用问题。

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

class GameResource {
public:
    int id;
    std::string type;
    GameResource(int id, std::string type) : id(id), type(type) {}

    void printInfo() const {
        std::cout << "Resource ID: " << id << " Type: " << type << std::endl;
    }

    ~GameResource() {
        std::cout << "Resource ID " << id << " Type " << type << " destroyed." << std::endl;
    }
};

class ResourceManager {
public:
    void addResource(int id, std::string type) {
        // 添加资源到管理器
        resources.push_back(std::make_shared<GameResource>(id, type));
    }

    void removeResource(int id) {
        // 移除资源
        for (auto it = resources.begin(); it != resources.end(); ++it) {
            if ((*it)->id == id) {
                resources.erase(it);
                break;
            }
        }
    }

    std::weak_ptr<GameResource> getResource(int id) const {
        // 获取资源
        for (auto& resource : resources) {
            if (resource->id == id) {
                return resource;
            }
        }
        return {};
    }

private:
    std::vector<std::shared_ptr<GameResource>> resources;
};

int main() {
    ResourceManager manager;

    manager.addResource(1, "model");
    manager.addResource(2, "texture");
    manager.addResource(3, "sound");

    // 获取资源
    auto weakPtr1 = manager.getResource(1);
    auto weakPtr2 = manager.getResource(2);

    if (auto sharedPtr1 = weakPtr1.lock()) {
        sharedPtr1->printInfo();
    }

    if (auto sharedPtr2 = weakPtr2.lock()) {
        sharedPtr2->printInfo();
    }

    // 移除资源
    manager.removeResource(1);

    // 再次检查资源是否仍然有效
    if (auto sharedPtr1 = weakPtr1.lock()) {
        sharedPtr1->printInfo();
    } else {
        std::cout << "Resource 1 is no longer valid." << std::endl;
    }

    return 0;
}

总结与扩展阅读

智能指针的使用心得

使用智能指针可以显著提高代码的健壮性和可维护性。通过合理选择和使用不同的智能指针类型，可以有效地管理资源生命周期，避免内存泄漏和悬挂指针访问。智能指针不仅简化了内存管理，还提高了代码的可读性和可维护性，使得代码更加安全可靠。

推荐进一步学习的资源

在线课程：可以在慕课网学习C++高级编程课程，深入理解智能指针及其他高级特性。
官方文档：参考C++标准库官方文档，了解智能指针的详细用法和实现原理。
编程社区：在C++编程社区中提问和讨论，获取更多实践经验和解决方案。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

料青山看我应如是

手记
篇

粉丝

97

获赞与收藏

354

关注作者，订阅最新文章

阅读免费教程

Android Studio 编辑器教程

40个小节 11846 244

后端通用面试教程

41个小节 30583 343

网络编程入门教程

20个小节 12561 237

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

C++智能指针入门教程

基本用法

特性与限制

基本用法

使用场景与注意事项

基本用法

使用场景

解决方案与最佳实践

阅读免费教程