智能指针如何与工厂模式配合返回智能指针的工厂函数实现

P粉602998670

发布时间：2025-08-02 10:36:02

300人浏览过

来源于php中文网

原创

智能指针与工厂模式结合的核心在于通过工厂函数返回智能指针（如std::unique_ptr或std::shared_ptr）以实现对象创建与生命周期管理的职责分离。1. 工厂函数负责根据参数动态创建派生类实例并封装进智能指针，客户端无需手动释放内存；2. std::unique_ptr适用于单一所有权场景，提供高效、安全的对象管理，且推荐使用std::make_unique创建；3. std::shared_ptr用于共享所有权，支持多个智能指针共同管理对象生命周期，需注意引用计数开销、循环引用及线程安全问题，并建议使用std::make_shared提升性能；4. 这种设计提升了代码健壮性、异常安全性与可维护性，同时简化了客户端逻辑。

智能指针如何与工厂模式配合返回智能指针的工厂函数实现

智能指针与工厂模式的结合，说白了，就是把对象创建的复杂性（工厂模式的职责）和对象生命周期管理（智能指针的职责）这两大块，非常优雅地整合到一起。工厂负责“生孩子”，智能指针负责“养孩子”，确保孩子生出来有人管，死了有人收尸，不留烂摊子。这解决了传统C++里手动

new

和

delete

带来的内存泄露、野指针等一系列让人头疼的问题，让代码更健壮，也更省心。

解决方案

要实现一个返回智能指针的工厂函数，核心思想就是让工厂函数不再返回原始指针，而是返回一个

std::unique_ptr

或

std::shared_ptr

。这样，当工厂函数返回对象时，所有权（或共享所有权）就立即被智能指针接管，客户端代码无需关心内存释放的问题。

我们通常会有一个基类或接口，以及一些具体的派生类。工厂函数根据传入的类型参数，动态创建对应的派生类实例，并将其包装在智能指针中返回。

举个例子，假设我们有一个

Product

接口和两个实现类

ConcreteProductA

、

ConcreteProductB

：

#include 
#include  // For std::unique_ptr and std::shared_ptr
#include 

// 1. 定义产品接口
class Product {
public:
    virtual ~Product() = default;
    virtual void use() const = 0;
};

// 2. 实现具体产品A
class ConcreteProductA : public Product {
public:
    ConcreteProductA() {
        std::cout << "ConcreteProductA created." << std::endl;
    }
    ~ConcreteProductA() override {
        std::cout << "ConcreteProductA destroyed." << std::endl;
    }
    void use() const override {
        std::cout << "Using ConcreteProductA." << std::endl;
    }
};

// 3. 实现具体产品B
class ConcreteProductB : public Product {
public:
    ConcreteProductB() {
        std::cout << "ConcreteProductB created." << std::endl;
    }
    ~ConcreteProductB() override {
        std::cout << "ConcreteProductB destroyed." << std::endl;
    }
    void use() const override {
        std::cout << "Using ConcreteProductB." << std::endl;
    }
};

// 4. 定义产品类型枚举
enum class ProductType {
    TypeA,
    TypeB
};

// 5. 工厂函数：返回unique_ptr
std::unique_ptr createProductUnique(ProductType type) {
    switch (type) {
        case ProductType::TypeA:
            // 使用std::make_unique更安全高效
            return std::make_unique();
        case ProductType::TypeB:
            return std::make_unique();
        default:
            return nullptr; // 或者抛出异常
    }
}

// 6. 工厂函数：返回shared_ptr (如果需要共享所有权)
std::shared_ptr createProductShared(ProductType type) {
    switch (type) {
        case ProductType::TypeA:
            // 使用std::make_shared更安全高效
            return std::make_shared();
        case ProductType::TypeB:
            return std::make_shared();
        default:
            return nullptr; // 或者抛出异常
    }
}

