使用智能指针优化int main() { Product* productA = new ProductA; Factory* factory1 = new Factory1; productA->setFactory(factory1); productA->Show(); return 0; }

可以使用C++11中的智能指针来优化这段代码，避免手动管理内存，提高代码的可读性和可维护性。具体的改写方法如下：

#include <memory> // 包含智能指针头文件

int main() {
    std::unique_ptr<Product> productA = std::make_unique<ProductA>(); // 使用std::unique_ptr代替原来的new操作
    std::unique_ptr<Factory> factory1 = std::make_unique<Factory1>();
    productA->setFactory(factory1.get()); // 调用get()方法获取智能指针持有的原始指针
    productA->Show();
    return 0;
}

在这段改写后的代码中，使用了std::unique_ptr智能指针来代替原来的new操作，std::unique_ptr具有独占所有权的特点，可以自动管理内存。同时，使用std::make_unique()函数创建智能指针可以避免手动管理内存的问题。在调用setFactory()方法时，使用get()方法获取智能指针持有的原始指针，以便传递给该方法使用。

相关问题

优化代码#include <iostream> #include<memory> #include<string> using namespace std; class Factory { public: virtual void makeProduct(string st) = 0; protected: Product* product; }; class Factory1 : public Factory { public: void makeProduct(string st) { cout << "工厂1创建"+st; } }; class Factory2 : public Factory { public: void makeProduct(string st) { cout << "工厂2创建"+st; } }; class Product{ public: void setFactory(Factory* fac) { this->factory = fac; }; virtual void Show() = 0; protected: Factory* factory; }; class ProductA : public Product { public: void Show() { string st="产品A"; this->factory->makeProduct(st); }; }; class ProductB : public Product { public: void Show() { string st = "产品B"; this->factory->makeProduct(st); } }; int main() { Factory* factory1; Product* productA; productA = new ProductA; factory1 = new Factory1; productA->setFactory(factory1); return 0; }

这段代码看起来已经是一个比较完整的工厂模式了，不过还有一些可以优化的地方。

1. 使用工厂函数代替工厂类

工厂类在这里只有一个纯虚函数，可以直接使用函数来代替。

2. 使用智能指针避免内存泄漏

在代码中使用了 new 操作符来分配内存，需要手动释放，容易造成内存泄漏。可以使用智能指针来自动管理内存，避免这个问题。

3. 将 string 字符串传参改为 const 引用

在代码中，每次传递 string 字符串时都会进行复制，可以使用 const 引用来避免这个问题。

下面是优化后的代码：

#include <iostream>
#include <memory>

using namespace std;

class Product {
public:
    virtual void Show() = 0;
};

class ProductA : public Product {
public:
    void Show() override {
        cout << "产品A" << endl;
    }
};

class ProductB : public Product {
public:
    void Show() override {
        cout << "产品B" << endl;
    }
};

using FactoryFunction = unique_ptr<Product> (*)();

unique_ptr<Product> Factory1() {
    return make_unique<ProductA>();
}

unique_ptr<Product> Factory2() {
    return make_unique<ProductB>();
}

int main() {
    auto productA = Factory1();
    auto productB = Factory2();
    productA->Show();
    productB->Show();
    return 0;
}

在优化后的代码中，使用了智能指针来管理内存，使用了工厂函数来代替工厂类，并且将传递字符串的方式改为了 const 引用。这样可以更好地提高代码的可读性和可维护性。

异常原因#include <iostream> #include<memory> #include<string> using namespace std; class Product { public: virtual void Creat() = 0; }; class ProductA : public Product { public: void Creat() { cout << "创建产品A"; }; }; class ProductB : public Product { public: void Creat() { cout << "创建产品B"; } }; class Factory { public: virtual void makeProduct() = 0; void setProduct(char type_of_product) { if (type_of_product == 'a'){ unique_ptr<Product> productA = make_unique<ProductA>(); this->product = productA.get(); } }; protected: Product* product; }; class Factory1 : public Factory { public: void makeProduct() { cout << "工厂1："; this->product->Creat(); } }; class Factory2 : public Factory { public: void makeProduct() { cout << "工厂2："; this->product->Creat(); } }; int main() { unique_ptr<Product> productA = make_unique<ProductA>(); unique_ptr<Factory> factory1 = make_unique<Factory1>(); factory1->setProduct('A'); factory1->makeProduct(); return 0; }

这份代码中存在一些问题：

1. `Factory::setProduct()` 中只有对产品A的处理，没有对产品B的处理。

2. `Factory::product` 指针没有进行初始化，可能会导致程序崩溃。

3. `unique_ptr<Factory> factory1 = make_unique<Factory1>();` 中的 `Factory1` 类没有定义默认构造函数，因此需要手动提供一个构造函数。

以下是修改后的代码：

#include <iostream>
#include <memory>
#include <string>

using namespace std;

class Product {
public:
    virtual void Creat() = 0;
};

class ProductA : public Product {
public:
    void Creat() {
        cout << "创建产品A";
    };
};

class ProductB : public Product {
public:
    void Creat() {
        cout << "创建产品B";
    }
};

class Factory {
public:
    virtual void makeProduct() = 0;
    virtual ~Factory() {}
    void setProduct(char type_of_product) {
        if (type_of_product == 'a') {
            unique_ptr<Product> productA = make_unique<ProductA>();
            this->product = productA.get();
        }
        else if (type_of_product == 'b') {
            unique_ptr<Product> productB = make_unique<ProductB>();
            this->product = productB.get();
        }
    };
protected:
    Product* product = nullptr;
};

class Factory1 : public Factory {
public:
    Factory1() {}
    void makeProduct() {
        cout << "工厂1：";
        if (product) {
            product->Creat();
        }
        else {
            cout << "未设置产品" << endl;
        }
    }
};

class Factory2 : public Factory {
public:
    Factory2() {}
    void makeProduct() {
        cout << "工厂2：";
        if (product) {
            product->Creat();
        }
        else {
            cout << "未设置产品" << endl;
        }
    }
};

int main() {
    unique_ptr<Factory> factory1 = make_unique<Factory1>();
    factory1->setProduct('a');
    factory1->makeProduct();
    return 0;
}

修改后的代码中，`Factory::setProduct()` 中加入了对产品B的处理；`Factory::product` 指针进行了初始化；`Factory1` 和 `Factory2` 中分别添加了默认构造函数并且在 `makeProduct()` 中判断是否设置了产品。