设计模式之工厂模式

原创于 2025-02-17 14:54:03 发布 · 967 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #java #c++ #简单工厂模式 #抽象工厂模式 #工厂方法模式

设计模式专栏收录该内容

16 篇文章

订阅专栏

概念

工厂模式是一种创建对象的设计模式，它将对象的创建和使用分离，使得代码更加灵活、可维护和可扩展。

工厂模式主要分为三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。

实现原理

工厂模式的核心思想是将对象的创建和使用分离，通过一个专门的工厂类或方法来负责对象的创建过程，这样可以提高代码的可维护性、可扩展性和灵活性。下面分别详细介绍三种工厂模式的实现原理。

简单工厂模式

简单工厂模式定义了一个工厂类，这个工厂类通常包含一个静态方法，根据传入的参数来决定创建哪种具体的产品对象。客户端只需要向工厂类提供所需产品的类型信息，而不需要关心产品对象的具体创建过程。

具体步骤

定义抽象产品类：抽象产品类定义了产品的公共接口，所有具体产品类都必须实现这些接口。
创建具体产品类：具体产品类继承自抽象产品类，并实现其定义的接口。
实现简单工厂类：简单工厂类包含一个静态方法，该方法根据传入的参数判断需要创建哪种具体的产品对象，并返回相应的产品对象。
客户端调用：客户端通过调用简单工厂类的静态方法，传入所需产品的类型信息，获取相应的产品对象，并使用该对象。

示例（咖啡店点餐）

比如你走进一家咖啡店，这家咖啡店可以制作多种咖啡，比如拿铁、美式咖啡等。你只需要告诉店员你想要的咖啡种类，店员就会为你制作相应的咖啡。这里的咖啡店就相当于简单工厂，你点的咖啡类型就是传入的参数，制作好的咖啡就是创建的产品。

对应代码角色：

抽象产品类：Coffee（咖啡），定义了咖啡的基本属性和方法，如品尝。
具体产品类：Latte（拿铁）和Americano（美式咖啡），继承自Coffee并实现具体的品尝方法。
简单工厂类：CoffeeShop（咖啡店），有一个制作咖啡的方法，根据你点的咖啡类型制作相应的咖啡。

示例代码

C++实现：

为了更好地释放资源，C++代码都使用智能指针。

#include <iostream>
#include <memory>
#include <stdexcept>
// 枚举：咖啡类型
enum class CoffeeType {
    LATTE,
    AMERICANO
};
// 抽象产品类：咖啡
class Coffee {
public:
    virtual void taste() const = 0;
    virtual ~Coffee() = default;
};
// 具体产品类：拿铁
class Latte : public Coffee {
public:
    void taste() const override {
        std::cout << "这是拿铁，口感丝滑，有浓郁的奶香。" << std::endl;
    }
};
// 具体产品类：美式咖啡
class Americano : public Coffee {
public:
    void taste() const override {
        std::cout << "这是美式咖啡，口感清爽，咖啡味浓郁。" << std::endl;
    }
};
// 工厂类：咖啡店
class CoffeeShop {
public:
    // 工厂方法，根据咖啡类型创建咖啡对象
    static std::unique_ptr<Coffee> makeCoffee(CoffeeType type) {
        switch (type) {
            case CoffeeType::LATTE:
                return std::make_unique<Latte>();
            case CoffeeType::AMERICANO:
                return std::make_unique<Americano>();
            default:
                throw std::invalid_argument("未知的咖啡类型");
        }
    }
};
int main() {
    CoffeeShop coffeeShop;
    try {
        auto latte = CoffeeShop::makeCoffee(CoffeeType::LATTE);
        latte->taste(); // 输出：这是拿铁，口感丝滑，有浓郁的奶香。
        auto americano = CoffeeShop::makeCoffee(CoffeeType::AMERICANO);
        americano->taste(); // 输出：这是美式咖啡，口感清爽，咖啡味浓郁。
    } catch (const std::exception& e) {
        std::cerr << "错误: " << e.what() << std::endl;
    }
    return 0;
}

java实现：

