C++如何使用make_unique创建unique_ptr对象

P粉602998670

发布时间：2025-09-08 09:44:02

967人浏览过

来源于php中文网

原创

std::make_unique 是 C++14 引入的辅助函数，用于安全、简洁地创建 std::unique_ptr 对象，避免手动使用 new 导致的内存泄漏和异常不安全问题。它通过单一表达式完成对象构造和智能指针初始化，确保异常安全，同时提升代码可读性。对于单个对象和数组类型均支持，但数组仅能接受大小参数并进行默认初始化；不支持自定义删除器，需直接使用 unique_ptr 构造函数处理特殊资源释放。在现代 C++ 中，std::make_unique 与 std::unique_ptr 共同实现 RAII 原则，确保资源的自动管理和程序的健壮性，是动态内存管理的推荐方式。

c++如何使用make_unique创建unique_ptr对象

std::make_unique

是 C++14 引入的一个非常实用的辅助函数，它提供了一种更安全、更简洁的方式来创建

std::unique_ptr

对象，有效地避免了直接使用

new

关键字可能带来的内存泄漏风险和重复代码，并且在异常安全方面表现更优。

解决方案

要使用

std::make_unique

创建

unique_ptr

对象，你只需要将你想要创建的类型作为模板参数，并将该类型的构造函数所需的所有参数直接传递给

make_unique

函数即可。

基本用法示例：

#include 
#include 
#include 

class MyObject {
public:
    MyObject() {
        std::cout << "MyObject default constructor called." << std::endl;
    }
    MyObject(int id, const std::string& name) : id_(id), name_(name) {
        std::cout << "MyObject constructor with args called: ID=" << id_ << ", Name=" << name_ << std::endl;
    }
    ~MyObject() {
        std::cout << "MyObject destructor called. ID=" << id_ << std::endl;
    }

    void greet() const {
        std::cout << "Hello from MyObject! ID=" << id_ << ", Name=" << name_ << std::endl;
    }

private:
    int id_ = 0;
    std::string name_ = "Default";
};

int main() {
    // 1. 创建一个不带参数的MyObject
    // 这等价于 std::unique_ptr(new MyObject());
    std::unique_ptr obj1 = std::make_unique();
    obj1->greet();

    std::cout << "--------------------" << std::endl;

    // 2. 创建一个带参数的MyObject
    // 这等价于 std::unique_ptr(new MyObject(101, "Alice"));
    std::unique_ptr obj2 = std::make_unique(101, "Alice");
    obj2->greet();

    std::cout << "--------------------" << std::endl;

    // 3. 创建一个MyObject数组
    // 这等价于 std::unique_ptr(new MyObject[3]);
    // 数组元素会被默认初始化或值初始化
    std::unique_ptr objArray = std::make_unique(3);
    // 访问数组元素，例如：objArray[0].greet();
    // 注意：对于数组，make_unique只接受大小参数，不接受单个元素的构造函数参数。
    // 如果需要自定义数组元素的构造，可能需要手动循环或考虑std::vector。

    std::cout << "Exiting main scope." << std::endl;
    // 当unique_ptr超出作用域时，它所管理的内存会被自动释放。
    return 0;
}

这段代码清晰地展示了

make_unique

如何简化了

unique_ptr

的创建过程。你不需要手动写

new

，也不需要关心

delete

，所有都由

unique_ptr

及其辅助函数搞定。

立即学习“C++免费学习笔记（深入）”；

为什么推荐使用

std::make_unique

而不是直接

new

来创建

unique_ptr

？

这其实是一个非常关键的问题，不仅仅是代码看起来更简洁那么简单，背后还有深层次的设计考量和实际益处。从我个人的经验来看，坚持使用

make_unique

几乎能避免掉一类常见的、难以发现的资源泄漏问题。

首先，最核心的原因是异常安全性。考虑这样一个场景：

void process(std::unique_ptr res, AnotherObject obj); // 假设AnotherObject构造函数可能抛异常

// 潜在问题代码：
process(std::unique_ptr(new Resource()), AnotherObject());

在

process

函数调用中，参数的评估顺序是不确定的。编译器可能会先执行

new Resource()

，然后执行

AnotherObject()

，最后才构造

std::unique_ptr

。如果

new Resource()

成功分配了内存，但紧接着

AnotherObject()

