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

new

delete

std::unique_ptr

std::shared_ptr

Product

ConcreteProductA

ConcreteProductB

#include <iostream>
#include <memory> // For std::unique_ptr and std::shared_ptr
#include <string>

// 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<Product> createProductUnique(ProductType type) {
    switch (type) {
        case ProductType::TypeA:
            // 使用std::make_unique更安全高效
            return std::make_unique<ConcreteProductA>();
        case ProductType::TypeB:
            return std::make_unique<ConcreteProductB>();
        default:
            return nullptr; // 或者抛出异常
    }
}

// 6. 工厂函数：返回shared_ptr (如果需要共享所有权)
std::shared_ptr<Product> createProductShared(ProductType type) {
    switch (type) {
        case ProductType::TypeA:
            // 使用std::make_shared更安全高效
            return std::make_shared<ConcreteProductA>();
        case ProductType::TypeB:
            return std::make_shared<ConcreteProductB>();
        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<Product> product3 = createProductShared(ProductType::TypeB);
    if (product3) {
        product3->use();
    }

    // shared_ptr共享所有权
    std::shared_ptr<Product> 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

std::unique_ptr

std::unique_ptr

// 示例：unique_ptr工厂的使用
void processProduct(std::unique_ptr<Product> 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

// 示例：shared_ptr工厂的使用
std::vector<std::shared_ptr<Product>> 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 清空或元素被移除时，对象才可能被销毁

shared_ptr