// 接口：咖啡
interface Coffee {
    void taste(); // 接口方法，具体实现类需实现
}
// 具体产品类：拿铁
class Latte implements Coffee {
    @Override
    public void taste() {
        System.out.println("这是拿铁，口感丝滑，有浓郁的奶香。");
    }
}
// 具体产品类：美式咖啡
class Americano implements Coffee {
    @Override
    public void taste() {
        System.out.println("这是美式咖啡，口感清爽，咖啡味浓郁。");
    }
}
// 枚举：咖啡类型
enum CoffeeType {
    LATTE,
    AMERICANO
}
// 简单工厂类：咖啡店
class CoffeeShop {
    // 简单工厂方法，根据类型创建咖啡对象
    public static Coffee makeCoffee(CoffeeType type) {
        switch (type) {
            case LATTE:
                return new Latte();
            case AMERICANO:
                return new Americano();
            default:
                throw new IllegalArgumentException("未知的咖啡类型: " + type);
        }
    }
}
// 测试类
public class Main {
    public static void main(String[] args) {
        Coffee latte = CoffeeShop.makeCoffee(CoffeeType.LATTE);
        latte.taste(); // 调用拿铁的taste方法
        Coffee americano = CoffeeShop.makeCoffee(CoffeeType.AMERICANO);
        americano.taste(); // 调用美式咖啡的taste方法
    }
}

防止外部实例化调整

此处可能会有如下考虑：我想要一杯咖啡，但是我自己做不出这杯咖啡来，只能去咖啡店购买。即在工厂模式中，具体产品类只能通过工厂进行实例化，不能用户再工厂外部直接实例化。

要解决这个问题，可以通过具体语言的特性进行调整，如C++,若要确保具体产品类只能通过工厂来实例化，可通过将具体产品类的构造函数设为私有（private）或受保护（protected），然后在工厂类里定义为具体产品类的友元类（friend），从而让工厂类能够访问这些构造函数。

如下是一个简要的具体产品类的简要示例：

// 具体产品类：美式咖啡
class Americano : public Coffee {
private:
    Americano(){};
    friend class CoffeeShop;
public:
    void taste() const override {
        std::cout << "这是美式咖啡，口感清爽，咖啡味浓郁。" << std::endl;
    }
};

此外，还可以通过内部类的方式来防止外部直接实例化，此处不再作详细说明。

而对于java，可以通过将具体产品类的构造函数设为protected或private，可以限制外部代码直接实例化它们。但是这种方法要求工厂类和具体产品类在同一个包中或者在内部类中。但如果需要更严格的封闭性，完全无法从外部访问具体产品类，只有工厂类可以访问。

代码如下：

// 抽象产品类：咖啡
abstract class Coffee {
    public abstract void taste(); // 抽象方法，具体子类需实现
}

// 简单工厂类：咖啡店
class CoffeeShop {
    // 私有的静态内部类：拿铁
    private static class Latte extends Coffee {
        @Override
        public void taste() {
            System.out.println("这是拿铁，口感丝滑，有浓郁的奶香。");
        }
    }

    // 私有的静态内部类：美式咖啡
    private static class Americano extends Coffee {
        @Override
        public void taste() {
            System.out.println("这是美式咖啡，口感清爽，咖啡味浓郁。");
        }
    }

    // 简单工厂方法，根据类型返回对应的产品实例
    public static Coffee makeCoffee(String type) {
        if ("latte".equalsIgnoreCase(type)) {
            return new Latte(); // 工厂方法可以访问内部类
        } else if ("americano".equalsIgnoreCase(type)) {
            return new Americano(); // 工厂方法可以访问内部类
        }
        return null; // 如果无法匹配，返回null
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        // 只能通过工厂类实例化
        Coffee latte = CoffeeShop.makeCoffee("latte");
        if (latte != null) {
            latte.taste(); // 调用拿铁的 taste 方法
        }

        Coffee americano = CoffeeShop.makeCoffee("americano");
        if (americano != null) {
            americano.taste(); // 调用美式咖啡的 taste 方法
        }

        // 以下代码会报错，因为 Latte 和 Americano 是私有静态内部类
        // Coffee latteObj = new CoffeeShop.Latte(); // 编译错误
    }
}