的构造函数抛出了异常，那么

std::unique_ptr

就永远没有机会被构造出来，自然也就无法接管并释放

new Resource()

分配的内存。结果就是，

Resource

对象发生了内存泄漏。

而使用

std::make_unique

，情况就完全不同了：

process(std::make_unique(), AnotherObject());

std::make_unique()

是一个单一的表达式，它要么完全成功（分配内存并构造

unique_ptr

），要么完全失败（如果

Resource

构造函数抛异常）。它确保了在

unique_ptr

构造完成之前，所有相关的内存分配和对象构造都已妥善处理。这样，即使

AnotherObject()

抛出异常，

unique_ptr

也已经成功接管了

Resource

的所有权，并在

process

函数调用失败时，通过栈展开机制，

unique_ptr

的析构函数会被调用，从而安全地释放内存。这大大增强了代码的健壮性。

其次，是代码的简洁性和可读性。对比

std::unique_ptr(new MyObject(arg1, arg2))

和

std::make_unique(arg1, arg2)

，后者显然更短，重复的类型名也少了一次。虽然这看起来是小事，但在大型项目中，这种累积的简洁性能够显著提升代码的可读性和维护效率。它减少了“仪式性”代码，让开发者能更专注于业务逻辑本身。

最后，虽然对

unique_ptr

来说影响不如

shared_ptr

那么大，但

make_unique

也避免了两次内存分配的可能性。

unique_ptr

本身通常不需要额外的控制块，但

make_unique

仍然将对象本身的内存分配和

unique_ptr

的构造过程封装在一个调用中，避免了手动

new

带来的潜在分离风险。

std::make_unique

在处理数组和自定义删除器时有什么需要注意的吗？

是的，

std::make_unique

在处理数组和自定义删除器时确实有一些特定的规则和限制，理解这些对于正确使用它至关重要。

处理数组：

std::make_unique

可以用来创建

unique_ptr

管理的动态数组。但它的语法和行为与单个对象的创建略有不同。

巨蟹星云网上商城

一套自助创建网上商店的软件系统，具有界面变幻多彩、功能强大，使用傻瓜化、运行自动化的特点，任何人基本上不用学习，都能快速创建自己的网上商店，用这套系统做一个购物网站，就象做填空题一样容易。采用「巨蟹星云」可以建立诸如：网上花店、网上化妆品店、网上服装店、网上书店、网上点卡店、网上成人用品店、网上玩具店、网上书店、网上手机店、网上数码产品销售店、网上保健品店、网上玩具店、网上车模店、网上音像制品店等

下载

当你需要创建数组时，类型参数应该是一个“数组类型”，并且需要提供数组的大小：

std::unique_ptr intArray = std::make_unique(10); // 创建一个包含10个int的数组
for (int i = 0; i < 10; ++i) {
    intArray[i] = i * 2;
}
// 当 intArray 超出作用域时，会自动调用 delete[] 释放内存

这里需要注意的关键点是：

类型声明：必须使用
```
T[]
```
而不是
```
T
```
。
构造函数参数：
```
make_unique
```
只接受一个参数，即数组的大小。它会使用默认构造函数（或值初始化）来初始化数组中的所有元素。这意味着你不能直接通过
```
make_unique
```
为数组中的每个元素传递不同的构造函数参数。如果你需要对数组的每个元素进行复杂的初始化，通常的做法是先创建一个
```
std::vector
```
，或者手动循环初始化
```
unique_ptr
```
管理的内存。
自动
delete[]
：
```
std::unique_ptr
```
会自动使用
```
delete[]
```
来释放内存，这正是我们期望的数组内存释放方式，避免了常见的
```
delete
```
vs
```
delete[]
```
错误。

处理自定义删除器：

这是

std::make_unique

的一个重要限制：它不支持自定义删除器。

std::make_unique

的设计目标是简化最常见的

unique_ptr

使用场景，即管理通过

new

分配的、需要通过

delete

或

delete[]

释放的内存。自定义删除器允许你指定一个非标准的资源释放机制（例如关闭文件句柄、释放操作系统资源等）。

如果你需要使用自定义删除器，你必须直接调用

std::unique_ptr

的构造函数，将自定义删除器作为模板参数和构造函数参数传递进去。

例如，管理一个

FILE*

资源：

#include  // For FILE, fopen, fclose