/*
int main() {
    // 使用unique_ptr工厂
    std::cout << "--- Using unique_ptr factory ---" << std::endl;
    auto product1 = createProductUnique(ProductType::TypeA);
    if (product1) {
        product1->use();
    }

    // unique_ptr所有权转移
    auto product2 = std::move(product1); // product1现在为空
    if (product2) {
        product2->use();
    }

    // 使用shared_ptr工厂
    std::cout << "\n--- Using shared_ptr factory ---" << std::endl;
    std::shared_ptr product3 = createProductShared(ProductType::TypeB);
    if (product3) {
        product3->use();
    }

    // shared_ptr共享所有权
    std::shared_ptr product4 = product3; // product3和product4共享同一个对象
    std::cout << "product3 use_count: " << product3.use_count() << std::endl;
    std::cout << "product4 use_count: " << product4.use_count() << std::endl;

    // 当所有shared_ptr离开作用域时，对象才会被销毁
    return 0;
}
*/

这个例子展示了两种常见的智能指针返回方式。选择

unique_ptr

还是

shared_ptr

，取决于你的设计意图：是单一所有权还是共享所有权。

为什么工厂模式与智能指针是天作之合？

我个人觉得，这简直是解放生产力啊！你想想看，在没有智能指针的年代，工厂函数返回一个原始指针，然后客户端代码就得小心翼翼地去

delete

它。稍微不注意，比如忘了

delete

，或者在

delete

之前抛了异常，内存就泄露了。这事儿吧，写起来麻烦，维护起来更麻烦，调试起来更是噩梦。

而智能指针介入后，整个局面就变了。工厂函数创建完对象，直接封装进

unique_ptr

或

shared_ptr

，然后返回。客户端拿到手的是一个“自带回收机制”的对象。它的生命周期完全由智能指针管理，一旦智能指针超出作用域，或者不再有引用指向，对象就会自动销毁。

这带来的好处是显而易见的：

内存安全：彻底告别手动
```
delete
```
，大大降低内存泄露和野指针的风险。这省去了多少心力去追踪内存问题啊！
异常安全：如果在对象创建过程中，或者在工厂函数返回后，客户端代码中途抛出异常，智能指针也能保证已分配的资源被正确释放。因为智能指针的析构函数会在栈展开时被调用。
职责分离：工厂模式专注于“如何创建对象”的复杂逻辑（比如根据配置创建不同类型的对象，或者进行复杂的初始化），而智能指针则专注于“如何管理对象生命周期”。两者各司其职，代码结构更清晰。
简化客户端代码：客户端拿到智能指针后，可以直接使用，无需关心底层是
```
new
```
出来的，也不用操心什么时候
```
delete
```
。这让客户端代码变得非常简洁和专注。

说实话，这就像是，以前你买个电器，还得自己去研究怎么处理废电池；现在你买个电器，电池用完直接扔，商家会帮你回收，多省事儿！

SEEK.ai

AI驱动的智能数据解决方案，询问您的任何数据并立即获得答案

下载

返回std::unique_ptr的工厂函数：何时选择以及注意事项

当你的设计意图是单一所有权时，也就是一个对象在任何时候都只归一个“主人”所有，那么返回

std::unique_ptr

的工厂函数就是你的首选。这种情况非常普遍，比如你创建一个配置文件解析器，或者一个网络连接对象，通常它们都只属于创建它们的那部分代码。

何时选择

std::unique_ptr

：

独占所有权：对象在生命周期内只有一个明确的拥有者。
资源管理：除了内存，
```
unique_ptr
```
也可以管理文件句柄、网络套接字等独占性资源。
性能敏感：
```
unique_ptr
```
没有引用计数开销，性能上更接近原始指针。
多态销毁：通过基类指针销毁派生类对象时，
```
unique_ptr
```
能正确调用派生类的析构函数。

注意事项：