两种方式对比：

方法	优点	限制
构造函数 (`protected`)	简单直观，工厂类和具体产品类可以分开管理。	构造函数受保护，要求工厂类和产品类在同一个包中，或者工厂类是子类才能访问产品的构造函数。
内部类（ `private static`）	更严格的封闭性，完全无法从外部访问具体产品类，只有工厂类可以访问。	具体产品类只能作为工厂类的一部分，设计上可能会显得不够独立，代码耦合性增加。

工厂方法模式

工厂方法模式将对象的创建延迟到子类中实现，每个具体的工厂子类负责创建一种具体的产品对象。抽象工厂类定义了创建产品的抽象方法，具体工厂子类实现这些方法来创建具体的产品。这样可以避免简单工厂模式中工厂类的职责过重问题，使得代码更加符合开闭原则。

具体步骤

1. 定义抽象产品类：同简单工厂模式，抽象产品类定义了产品的公共接口。
2. 创建具体产品类：具体产品类继承自抽象产品类，并实现其定义的接口。
3. 定义抽象工厂类：抽象工厂类定义了创建产品的抽象方法，该方法返回抽象产品类的指针或引用。
4. 实现具体工厂类：具体工厂类继承自抽象工厂类，实现抽象工厂类中定义的创建产品的方法，负责创建具体的产品对象。
5. 客户端调用：客户端通过创建具体的工厂对象，调用工厂对象的创建产品方法，获取相应的产品对象，并使用该对象。

示例（不同城市的咖啡店）

现在假设你在不同的城市旅游，每个城市的咖啡店都有自己独特的咖啡制作风格。比如北京的咖啡店制作的拿铁和上海的咖啡店制作的拿铁可能口感略有不同。每个城市的咖啡店就是一个具体的工厂，它们都可以制作拿铁和美式咖啡，但制作方法有所差异。

对应代码角色

抽象产品类：Coffee（咖啡）。
具体产品类：BeijingLatte（北京拿铁）、ShanghaiLatte（上海拿铁）、BeijingAmericano（北京美式咖啡）、ShanghaiAmericano（上海美式咖啡）。
抽象工厂类：CoffeeFactory（咖啡工厂），定义了制作咖啡的抽象方法。
具体工厂类：BeijingCoffeeFactory（北京咖啡工厂）和ShanghaiCoffeeFactory（上海咖啡工厂），分别实现制作北京风格和上海风格咖啡的方法。

示例代码

C++实现

[[nodiscard]]属性¹：该属性是在 C++17 标准中引入的，该属性用于修饰函数或者类型，其主要作用是告诉编译器，如果调用该函数返回的结果被忽略（即没有使用该返回值），编译器应该发出警告。

#include <iostream>
#include <memory>

// 抽象产品类：咖啡
class Coffee {
public:
    virtual void taste() const = 0;
    virtual ~Coffee() = default;
};

// 具体产品类：北京拿铁
class BeijingLatte : public Coffee {
public:
    void taste() const override {
        std::cout << "这是北京风格的拿铁，口感醇厚。" << std::endl;
    }
};

// 具体产品类：上海拿铁
class ShanghaiLatte : public Coffee {
public:
    void taste() const override {
        std::cout << "这是上海风格的拿铁，口感清新。" << std::endl;
    }
};

// 具体产品类：北京美式咖啡
class BeijingAmericano : public Coffee {
public:
    void taste() const override {
        std::cout << "这是北京风格的美式咖啡，味道浓烈。" << std::endl;
    }
};

// 具体产品类：上海美式咖啡
class ShanghaiAmericano : public Coffee {
public:
    void taste() const override {
        std::cout << "这是上海风格的美式咖啡，味道淡雅。" << std::endl;
    }
};

// 抽象工厂类：咖啡工厂
class CoffeeFactory {
public:
    [[nodiscard]] virtual std::unique_ptr<Coffee> createLatte() const = 0;
    [[nodiscard]] virtual std::unique_ptr<Coffee> createAmericano() const = 0;
    virtual ~CoffeeFactory() = default;
};

