在我看来当您希望从一堆其他对象创建对象，并且创建零件需要独立于要创建的对象时，使用生成器模式。它有助于向客户端隐藏部件的创建，以使构建器和客户端独立。它用于创建复杂对象（可能包含复杂财产的对象）

而工厂模式指定您要创建一个公共族的对象，并希望它立即被切去。它用于更简单的对象。

IMHO

Builder是某种更复杂的工厂。

但在Builder中，您可以使用另一个工厂来实例化对象，这是构建最终有效对象所必需的。

所以，谈论“创造性模式”的复杂性演变，你可以这样想：

Dependency Injection Container -> Service Locator -> Builder -> Factory

我可以看出建筑商和工厂之间的一个显著区别是

假设我们有一辆车

class Car
{
  bool HasGPS;
  bool IsCityCar;
  bool IsSportsCar;
  int   Cylenders;
  int Seats;

  public:
     void Car(bool hasGPs=false,bool IsCityCar=false,bool IsSportsCar=false, int Cylender=2, int Seats=4);
 };

在上面的界面中，我们可以通过以下方式获取汽车：

 int main()
 {
    BadCar = new Car(false,false,true,4,4);
  }

但是如果在创建Seats时发生了一些异常呢？？？你根本得不到这个物体//但是

假设您有如下实现

class Car
 {
    bool mHasGPS;
    bool mIsCityCar;
    bool mIsSportsCar;
    int mCylenders;
    int mSeats;

 public:
    void Car() : mHasGPs(false), mIsCityCar(false), mIsSportsCar(false), mCylender(2), mSeats(4) {}
    void SetGPS(bool hasGPs=false)  {mHasGPs = hasGPs;}
    void SetCity(bool CityCar)  {mIsCityCar = CityCar;}
    void SetSports(bool SportsCar)  {mIsSportsCar = SportsCar;}
    void SetCylender(int Cylender)  {mCylenders = Cylender;}    
    void SetSeats(int seat) {mSeats = seat;}    
};

 class CarBuilder 
 {
    Car* mCar;
public:
        CarBuilder():mCar(NULL) {   mCar* = new Car();  }
        ~CarBuilder()   {   if(mCar)    {   delete mCar;    }
        Car* GetCar()   {   return mCar; mCar=new Car();    }
        CarBuilder* SetSeats(int n) {   mCar->SetSeats(n); return this; }
        CarBuilder* SetCylender(int n)  {   mCar->SetCylender(n); return this;  }
        CarBuilder* SetSports(bool val) {   mCar->SetSports(val); return this;  }
        CarBuilder* SetCity(bool val)   {   mCar->SetCity(val); return this;    }
        CarBuilder* SetGPS(bool val)    {   mCar->SetGPS(val); return this; }
}

现在您可以这样创建

 int main()
 {
   CarBuilder* bp =new CarBuilder;
    Car* NewCar  = bp->SetSeats(4)->SetSports(4)->SetCity(ture)->SetGPS(false)->SetSports(true)->GetCar();

     bp->SetSeats(2);

     bp->SetSports(4);

     bp->SetCity(ture);

     bp->SetSports(true)

     Car* Car_II=  bp->GetCar();

  }

在第二种情况下，即使一次操作失败，你仍然可以得到汽车。

可能是这辆车后来不太好用了，但你会有目标的。

因为Factory方法在一次调用中为您提供Car，而Builder则逐个构建。

尽管如此，这取决于哪一位的需要。

首先，要遵循我的论证：

设计大型软件系统的主要挑战是它们必须灵活且不复杂地进行更改。出于这个原因，有一些度量，如耦合和内聚。为了实现可以轻松更改或扩展其功能而无需从头设计整个系统的系统，您可以遵循设计原则（如SOLID等）。过了一段时间，一些开发人员意识到，如果他们遵循这些原则，就会有一些类似的解决方案可以很好地解决类似问题。这些标准解决方案被证明是设计模式。

因此，设计模式支持您遵循一般设计原则，以实现具有高内聚性的松散耦合系统。

回答问题：

通过询问两种模式之间的差异，你必须问问自己，哪种模式使你的系统更灵活。每个模式都有自己的目的来组织系统中类之间的依赖关系。

抽象工厂模式：GoF：“提供一个接口来创建相关或依赖对象的族，而不指定它们的具体类。”

这意味着什么：通过提供这样的接口，对每个系列产品的构造函数的调用被封装在工厂类中。因为这是整个系统中唯一调用这些构造函数的地方，所以可以通过实现新的工厂类来更改系统。如果您通过另一个交换工厂的表示，则可以在不接触大部分代码的情况下交换一整套产品。

生成器模式：GoF：“将复杂对象的构造与其表示分离，以便相同的构造过程可以创建不同的表示。”

这意味着什么：您将构建过程封装在另一个类中，称为director（GoF）。该导向器包含创建产品新实例的算法（例如，用其他部件组成一个复杂的产品）。为了创建整个产品的组成部分，导演使用了一个生成器。通过在director中交换生成器，您可以使用相同的算法来创建产品，但更改单个零件的表示（以及产品的表示）。要在产品的表示中扩展或修改系统，只需实现一个新的生成器类。

简而言之：抽象工厂模式的目的是交换一组共同使用的产品。生成器模式的目的是封装创建产品的抽象算法，以将其用于产品的不同表示。

在我看来，你不能说抽象工厂模式是生成器模式的大哥。是的，它们都是创造模式，但模式的主要意图完全不同。

对于设计模式，通常没有适用于所有情况的“更有利”解决方案。这取决于您需要实施什么。

来自维基百科：

Builder专注于构建一步一步复杂的物体。摘要工厂强调产品系列对象（简单或复杂）。生成器将产品作为最终产品返回步骤，但就抽象而言工厂关心，产品得到立即返回。生成器通常构建一个复合。通常，设计开始时使用工厂方法（不那么复杂，更多可定制，子类激增）并向抽象工厂发展，原型或生成器（更灵活，更复杂）发现更灵活的地方需要。有时创造模式是互补的：构建者可以使用要实现的其他模式构建哪些组件。摘要工厂、建造商和原型可以使用Singleton实现。

工厂设计模式维基百科条目：http://en.wikipedia.org/wiki/Factory_method_pattern

构建器设计模式的维基百科条目：http://en.wikipedia.org/wiki/Builder_pattern

这两种模式都有相同的必要性：对某些客户端代码隐藏复杂对象的构造逻辑。但是，是什么使一个对象变得“复杂”（或有时变得复杂）？主要是由于依赖关系，或者更确切地说是由更多部分状态组成的对象的状态。您可以通过构造函数注入依赖项来设置初始对象状态，但一个对象可能需要很多依赖项，其中一些依赖项将处于默认初始状态（只是因为我们应该了解到，将默认依赖项设置为null不是最干净的方式），而另一些依赖项则设置为由某种条件驱动的状态。此外，有些对象财产是某种“不经意的依赖关系”，但它们也可以假定为可选状态。

有两种众所周知的方法来控制这种复杂性：

组合/聚合：构造一个对象，构造其依赖对象，然后连接在一起。在这里，构建器可以使确定引导组件构建的规则的过程透明而灵活。多态性：构造规则直接声明到子类型定义中，因此每个子类型都有一组规则，某些条件决定了这些规则中的哪一个适用于构造对象。工厂完全适合这种情况。

没有什么可以阻止这两种方法的混合。一个产品系列可以抽象对象创建，由生成器完成，生成器可以使用工厂来确定实例化哪个组件对象。