C++ 智能指针 unique_ptr

最新推荐文章于 2025-07-04 00:00:00 发布
原创 最新推荐文章于 2025-07-04 00:00:00 发布 · 2k 阅读 · 30 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

1. unique_ptr 基本概念

std::unique_ptr 是 C++ 标准库中一种智能指针，用于确保对象拥有唯一的所有权。也就是说，某一时刻，只有一个 unique_ptr 能管理特定对象的生命周期，当 unique_ptr 被销毁时，所指向的对象也随之销毁。它主要用于解决手动管理动态内存带来的问题，防止内存泄漏和未定义行为。

特点：
  • 独占所有权：对象的生命周期只能被一个 unique_ptr 管理，无法进行复制（复制会导致编译错误）。
  • 自动析构：当 unique_ptr 离开作用域或者被重置时，它会自动释放所管理的对象。
  • 轻量：与裸指针相比，unique_ptr 只额外持有一个指向所管理对象的指针，开销极小。

2. 基本用法

#include <iostream>
#include <memory>

class Test {
public:
    Test() { std::cout << "Test created\n"; }
    ~Test() { std::cout << "Test destroyed\n"; }
    void show() { std::cout << "Test::show\n"; }
};

int main() {
    std::unique_ptr<Test> ptr1(new Test());  // 创建 unique_ptr 管理 Test 对象
    ptr1->show();  // 访问 Test 对象的方法
    // Test 对象将在 ptr1 作用域结束时自动销毁
}
输出：

Test created
Test::show
Test destroyed

如上所示：初始化方法共两种：

std::unique_ptr<Test> ptr1(new Test());

std::unique_ptr<Test> ptr2 = std::make_unique<Test>();

在上面的例子中，当 ptr1 离开作用域时，Test 对象会自动被销毁。

3. 转移所有权

unique_ptr 不允许复制，但可以通过 std::move 将所有权转移。

#include <iostream>
#include <memory>

class Test {
public:
    Test() { std::cout << "Test created\n"; }
    ~Test() { std::cout << "Test destroyed\n"; }
    void show() { std::cout << "Test::show\n"; }
};

int main() {
    std::unique_ptr<Test> ptr1(new Test());
    std::unique_ptr<Test> ptr2 = std::make_unique<Test>();

    // 转移所有权
    ptr2 = std::move(ptr1);  // 现在 ptr1 不再拥有 Test 对象
    if (!ptr1) {
        std::cout << "ptr1 is null\n";
    }
    ptr2->show();
}

输出：

Test created
Test created
Test destroyed
ptr1 is null
Test::show
Test destroyed

4. 自定义删除器

unique_ptr 支持自定义删除器，以处理非默认的对象销毁行为。例如，管理通过 fopen 打开的文件：

#include <cstdio>
#include <memory>

int main() {
    std::unique_ptr<FILE, decltype(&fclose)> filePtr(fopen("test.txt", "w"), &fclose);
    if (filePtr) {
        std::fprintf(filePtr.get(), "Hello, World!");
    }
}

自定义删除器在定义 unique_ptr 时需要指定删除函数的类型。

5. 常见应用场景

  1. RAII（资源获取即初始化）：使用 unique_ptr 来管理资源（如动态内存、文件句柄、锁等），确保资源在不再使用时自动释放。
  2. 动态分配的对象管理：避免手动 new 和 delete 引发的内存泄漏问题。
  3. 实现工厂模式：工厂模式中返回对象的所有权可以通过 unique_ptr 传递，以确保对象生命周期的安全管理。
  4. 函数返回动态对象：函数返回动态分配的对象时，可以返回 unique_ptr，确保调用者获取对象所有权，并避免内存泄漏。

6. 注意事项和常见坑

6.1 禁止复制

unique_ptr 无法复制，如果尝试这样做，编译器会报错。

std::unique_ptr<Test> ptr1(new Test());
std::unique_ptr<Test> ptr2 = ptr1;  // 错误：unique_ptr 不允许复制