// 具体工厂类：北京咖啡工厂
class BeijingCoffeeFactory : public CoffeeFactory {
public:
    [[nodiscard]] std::unique_ptr<Coffee> createLatte() const override {
        return std::make_unique<BeijingLatte>();
    }
    [[nodiscard]] std::unique_ptr<Coffee> createAmericano() const override {
        return std::make_unique<BeijingAmericano>();
    }
};

// 具体工厂类：上海咖啡工厂
class ShanghaiCoffeeFactory : public CoffeeFactory {
public:
    [[nodiscard]] std::unique_ptr<Coffee> createLatte() const override {
        return std::make_unique<ShanghaiLatte>();
    }
    [[nodiscard]] std::unique_ptr<Coffee> createAmericano() const override {
        return std::make_unique<ShanghaiAmericano>();
    }
};

int main() {
    std::unique_ptr<CoffeeFactory> beijingFactory = std::make_unique<BeijingCoffeeFactory>();
    std::unique_ptr<Coffee> beijingLatte = beijingFactory->createLatte();
    beijingLatte->taste();
    std::unique_ptr<Coffee> beijingAmericano = beijingFactory->createAmericano();
    beijingAmericano->taste();

    std::unique_ptr<CoffeeFactory> shanghaiFactory = std::make_unique<ShanghaiCoffeeFactory>();
    std::unique_ptr<Coffee> shanghaiLatte = shanghaiFactory->createLatte();
    shanghaiLatte->taste();
    std::unique_ptr<Coffee> shanghaiAmericano = shanghaiFactory->createAmericano();
    shanghaiAmericano->taste();

    return 0;
}

Java实现

// 接口：咖啡
interface Coffee {
    void taste(); // 接口方法，具体实现类需实现
}
// 具体产品类：北京拿铁
class BeijingLatte implements Coffee {
    @Override
    public void taste() {
        System.out.println("这是北京风格的拿铁，口感醇厚。");
    }
}
// 具体产品类：上海拿铁
class ShanghaiLatte implements Coffee {
    @Override
    public void taste() {
        System.out.println("这是上海风格的拿铁，口感清新。");
    }
}
// 具体产品类：北京美式咖啡
class BeijingAmericano implements Coffee {
    @Override
    public void taste() {
        System.out.println("这是北京风格的美式咖啡，味道浓烈。");
    }
}
// 具体产品类：上海美式咖啡
class ShanghaiAmericano implements Coffee {
    @Override
    public void taste() {
        System.out.println("这是上海风格的美式咖啡，味道淡雅。");
    }
}
// 枚举：咖啡类型
enum CoffeeType {
    LATTE,
    AMERICANO
}
// 抽象工厂类：咖啡工厂
interface CoffeeFactory {
    Coffee makeCoffee(CoffeeType type);
}
// 具体工厂类：北京咖啡工厂
class BeijingCoffeeFactory implements CoffeeFactory {
    @Override
    public Coffee makeCoffee(CoffeeType type) {
        switch (type) {
            case LATTE:
                return new BeijingLatte();
            case AMERICANO:
                return new BeijingAmericano();
            default:
                throw new IllegalArgumentException("未知的咖啡类型: " + type);
        }
    }
}
// 具体工厂类：上海咖啡工厂
class ShanghaiCoffeeFactory implements CoffeeFactory {
    @Override
    public Coffee makeCoffee(CoffeeType type) {
        switch (type) {
            case LATTE:
                return new ShanghaiLatte();
            case AMERICANO:
                return new ShanghaiAmericano();
            default:
                throw new IllegalArgumentException("未知的咖啡类型: " + type);
        }
    }
}
// 测试类
public class Main {
    public static void main(String[] args) {
        CoffeeFactory beijingFactory = new BeijingCoffeeFactory();
        Coffee beijingLatte = beijingFactory.makeCoffee(CoffeeType.LATTE);
        beijingLatte.taste(); // 输出：这是北京风格的拿铁，口感醇厚。
        Coffee beijingAmericano = beijingFactory.makeCoffee(CoffeeType.AMERICANO);
        beijingAmericano.taste(); // 输出：这是北京风格的美式咖啡，味道浓烈。
        CoffeeFactory shanghaiFactory = new ShanghaiCoffeeFactory();
        Coffee shanghaiLatte = shanghaiFactory.makeCoffee(CoffeeType.LATTE);
        shanghaiLatte.taste(); // 输出：这是上海风格的拿铁，口感清新。
        Coffee shanghaiAmericano = shanghaiFactory.makeCoffee(CoffeeType.AMERICANO);
        shanghaiAmericano.taste(); // 输出：这是上海风格的美式咖啡，味道淡雅。
    }
}