// 自定义删除器，用于关闭文件
struct FileCloser {
    void operator()(FILE* filePtr) const {
        if (filePtr) {
            std::cout << "Closing file..." << std::endl;
            fclose(filePtr);
        }
    }
};

int main() {
    // 错误：make_unique 不支持自定义删除器
    // std::unique_ptr pFile = std::make_unique(fopen("test.txt", "w"));

    // 正确：直接使用 unique_ptr 构造函数
    // 模板参数是 <类型, 删除器类型>
    // 构造函数参数是 (原始指针, 删除器对象)
    std::unique_ptr pFile(fopen("test.txt", "w"), FileCloser());

    if (pFile) {
        fprintf(pFile.get(), "Hello from unique_ptr!\n");
        std::cout << "File opened and written to." << std::endl;
    } else {
        std::cerr << "Failed to open file." << std::endl;
    }

    // 当 pFile 超出作用域时，FileCloser::operator() 会被调用
    std::cout << "Exiting main scope for custom deleter example." << std::endl;
    return 0;
}

在这个例子中，

FileCloser

是一个函数对象（或lambda表达式也可以），它定义了如何关闭

FILE*

。我们通过

std::unique_ptr(...)

明确地告诉

unique_ptr

要使用

FileCloser

来释放资源。所以，当遇到需要非标准释放逻辑的资源时，请记住

make_unique

并非万能，你需要回到

unique_ptr

的直接构造函数。

unique_ptr

和

make_unique

在现代 C++ 开发中扮演着怎样的角色？

在现代 C++ 开发中，

unique_ptr

和

make_unique

组合起来，几乎是动态内存管理的首选方案，它们在编写安全、高效且易于维护的代码方面扮演着不可或缺的角色。我甚至可以说，如果你还在频繁地直接使用

new

和

delete

来管理独占资源，那么你的 C++ 代码风格可能需要更新了。

它们的核心作用在于实现 RAII (Resource Acquisition Is Initialization) 原则。

unique_ptr

的设计哲学就是将资源的生命周期与对象的生命周期绑定。当

unique_ptr

对象被创建时，它获取资源（通过

new

或其他方式），当

unique_ptr

对象被销毁时（无论是正常退出作用域、抛出异常还是容器销毁），它都会自动释放所持有的资源。这种机制彻底解决了传统 C++ 中手动

new

delete

带来的两大痛点：内存泄漏和重复释放。

unique_ptr

的主要角色：

独占所有权管理：
```
unique_ptr
```
明确表示它对所指向的资源拥有独占所有权。这意味着同一时间只有一个
```
unique_ptr
```
可以指向某个特定资源。这种清晰的所有权语义极大地简化了代码的推理，避免了多个指针同时管理同一块内存可能导致的混乱和错误。
移动语义：
```
unique_ptr
```
是一个“只可移动，不可复制”的类型。这意味着你可以通过
```
std::move
```
将所有权从一个
```
unique_ptr
```
转移到另一个，但不能复制它。这种设计强制了所有权的单一性，使得资源转移变得安全且高效，特别是在函数返回动态分配对象时。
替代裸指针：在现代 C++ 中，裸指针（raw pointer）通常只用于非拥有性引用（non-owning reference）或者指向数组的迭代器，而不再是管理动态内存的主要工具。
```
unique_ptr
```
几乎完全取代了需要
```
delete
```
的裸指针。
异常安全：如前所述，
```
unique_ptr
```
配合
```
make_unique
```
提供了强大的异常安全性。无论程序执行路径如何，资源总能被正确释放。
Pimpl (Pointer to Implementation) 模式：
```
unique_ptr
```
是实现 Pimpl 模式的理想选择。通过
```
unique_ptr
```
作为类成员，可以隐藏类的实现细节，减少编译依赖，从而加快编译速度，并提供更好的二进制兼容性。

make_unique

的主要角色：

简化
unique_ptr
创建：它提供了一个简洁、一致的接口来创建
```
unique_ptr
```
。
提升异常安全：这是它最关键的贡献，通过单次操作保证了内存分配和
```
unique_ptr
```
构造的原子性，避免了资源泄漏。
鼓励最佳实践：
```
make_unique
```
的存在本身就在鼓励开发者采用更安全的
```
unique_ptr
```
创建方式，而不是回退到
```
new
```
。