6.2 不能使用数组类型的 new[]

unique_ptr 需要使用 std::unique_ptr<T[]> 进行数组管理，如果直接用 std::unique_ptr<T> 处理数组，会导致内存释放错误。

std::unique_ptr<int[]> arr(new int[10]);  // 正确：用 unique_ptr 管理动态数组

6.3 必须小心自定义删除器的类型

在使用自定义删除器时，必须确保删除器的类型与 unique_ptr 定义时一致，否则可能会导致删除行为不正确，甚至内存泄漏。

6.4 避免不必要的内存分配

unique_ptr 适用于管理堆内存对象，但如果对象不需要动态分配，则使用局部对象更高效。

std::unique_ptr<int> ptr(new int(5));  // 动态分配
int localVar = 5;  // 更高效

6.5 小心 std::move 后的空指针访问

在将 unique_ptr 传递或转移所有权后，需要检查指针是否为空，避免解引用空指针。

std::unique_ptr<Test> ptr1(new Test());
std::unique_ptr<Test> ptr2 = std::move(ptr1);
ptr1->show();  // 错误：ptr1 为空，不能再使用

6.6 避免循环引用

虽然 unique_ptr 本身不支持共享所有权，但如果与 std::shared_ptr 混用时，必须小心避免循环引用，防止内存泄漏。比如 shared_ptr 与 unique_ptr 之间相互指向时，需要特别注意删除器和生命周期的管理。

7. 工厂模式

工厂模式是一种创建型设计模式，用于在代码中提供一种接口来创建对象，而无需指定它们的具体类。其核心思想是将对象的创建和使用解耦，允许子类决定要实例化的具体类。工厂模式可以分为简单工厂、工厂方法和抽象工厂三种不同的变体。

在工厂模式中，std::unique_ptr 是非常常见的选择，因为工厂创建的对象通常是在堆上分配的，而 unique_ptr 能确保这些对象在不再需要时被自动销毁，避免内存泄漏。下面我们详细讲解工厂模式中的 unique_ptr 使用点。

1. 简单工厂模式

简单工厂模式中，工厂类通过一个静态方法根据传入的参数创建并返回对象。工厂的使用者不需要关心具体的类细节，只需通过工厂获取对象。

在简单工厂模式中使用 std::unique_ptr 可以确保工厂创建的对象不需要手动管理内存，自动销毁。

示例：

#include <iostream>
#include <memory>

// 产品基类
class Product {
public:
    virtual void use() = 0;
    virtual ~Product() = default;
};

// 具体产品A
class ProductA : public Product {
public:
    void use() override {
        std::cout << "Using Product A" << std::endl;
    }
};

// 具体产品B
class ProductB : public Product {
public:
    void use() override {
        std::cout << "Using Product B" << std::endl;
    }
};

// 工厂类
class SimpleFactory {
public:
    // 工厂方法：返回指向Product的unique_ptr
    static std::unique_ptr<Product> createProduct(const std::string &type) {
        if (type == "A") {
            return std::make_unique<ProductA>();  // 创建并返回ProductA
        }
        else if (type == "B") {
            return std::make_unique<ProductB>();  // 创建并返回ProductB
        }
        else {
            return nullptr;  // 未知类型，返回空指针
        }
    }
};

int main() {
    // 使用工厂创建 Product A
    std::unique_ptr<Product> productA = SimpleFactory::createProduct("A");
    productA->use();

    // 使用工厂创建 Product B
    std::unique_ptr<Product> productB = SimpleFactory::createProduct("B");
    productB->use();

    return 0;
}

使用 unique_ptr 的好处：

  • 自动内存管理：工厂创建的对象无需手动释放，unique_ptr 会在其离开作用域时自动释放内存，防止内存泄漏。
  • 独占所有权：unique_ptr 确保了工厂创建的对象只有调用者能使用，防止了多指针共享同一资源可能带来的问题。
2. 工厂方法模式