若需要具体类的封闭性，无法从外部访问具体产品类，可参照简单工厂模式处说明进行调整：防止外部实例化调整。

抽象工厂模式

抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它允许客户端使用抽象的接口来创建一组相关的产品，而不需要关心这些产品的具体实现。抽象工厂模式通过将多个相关产品的创建封装在一个工厂类中，使得客户端可以方便地切换不同的产品族。

具体步骤

1. 定义抽象产品类族：定义多个抽象产品类，每个抽象产品类代表一个产品族中的一类产品，它们定义了该类产品的公共接口。
2. 创建具体产品类：针对每个抽象产品类，创建多个具体产品类，这些具体产品类分别属于不同的产品族，并实现相应抽象产品类的接口。
3. 定义抽象工厂类：抽象工厂类定义了创建一系列相关产品的抽象方法，每个方法对应一个抽象产品类，返回相应抽象产品类的指针或引用。
4. 实现具体工厂类：具体工厂类继承自抽象工厂类，实现抽象工厂类中定义的创建产品的方法，负责创建一组相关的具体产品对象。
5. 客户端调用：客户端通过创建具体的工厂对象，调用工厂对象的创建产品方法，获取一组相关的产品对象，并使用这些对象。

示例（大型餐饮集团）

现在有一个大型餐饮集团，旗下有不同风格的餐厅，比如西餐厅和中餐厅。西餐厅可以提供西餐的主食（如牛排）和饮品（如红酒），中餐厅可以提供中餐的主食（如炒饭）和饮品（如茶）。这里的餐饮集团就相当于抽象工厂，西餐厅和中餐厅就是具体工厂，牛排、红酒、炒饭、茶就是不同的产品。

对应代码角色

抽象产品类族：StapleFood（主食）和Beverage（饮品）。
具体产品类：Steak（牛排）、FriedRice（炒饭）、RedWine（红酒）、Tea（茶）。
抽象工厂类：RestaurantFactory（餐厅工厂），定义了创建主食和饮品的抽象方法。
具体工厂类：WesternRestaurantFactory（西餐厅工厂）和ChineseRestaurantFactory（中餐厅工厂），分别实现创建西餐和中餐的主食与饮品的方法。

示例代码

