抽象工厂结构的差异

我为抽象工厂编写了 2 种类型的代码：类型1 和类型2
类型1是我通过互联网
网站得出的，但类型2是我应该是一个更好的约定

类型1
首先是所需最终产品的基类。有必需的工厂基类。决定所需的工厂品牌。通过派生实例化它们的具体类。确定每个品牌的工厂应该提供哪些常见类别。然后通过推导实例化每个最终产品的最终产品的混凝土。但是在 main 函数中，您直接创建工厂对象。此类代码中将需要更多的维护。

class Shoe
{
public:
virtual void Detail() = 0;
char make[2];
int size;
};
class Shoe_B5:public Shoe //small
{
public:
Shoe_B5()
{
strcpy(make,"B");
size = 5;
}
void Detail()
{
cout<<"Shoe"<<make<<size<<endl;
}
};
class Shoe_B6:public Shoe //medium
{
public:
Shoe_B6()
{
strcpy(make,"B");
size = 6;
}
void Detail()
{
cout<<"Shoe"<<make<<size<<endl;
}
};
class Shoe_B7:public Shoe //large
{
public:
Shoe_B7()
{
strcpy(make,"B");
size = 7;
}
void Detail()
{
cout<<"Shoe"<<make<<size<<endl;
}
};
class Shoe_B8:public Shoe //XL
{
public:
Shoe_B8()
{
strcpy(make,"B");
size = 8;
}
void Detail()
{
cout<<"Shoe"<<make<<size<<endl;
}
};
class Shoe_RT5:public Shoe //small
{
public:
Shoe_RT5()
{
strcpy(make,"RT");
size = 5;
}
void Detail()
{
cout<<"Shoe"<<make<<size<<endl;
}
};

class Shoe_RT6:public Shoe //medium
{
public:
Shoe_RT6()
{
strcpy(make,"RT");
size = 6;
}
void Detail()
{
cout<<"Shoe"<<make<<size<<endl;
}
};
class Shoe_RT7:public Shoe //Large
{
public:
Shoe_RT7()
{
strcpy(make,"RT");
size = 7;
}
void Detail()
{
cout<<"Shoe"<<make<<size<<endl;
}
};

class Shoe_RT8:public Shoe //XL
{
public:
Shoe_RT8()
{
strcpy(make,"RT");
size = 8;
}
void Detail()
{
cout<<"Shoe"<<make<<size<<endl;
}
};
class Factory
{
public:
virtual Shoe* createSmall() = 0;
virtual Shoe* createMedium() = 0;
virtual Shoe* createLarge() = 0;
virtual Shoe* createXL() = 0;
};
class BataFactory: public Factory
{
public:
Shoe* createSmall()
{
return new Shoe_B5;
}
Shoe* createMedium()
{
return new Shoe_B6;
}
Shoe* createLarge()
{
return new Shoe_B7;
}
Shoe* createXL()
{
return new Shoe_B8;
}
};

class RedTapeFactory: public Factory
{
public:
Shoe* createSmall()
{
return new Shoe_RT5;
}
Shoe* createMedium()
{
return new Shoe_RT6;
}
Shoe* createLarge()
{
return new Shoe_RT7;
}
Shoe* createXL()
{
return new Shoe_RT8;
}
};
class Client
{
Factory* fac;
Shoe* s;
public:
Client(Factory* factory)
{
fac = factory;
}
Shoe* Create(int num)
{
switch(num)
{
case 1:
s = fac->createSmall();
break;
case 2:
s = fac->createMedium();
break;
case 3:
s = fac->createLarge();
break;
case 4:
s = fac->createXL();
break;
}
}
void getDetails()
{
s->Detail();
}
};
int main()
{
Factory * fac;
if(condition)
fac = new BataFactory;
else
fac = new RedTapeFactory;
Client * c = new Client(fac);
c->create(Size);
c->getDetails();
}

类型 2 的区别
但是在 main 函数中，您正在像在工厂方法中一样创建工厂。此类代码中所需的维护较少。

class Factory
{
public:
//produce allowed category of shoes
virtual Shoe* createSmall() = 0;
virtual Shoe* createMedium() = 0;
virtual Shoe* createLarge() = 0;
virtual Shoe* createXL() = 0;
//produce allowed category of factories
static Factory* CreateFactory(int num);
};
Factory* Factory::CreateFactory(int num)
{
switch(num)
{
case 1:
return new BataFactory;
break;
case 2:
return new RedTapeFactory;
break;
}
}
int main()
{
Factory * fac;
switch(condition)
{
case 1:
fac = Factory::CreateFactory(1);
break;
case 2:
fac = Factory::CreateFactory(2);
break;
}
Client * c = new Client(fac);
c->create(Size);
c->getDetails();
}