工厂方法模式是一种允许子类决定创建哪个类实例的设计模式。工厂方法提供一个接口来创建对象，而将具体的对象创建推迟到子类。

在这种模式中，每个具体的工厂会返回一个具体类的 std::unique_ptr，由调用者负责接管所有权。

示例：

#include <iostream>
#include <memory>

// 产品基类
class Product {
public:
    virtual void use() = 0;
    virtual ~Product() = default;
};

// 具体产品A
class ProductA : public Product {
public:
    void use() override {
        std::cout << "Using Product A" << std::endl;
    }
};

// 具体产品B
class ProductB : public Product {
public:
    void use() override {
        std::cout << "Using Product B" << std::endl;
    }
};

// 工厂基类
class Factory {
public:
    virtual std::unique_ptr<Product> createProduct() = 0;  // 工厂方法，返回unique_ptr
    virtual ~Factory() = default;
};

// 具体工厂A，负责创建ProductA
class FactoryA : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ProductA>();  // 创建并返回ProductA
    }
};

// 具体工厂B，负责创建ProductB
class FactoryB : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ProductB>();  // 创建并返回ProductB
    }
};

int main() {
    std::unique_ptr<Factory> factoryA = std::make_unique<FactoryA>();  // 创建工厂A
    std::unique_ptr<Product> productA = factoryA->createProduct();  // 创建ProductA
    productA->use();

    std::unique_ptr<Factory> factoryB = std::make_unique<FactoryB>();  // 创建工厂B
    std::unique_ptr<Product> productB = factoryB->createProduct();  // 创建ProductB
    productB->use();

    return 0;
}

使用 unique_ptr 的好处：

  • 灵活性和扩展性：子类可以方便地扩展，添加新的工厂来创建不同的产品，而不需要更改现有的代码。
  • 内存管理安全：与简单工厂模式相同，unique_ptr 在创建产品时可以确保对象在使用结束后自动销毁。
3. 抽象工厂模式

抽象工厂模式提供了一组相关或依赖对象的创建接口，而无需指定具体的类。它通常用于创建一系列产品，这些产品可以由不同的工厂类生成。

unique_ptr 在抽象工厂模式中也发挥了重要作用，确保复杂对象树中的内存安全和自动释放。

示例：

#include <iostream>
#include <memory>

// 产品基类
class ProductA {
public:
    virtual void useA() = 0;
    virtual ~ProductA() = default;
};

class ProductB {
public:
    virtual void useB() = 0;
    virtual ~ProductB() = default;
};

// 具体产品A1和A2
class ConcreteProductA1 : public ProductA {
public:
    void useA() override {
        std::cout << "Using Product A1" << std::endl;
    }
};

class ConcreteProductA2 : public ProductA {
public:
    void useA() override {
        std::cout << "Using Product A2" << std::endl;
    }
};

// 具体产品B1和B2
class ConcreteProductB1 : public ProductB {
public:
    void useB() override {
        std::cout << "Using Product B1" << std::endl;
    }
};

class ConcreteProductB2 : public ProductB {
public:
    void useB() override {
        std::cout << "Using Product B2" << std::endl;
    }
};

// 抽象工厂基类
class AbstractFactory {
public:
    virtual std::unique_ptr<ProductA> createProductA() = 0;
    virtual std::unique_ptr<ProductB> createProductB() = 0;
    virtual ~AbstractFactory() = default;
};

// 具体工厂1，创建A1和B1
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<ProductA> createProductA() override {
        return std::make_unique<ConcreteProductA1>();  // 创建ProductA1
    }

    std::unique_ptr<ProductB> createProductB() override {
        return std::make_unique<ConcreteProductB1>();  // 创建ProductB1
    }
};

// 具体工厂2，创建A2和B2
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<ProductA> createProductA() override {
        return std::make_unique<ConcreteProductA2>();  // 创建ProductA2
    }

    std::unique_ptr<ProductB> createProductB() override {
        return std::make_unique<ConcreteProductB2>();  // 创建ProductB2
    }
};