使用
std::make_unique
：在C++14及以后，总是优先使用
```
std::make_unique
```
来创建
```
unique_ptr
```
。它不仅代码更简洁，还能提供异常安全保证，避免了
```
new
```
表达式可能带来的潜在内存泄露风险（例如，
```
new
```
和智能指针构造函数之间的操作失败）。
返回方式：工厂函数返回
```
std::unique_ptr
```
时，通常是按值返回。
```
unique_ptr
```
支持移动语义，所以返回时会触发移动构造，效率很高。客户端通过
```
auto
```
接收，即可获得所有权。
所有权转移：
```
unique_ptr
```
不能被复制，但可以被移动。这意味着你不能简单地将一个
```
unique_ptr
```
赋值给另一个
```
unique_ptr
```
，但可以通过
```
std::move
```
来显式地转移所有权。一旦所有权转移，原
```
unique_ptr
```
就会变为空。
裸指针获取：虽然不推荐，但你可以通过
```
.get()
```
方法获取原始指针。不过，一旦你获取了原始指针并将其传递给其他函数，就必须确保原始指针不会被不当使用，例如被
```
delete
```
两次，或者在
```
unique_ptr
```
销毁后仍然被访问。

// 示例：unique_ptr工厂的使用
void processProduct(std::unique_ptr p) {
    if (p) {
        p->use();
    }
    // p离开作用域时，Product对象被销毁
}

// 在某个函数中调用工厂
auto my_product = createProductUnique(ProductType::TypeA);
if (my_product) {
    // my_product拥有ProductA的所有权
    my_product->use();
    // 转移所有权到另一个函数
    processProduct(std::move(my_product)); // my_product现在为空
}
// 这里my_product已经为空，ProductA的销毁由processProduct函数负责

记住，

unique_ptr

的哲学就是“独占”，一旦你理解并接受这一点，它的使用就会变得非常直观。

返回std::shared_ptr的工厂函数：适用场景与权衡

当你的设计需要共享所有权时，也就是一个对象可能同时被多个“主人”引用，并且只有当所有引用都消失时，对象才应该被销毁，那么返回

std::shared_ptr

的工厂函数就派上用场了。这种场景在很多地方都会遇到，比如缓存系统、观察者模式中的主题对象，或者图形场景中的共享资源。

何时选择

std::shared_ptr

：

共享所有权：多个
```
shared_ptr
```
可以共同管理同一个对象的生命周期。
缓存机制：当对象被放入缓存，同时又被客户端使用时，
```
shared_ptr
```
可以确保对象在被缓存和被使用期间都不会被提前销毁。
循环引用：虽然
```
shared_ptr
```
本身可能导致循环引用问题（可以通过
```
std::weak_ptr
```
解决），但它依然是实现共享所有权的主要工具。
复杂生命周期：当对象的生命周期难以通过单一所有权模型来界定时。

权衡与注意事项：

引用计数开销：
```
shared_ptr
```
内部维护一个引用计数器。每次拷贝、赋值都会增加或减少引用计数，这会带来一定的性能开销。与
```
unique_ptr
```
相比，它不是零开销抽象。
使用
std::make_shared
：和
```
make_unique
```
类似，强烈推荐使用
```
std::make_shared
```
来创建
```
shared_ptr
```
。它能将对象的内存和引用计数器的内存一次性分配，减少了内存碎片，提高了效率，并且提供了异常安全。
循环引用：这是
```
shared_ptr
```
最常见的陷阱。如果对象A持有
```
shared_ptr
```
指向B，同时B也持有
```
shared_ptr
```
指向A，那么它们的引用计数永远不会降到零，导致内存泄露。解决办法是使用
```
std::weak_ptr
```
来打破循环，
```
weak_ptr
```
不增加引用计数，只提供对对象的弱引用。
线程安全：
```
shared_ptr
```
本身的引用计数操作是线程安全的（原子操作），但它所指向的对象本身的数据成员的访问并不是线程安全的。如果你在多线程环境下共享对象，仍然需要额外的同步机制来保护对象的数据。

// 示例：shared_ptr工厂的使用
std::vector> cached_products;

void cacheAndUseProduct(ProductType type) {
    auto product_from_factory = createProductShared(type);
    if (product_from_factory) {
        product_from_factory->use();
        cached_products.push_back(product_from_factory); // 缓存一份，增加引用计数
        std::cout << "Product cached. Current ref count: " << product_from_factory.use_count() << std::endl;
    }
}

// 在某个函数中调用
// cacheAndUseProduct(ProductType::TypeB);
// 此时 product_from_factory 离开作用域，但因为 cached_products 仍持有引用，对象不会被销毁
// 只有当 cached_products 清空或元素被移除时，对象才可能被销毁

选择