C++实现

  #include <iostream>
  #include <memory>
  
  // 抽象产品类：主食
  class StapleFood {
  public:
      virtual void taste() const = 0;
      virtual ~StapleFood() = default;
  };
  
  // 具体产品类：牛排
  class Steak : public StapleFood {
  public:
      void taste() const override {
          std::cout << "这是牛排，肉质鲜嫩多汁。" << std::endl;
      }
  };
  
  // 具体产品类：炒饭
  class FriedRice : public StapleFood {
  public:
      void taste() const override {
          std::cout << "这是炒饭，香气扑鼻。" << std::endl;
      }
  };
  
  // 抽象产品类：饮品
  class Beverage {
  public:
      virtual void taste() const = 0;
      virtual ~Beverage() = default;
  };
  
  // 具体产品类：红酒
  class RedWine : public Beverage {
  public:
      void taste() const override {
          std::cout << "这是红酒，口感醇厚。" << std::endl;
      }
  };
  
  // 具体产品类：茶
  class Tea : public Beverage {
  public:
      void taste() const override {
          std::cout << "这是茶，清香宜人。" << std::endl;
      }
  };
  
  // 抽象工厂类：餐厅工厂
  class RestaurantFactory {
  public:
      [[nodiscard]] virtual std::unique_ptr<StapleFood> createStapleFood() const = 0;
      [[nodiscard]] virtual std::unique_ptr<Beverage> createBeverage() const = 0;
      virtual ~RestaurantFactory() = default;
  };
  
  // 具体工厂类：西餐厅工厂
  class WesternRestaurantFactory : public RestaurantFactory {
  public:
      [[nodiscard]] std::unique_ptr<StapleFood> createStapleFood() const override {
          return std::make_unique<Steak>();
      }
      [[nodiscard]] std::unique_ptr<Beverage> createBeverage() const override {
          return std::make_unique<RedWine>();
      }
  };
  
  // 具体工厂类：中餐厅工厂
  class ChineseRestaurantFactory : public RestaurantFactory {
  public:
      [[nodiscard]] std::unique_ptr<StapleFood> createStapleFood() const override {
          return std::make_unique<FriedRice>();
      }
      [[nodiscard]] std::unique_ptr<Beverage> createBeverage() const override {
          return std::make_unique<Tea>();
      }
  };
  
  int main() {
      std::unique_ptr<RestaurantFactory> westernFactory = std::make_unique<WesternRestaurantFactory>();
      std::unique_ptr<StapleFood> steak = westernFactory->createStapleFood();
      std::unique_ptr<Beverage> redWine = westernFactory->createBeverage();
      steak->taste();
      redWine->taste();
  
      std::unique_ptr<RestaurantFactory> chineseFactory = std::make_unique<ChineseRestaurantFactory>();
      std::unique_ptr<StapleFood> friedRice = chineseFactory->createStapleFood();
      std::unique_ptr<Beverage> tea = chineseFactory->createBeverage();
      friedRice->taste();
      tea->taste();
  
      return 0;
  }

java实现

// 接口：主食
interface StapleFood {
    void taste();
}
// 具体产品类：牛排
class Steak implements StapleFood {
    @Override
    public void taste() {
        System.out.println("这是牛排，肉质鲜嫩多汁。");
    }
}
// 具体产品类：炒饭
class FriedRice implements StapleFood {
    @Override
    public void taste() {
        System.out.println("这是炒饭，香气扑鼻。");
    }
}
// 接口：饮品
interface Beverage {
    void taste();
}
// 具体产品类：红酒
class RedWine implements Beverage {
    @Override
    public void taste() {
        System.out.println("这是红酒，口感醇厚。");
    }
}
// 具体产品类：茶
class Tea implements Beverage {
    @Override
    public void taste() {
        System.out.println("这是茶，清香宜人。");
    }
}
// 枚举：餐厅类型
enum RestaurantType {
    WESTERN,
    CHINESE
}
// 抽象工厂接口：餐厅工厂
interface RestaurantFactory {
    StapleFood createStapleFood();
    Beverage createBeverage();
}
// 具体工厂类：西餐厅工厂
class WesternRestaurantFactory implements RestaurantFactory {
    @Override
    public StapleFood createStapleFood() {
        return new Steak();
    }
    @Override
    public Beverage createBeverage() {
        return new RedWine();
    }
}
// 具体工厂类：中餐厅工厂
class ChineseRestaurantFactory implements RestaurantFactory {
    @Override
    public StapleFood createStapleFood() {
        return new FriedRice();
    }
    @Override
    public Beverage createBeverage() {
        return new Tea();
    }
}
// 工厂创建器类（可选，用于集中管理工厂创建逻辑）
class RestaurantFactoryCreator {
    public static RestaurantFactory createFactory(RestaurantType type) {
        switch (type) {
            case WESTERN:
                return new WesternRestaurantFactory();
            case CHINESE:
                return new ChineseRestaurantFactory();
            default:
                throw new IllegalArgumentException("未知的餐厅类型: " + type);
        }
    }
}
// 测试类
public class Main {
    public static void main(String[] args) {
        // 创建西餐厅工厂
        RestaurantFactory westernFactory = RestaurantFactoryCreator.createFactory(RestaurantType.WESTERN);
        StapleFood steak = westernFactory.createStapleFood();
        Beverage redWine = westernFactory.createBeverage();
        steak.taste(); // 输出：这是牛排，肉质鲜嫩多汁。
        redWine.taste(); // 输出：这是红酒，口感醇厚。
        // 创建中餐厅工厂
        RestaurantFactory chineseFactory = RestaurantFactoryCreator.createFactory(RestaurantType.CHINESE);
        StapleFood friedRice = chineseFactory.createStapleFood();
        Beverage tea = chineseFactory.createBeverage();
        friedRice.taste(); // 输出：这是炒饭，香气扑鼻。
        tea.taste(); // 输出：这是茶，清香宜人。
    }
}