int main() {
    // 使用具体工厂1创建产品
    std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();
    std::unique_ptr<ProductA> productA1 = factory1->createProductA();
    std::unique_ptr<ProductB> productB1 = factory1->createProductB();
    productA1->useA();
    productB1->useB();

    // 使用具体工厂2创建产品
    std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();
    std::unique_ptr<ProductA> productA2 = factory2->createProductA();
    std::unique_ptr<ProductB> productB2 = factory2->createProductB();
    productA2->useA();
    productB2->useB();

    return 0;
}

使用 unique_ptr 的好处：

  • 抽象产品组管理：抽象工厂模式中，工厂创建一组相关对象，unique_ptr 确保创建的每个对象都有明确的生命周期管理。
  • 内存管理一致性：通过 unique_ptr，创建的每个产品在离开作用域时自动释放，减少内存管理的复杂性。
C++11中的智能指针unique_ptr、shared_ptr和weak_ptr详解
dvlinker的技术专栏
05-28 3万+
详细讲解C++11中引入的智能指针unique_ptr、shared_ptr和weak_ptr。
C++智能指针unique_ptr
weixin_44651073的博客
02-26 993
智能指针unique_ptr语法详解
C++ unique_ptr（智能指针，独占所有权）
Dontla的博客
09-03 1258
在现代 C++（C++11 及以后版本）中，智能指针是管理动态分配内存的首选方式。unique_ptr是一种智能指针，它提供了对单一对象的独占所有权语义，确保无其他智能指针同时拥有同一原始指针。这种特性使得unique_ptr成为资源管理中保证资源释放和避免内存泄漏的强大工具。在某些情况下，可能需要对资源进行特殊的清理操作，unique_ptr支持自定义删除器，以满足这种需求。unique_ptr。
C++智能指针之unique_ptr
CltCj的博客
11-26 8212
在C++中，动态内存的申请和释放是通过运算符：new 和 delete 进行管理的。其中 new 负责申请内存，delete负责释放内存。动态内存的使用很容易出现问题，这主要在于你需要保证在正确的时间释放内存，这是比较困难的，如果你忘记释放内存，就会造成内存泄露；有时在还有指针引用内存的情况下我们就释放了它，在这种情况下就会产生引用非法内存的指针。
C++11 unique_ptr 原理与详细教程
最新发布
码事漫谈
07-04 753
是 C++11 引入的智能指针，用于管理动态分配的内存资源，其核心特性是独占所有权——同一时间只能有一个unique_ptr指向特定对象。当unique_ptr离开作用域或被销毁时，它所管理的对象会自动释放，从而有效避免内存泄漏。// 自定义文件删除器if (fp) {// 使用自定义删除器的 unique_ptr// 离开作用域时自动调用 FileDeleter 关闭文件return 0;delete p;
C++ unique_ptr
baidu_41388533的博客
06-04 1001
原文链接：智能指针之unique_ptr 一、unique_ptr类 头文件：#include<memory> 智能指针，是一个模板。创建智能指针时，必须提供指针所指的类型 与shared_ptr的不同之处： shared_ptr所指向的对象可以有多个其他shared_ptr智能指针 而unique_ptr所指向的对象只能有一个unique_ptr指针，也就是自己。当unique_ptr被销毁时，它所指向的对象也被销毁 二、unique_ptr类的初始化 unique_ptr指针
c++智能指针（3） -- unique_ptr
weixin_68026222的博客
04-15 2749
unique_ptr p1(new 空间);// 类型: 智能指针指向的类型，空间：智能指针管理的空间// 创建一个p1的智能指针对象，其指向int类型的数据，动态开辟一个int类型的空间作为参数(其内部的指针会指向这片空间)// 创建一个空对象，指向int类型的数据，其内部的指针会指向NULL// 临时对象// 注意：这样会导致两个指针指向一片空间(我们尽量不要这么做)
C++智能指针unique_ptr 详解
sinat_31608641的博客
07-29 9292
一、智能指针 C++智能指针是包含重载运算符的类，其行为像常规指针，但智能指针能够及时、妥善地销毁动态分配的数据，并实现了明确的对象生命周期，因此更有价值。 二、unique_ptr 简介 unique_ptr 是从 C++ 11 开始，定义在 <memory> 中的智能指针(smart pointer)。它持有对对象的独有权，即两个 unique_ptr 不能指向一个对象，不能进行复制操作只能进行移动操作。 unique_ptr 之所以叫这个名字，是因为它智能指向一个对象，即当它指向其
C++智能指针之unique_ptr（保姆级教学）
qq_25218501的博客
09-07 4632
独占式指针（专属所有权），同一时刻，只能有一个unique_ptr指向这个对象；当指针销毁，指向的对象也销毁；因此该指针不支持拷贝和赋值操作，也不存在引用计数。
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
本文主要讨论了三种智能指针：`shared_ptr`、`unique_ptr`和`weak_ptr`。 首先，`shared_ptr`是引用计数型智能指针，它维护了一个内部的引用计数，用于跟踪有多少个`shared_ptr`实例指向同一对象。当创建一个新的`...
C++11智能指针中的 unique_ptr实例详解
08-19
《C++11智能指针中的unique_ptr实例详解》 C++11引入了智能指针，其中的unique_ptr是一种非常重要的智能指针类型。它以其“独特性”和“唯一性”为特点，提供了对对象所有权的严格管理，确保了资源在不再需要时能够...
C++ 智能指针unique_ptr、shared_ptr、weak_ptr详解（包含代码示例）
Warren++的博客
05-19 1371
C++ 智能指针unique_ptr、shared_ptr、weak_ptr详解（包含代码示例）
C++11之 unique_ptr
绝知此事要躬行
08-24 3967
原文地址为：http://www.drdobbs.com/cpp/c11-uniqueptr/240002708 在C++11中加入了很多的新特性，unique_ptr一枝独秀，对于动态分配的内存对象，它简单有效。虽然它不是万能的，但是它做的已经够好了：利用简单的语法便可以管理动态分配的对象。 基本语法： unique_ptr 是一个模板类，你可以很简单地构造一个unique_ptr
c++ 智能指针 -- unique_ptr
Timeinsist的博客
01-31 289
1.1 基本语义 c++11 引入unique_ptr智能指针，其对所管理资源拥有独占语义，不能多个多个unique_ptr管理同一个资源，离开其作用域时，会使用与其关联的删除器释放所管理的资源，c++14新增 make_unique工程方法来构造unique_ptr指针，从而避免在程序中显示使用new分配内存。 unique_ptr提供了两个构造函数，用来管理数组或者对象资源，其Deleter模板参数可以指定删除器，用来释放所管理的资源 template< class T, clas
C++智能指针——unique_ptr
weixin_43945471的博客
03-17 211
C++智能指针——unique_ptr
c++ 智能指针 unique_ptr
07-25
unique_ptr 是 C++ 中的智能指针，用于管理动态分配的对象。它的特点是独占资源，即同一时间只能有一个 unique_ptr 指向同一个对象，确保了资源的独占性和自动释放。当 unique_ptr 被销毁或者重置时，它所管理的对象也会被自动释放。 unique_ptr 的使用相对简单，可以通过以下方式创建一个 unique_ptr 对象： ``` std::unique_ptr<DataType> ptr = std::make_unique<DataType>(args); ``` 其中，DataType 是指向的对象类型，args 是用于构造 DataType 对象的参数。 unique_ptr 还提供了一些常用的操作方法，比如访问指针所指的对象可以使用 `*` 或者 `->` 运算符，重置指针可以使用 `reset` 方法，获取指针可以使用 `get` 方法等等。此外，unique_ptr 还支持移动语义，可以通过 `std::move` 将 unique_ptr 转移给其他 unique_ptr。 需要注意的是，unique_ptr 不支持复制语义，即不能直接进行复制操作。如果需要共享资源，可以考虑使用 shared_ptr。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值