如何处理对象的状态变化？如何实现工厂模式？

使用成员变量：可以在类中定义成员变量来表示对象的状态，通过修改这些成员变量的值来反映对象的状态变化。
封装状态修改操作：将修改状态的操作封装在成员函数中，确保状态的改变遵循一定的规则和逻辑，防止非法状态的出现。
使用状态模式：当对象的状态比较复杂，且状态之间的转换有较多逻辑时，可以考虑使用状态模式，将不同的状态封装为不同的类，将状态的切换逻辑封装在这些状态类中。

使用状态模式的示例代码：

cpp 复制代码

#include <iostream>
#include <string>

class State;  // 前向声明

class Context {
private:
    State* currentState;
public:
    Context(State* state) : currentState(state) {}

    void setState(State* state) {
        currentState = state;
    }

    void request() {
        currentState->handle(this);
    }
};


class State {
public:
    virtual ~State() {}
    virtual void handle(Context* context) = 0;
};


class StateA : public State {
public:
    void handle(Context* context) override {
        std::cout << "State A handling" << std::endl;
        context->setState(new StateB());  // 状态转换
    }
};


class StateB : public State {
public:
    void handle(Context* context) override {
        std::cout << "State B handling" << std::endl;
        context->setState(new StateA());  // 状态转换
    }
};


int main() {
    Context context(new StateA());
    context.request();  // 调用状态 A 的处理
    context.request();  // 调用状态 B 的处理
    return 0;
}

实现工厂模式：

简单工厂模式：创建一个工厂类，该类包含一个静态函数，根据输入的参数创建不同类型的对象。
工厂方法模式：在基类中定义一个抽象的工厂方法，让子类实现该方法来创建具体的对象。
抽象工厂模式：创建一个抽象工厂类，其中包含多个抽象的工厂方法，每个工厂方法负责创建一种产品族的对象，具体工厂类实现这些方法。

简单工厂模式的示例代码：

cpp 复制代码

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


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


class ConcreteProductA : public Product {
public:
    void show() override {
        std::cout << "ConcreteProductA" << std::endl;
    }
};


class ConcreteProductB : public Product {
public:
    void show() override {
        std::cout << "ConcreteProductB" << std::endl;
    }
};


class SimpleFactory {
public:
    static std::unique_ptr<Product> createProduct(const std::string& type) {
        if (type == "A") {
            return std::make_unique<ConcreteProductA>();
        } else if (type == "B") {
            return std::make_unique<ConcreteProductB>();
        } else {
            return nullptr;
        }
    }
};


int main() {
    auto productA = SimpleFactory::createProduct("A");
    if (productA) {
        productA->show();
    }
    auto productB = SimpleFactory::createProduct("B");
    if (productB) {
        productB->show();
    }
    return 0;
}

工厂方法模式的示例代码：

cpp 复制代码

#include <iostream>


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


class ConcreteProductA : public Product {
public:
    void show() override {
        std::cout << "ConcreteProductA" << std::endl;
    }
};


class ConcreteProductB : public Product {
public:
    void show() override {
        std::cout << "ConcreteProductB" << std::endl;
    }
};


class Creator {
public:
    virtual ~Creator() {}
    virtual Product* createProduct() = 0;
};


class ConcreteCreatorA : public Creator {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};


class ConcreteCreatorB : public Creator {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};


int main() {
    Creator* creatorA = new ConcreteCreatorA();
    Product* productA = creatorA->createProduct();
    productA->show();
    delete productA;
    delete creatorA;

    Creator* creatorB = new ConcreteCreatorB();
    Product* productB = creatorB->createProduct();
    productB->show();
    delete productB;
    delete creatorB;
    return 0;
}

抽象工厂模式的示例代码：

cpp 复制代码

#include <iostream>


class ProductA {
public:
    virtual ~ProductA() {}
    virtual void show() = 0;
};


class ConcreteProductA1 : public ProductA {
public:
    void show() override {
        std::cout << "ConcreteProductA1" << std::endl;
    }
};


class ConcreteProductA2 : public ProductA {
public:
    void show() override {
        std::cout << "ConcreteProductA2" << std::endl;
    }
};


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


class ConcreteProductB1 : public ProductB {
public:
    void show() override {
        std::cout << "ConcreteProductB1" << std::endl;
    }
};


class ConcreteProductB2 : public ProductB {
public:
    void show() override {
        std::cout << "ConcreteProductB2" << std::endl;
    }
};


class AbstractFactory {
public:
    virtual ~AbstractFactory() {}
    virtual ProductA* createProductA() = 0;
    virtual ProductB* createProductB() = 0;
};


class ConcreteFactory1 : public AbstractFactory {
public:
    ProductA* createProductA() override {
        return new ConcreteProductA1();
    }
    ProductB* createProductB() override {
        return new ConcreteProductB1();
    }
};


class ConcreteFactory2 : public AbstractFactory {
public:
    ProductA* createProductA() override {
        return new ConcreteProductA2();
    }
    ProductB* createProductB() override {
        return new ConcreteProductB2();
    }
};


int main() {
    AbstractFactory* factory1 = new ConcreteFactory1();
    ProductA* productA1 = factory1->createProductA();
    ProductB* productB1 = factory1->createProductB();
    productA1->show();
    productB1->show();
    delete productA1;
    delete productB1;
    delete factory1;

    AbstractFactory* factory2 = new ConcreteFactory2();
    ProductA* productA2 = factory2->createProductA();
    ProductB* productB2 = factory2->createProductB();
    productA2->show();
    productB2->show();
    delete productA2;
    delete productB2;
    delete factory2;
    return 0;
}