应用场景

简单工厂模式

计算器程序：在实现一个简单的计算器程序时，可使用简单工厂模式。根据用户输入的运算符，如 “+”“-”“ *”“/” 等，通过简单工厂来创建相应的运算对象，如加法运算对象、减法运算对象等，然后执行相应的运算操作。这样可以将运算对象的创建和运算逻辑分离，使代码更易于维护和扩展。
文件格式解析器：开发一个文件处理系统，需要根据不同的文件扩展名（如.txt、.pdf、.docx 等）来创建不同的文件解析器。简单工厂模式可以根据文件扩展名创建相应的解析器对象，然后调用解析器的方法来解析文件内容。
数据库连接创建：在开发数据库应用程序时，根据配置文件中指定的数据库类型（如 MySQL、Oracle、SQL Server 等），使用简单工厂模式创建相应的数据库连接对象。这样可以将数据库连接的创建过程封装在工厂类中，方便在不同的数据库之间进行切换。

工厂方法模式

电商系统中的订单处理：在电商系统中，不同类型的订单（如普通订单、团购订单、秒杀订单等）可能有不同的处理逻辑。可以使用工厂方法模式，为每种订单类型创建一个具体的订单处理工厂类，每个工厂类负责创建相应类型的订单处理对象，并实现订单处理的具体逻辑。
游戏开发中的角色创建：在游戏开发中，不同类型的角色（如战士、法师、刺客等）具有不同的行为和属性。可以使用工厂方法模式，为每种角色创建一个具体的角色工厂类，每个工厂类负责创建相应类型的角色对象，并初始化角色的属性和行为。
日志记录系统：在一个大型项目中，可能需要根据不同的环境（如开发环境、测试环境、生产环境等）记录不同级别的日志（如调试日志、信息日志、错误日志等）。可以使用工厂方法模式，为每个环境创建一个具体的日志记录工厂类，每个工厂类负责创建相应级别的日志记录对象，并实现日志记录的具体逻辑。

抽象工厂模式

跨平台应用开发：在开发跨平台应用时，需要根据不同的操作系统（如 Windows、Mac、Linux 等）创建不同的界面组件（如按钮、文本框、菜单等）。抽象工厂模式可以定义一个抽象的界面组件工厂接口，然后为每个操作系统创建一个具体的工厂类，每个具体工厂类负责创建适用于该操作系统的界面组件对象。
汽车制造模拟：在模拟汽车制造的系统中，汽车由多个部件组成，如发动机、轮胎、座椅等。不同品牌的汽车，其部件的实现可能不同。可以使用抽象工厂模式，为每个汽车品牌创建一个具体的工厂类，每个工厂类负责创建该品牌汽车的各种部件对象，然后将这些部件组装成完整的汽车。
数据库操作抽象：在开发数据库应用程序时，可能需要支持多种数据库（如 MySQL、Oracle、SQL Server 等），并且不同的数据库在操作上可能有一些差异。抽象工厂模式可以定义一个抽象的数据库操作工厂接口，然后为每个数据库创建一个具体的工厂类，每个具体工厂类负责创建适用于该数据库的操作对象，如连接对象、语句对象等，并实现数据库操作的具体方法。

C++ 属性（Attributes）机制是从 C++11 标准开始引入的。属性是一种通用的语法，用于为程序中的实体（如函数、类、变量等）添加额外的元信息，这些元信息可以帮助编译器进行优化、发出警告或者执行特定的语义检查等。C++11 引入了一些基本的属性，例如 [[noreturn]]，它用于修饰函数，表明该函数不会正常返回。即函数要么通过抛出异常终止，要么进入无限循环等情况，不会以 return 语句正常返回控制流到调用点。 ↩︎