智博吧,福彩3d乐彩网,共看明月应垂泪
我们先看工厂模式的介绍
这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
简单来说，使用了c++多态的特性，将存在继承关系的类，通过一个工厂类创建对应的子类（派生类）对象。在项目复杂的情况下，可以便于子类对象的创建。
工厂模式的实现方式可分别简单工厂模式、工厂方法模式、抽象工厂模式，每个实现方式都存在优和劣。
最近炒鞋炒的非常的火，那么以鞋厂的形式，一一分析针对每个实现方式进行分析。
我要评论shoesfactory)：工厂模式的核心类，会定义一个用于创建指定的具体实例对象的接口。shoes)：是具体产品类的继承的父类或实现的接口。nikeshoes\adidasshoes\liningshoes)：工厂类所创建的对象就是此具体产品实例。shoes为鞋子的抽象类（基类），接口函数为show()，用于显示鞋子广告。nikeshoes、adidasshoes、liningshoes为具体鞋子的类，分别是耐克、阿迪达斯和李宁鞋牌的鞋，它们都继承于shoes抽象类。// 鞋子抽象类
class shoes
{
public:
virtual ~shoes() {}
virtual void show() = 0;
};
// 耐克鞋子
class nikeshoes : public shoes
{
public:
void show()
{
std::cout << "我是耐克球鞋，我的广告语：just do it" << std::endl;
}
};
// 阿迪达斯鞋子
class adidasshoes : public shoes
{
public:
void show()
{
std::cout << "我是阿迪达斯球鞋，我的广告语:impossible is nothing" << std::endl;
}
};
// 李宁鞋子
class liningshoes : public shoes
{
public:
void show()
{
std::cout << "我是李宁球鞋，我的广告语：everything is possible" << std::endl;
}
};
shoesfactory为工厂类，类里实现根据鞋子类型创建对应鞋子产品对象的createshoes(shoes_type type)函数。enum shoes_type
{
nike,
lining,
adidas
};
// 总鞋厂
class shoesfactory
{
public:
// 根据鞋子类型创建对应的鞋子对象
shoes *createshoes(shoes_type type)
{
switch (type)
{
case nike:
return new nikeshoes();
break;
case lining:
return new liningshoes();
break;
case adidas:
return new adidasshoes();
break;
default:
return null;
break;
}
}
};
main函数，先是构造了工厂对象，后创建指定类型的具体鞋子产品对象，创建了具体鞋子产品的对象便可直接打印广告。因为采用的是new的方式创建了对象，用完了要通过delete 释放资源资源哦！int main()
{
// 构造工厂对象
shoesfactory shoesfactory;
// 从鞋工厂对象创建阿迪达斯鞋对象
shoes *pnikeshoes = shoesfactory.createshoes(nike);
if (pnikeshoes != null)
{
// 耐克球鞋广告喊起
pnikeshoes->show();
// 释放资源
delete pnikeshoes;
pnikeshoes = null;
}
// 从鞋工厂对象创建阿迪达斯鞋对象
shoes *pliningshoes = shoesfactory.createshoes(lining);
if (pliningshoes != null)
{
// 李宁球鞋广告喊起
pliningshoes->show();
// 释放资源
delete pliningshoes;
pliningshoes = null;
}
// 从鞋工厂对象创建阿迪达斯鞋对象
shoes *padidasshoes = shoesfactory.createshoes(adidas);
if (padidasshoes != null)
{
// 阿迪达斯球鞋广告喊起
padidasshoes->show();
// 释放资源
delete padidasshoes;
padidasshoes = null;
}
return 0;
}
[root@lincoding factory]# ./simplefactory 我是耐克球鞋，我的广告语：just do it 我是阿迪达斯球鞋，我的广告语:impossible is nothing 我是李宁球鞋，我的广告语：everything is possible
shoesfactory）：工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。nikeproducer\adidasproducer\liningproducer）：继承于抽象工厂，实现创建对应具体产品对象的方式。shoes）：它是具体产品继承的父类（基类）。nikeshoes\adidasshoes\liningshoes）：具体工厂所创建的对象，就是此类。shoesfactory抽象工厂类，提供了创建具体鞋子产品的纯虚函数。nikeproducer、adidasproducer、liningproducer具体工厂类，继承持续工厂类，实现对应具体鞋子产品对象的创建。// 总鞋厂
class shoesfactory
{
public:
virtual shoes *createshoes() = 0;
virtual ~shoesfactory() {}
};
// 耐克生产者/生产链
class nikeproducer : public shoesfactory
{
public:
shoes *createshoes()
{
return new nikeshoes();
}
};
// 阿迪达斯生产者/生产链
class adidasproducer : public shoesfactory
{
public:
shoes *createshoes()
{
return new adidasshoes();
}
};
// 李宁生产者/生产链
class liningproducer : public shoesfactory
{
public:
shoes *createshoes()
{
return new liningshoes();
}
};
main函数针对每种类型的鞋子，构造了每种类型的生产线，再由每个生产线生产出对应的鞋子。需注意的是具体工厂对象和具体产品对象，用完了需要通过delete释放资源。int main()
{
// ================ 生产耐克流程 ==================== //
// 鞋厂开设耐克生产线
shoesfactory *nikeproducer = new nikeproducer();
// 耐克生产线产出球鞋
shoes *nikeshoes = nikeproducer->createshoes();
// 耐克球鞋广告喊起
nikeshoes->show();
// 释放资源
delete nikeshoes;
delete nikeproducer;
// ================ 生产阿迪达斯流程 ==================== //
// 鞋厂开设阿迪达斯生产者
shoesfactory *adidasproducer = new adidasproducer();
// 阿迪达斯生产线产出球鞋
shoes *adidasshoes = adidasproducer->createshoes();
// 阿迪达斯球鞋广喊起
adidasshoes->show();
// 释放资源
delete adidasshoes;
delete adidasproducer;
return 0;
}
[root@lincoding factory]# ./methodfactory 我是耐克球鞋，我的广告语：just do it 我是阿迪达斯球鞋，我的广告语:impossible is nothing
shoesfactory）：工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。nikeproducer）：继承于抽象工厂，实现创建对应具体产品对象的方式。shoes\clothe）：它是具体产品继承的父类（基类）。nikeshoes\nikeclothe）：具体工厂所创建的对象，就是此类。clothe和shoes，分别为衣服和鞋子的抽象产品类。nikeclothe和nikeshoes，分别是耐克衣服和耐克衣服的具体产品类。// 基类 衣服
class clothe
{
public:
virtual void show() = 0;
virtual ~clothe() {}
};
// 耐克衣服
class nikeclothe : public clothe
{
public:
void show()
{
std::cout << "我是耐克衣服，时尚我最在行！" << std::endl;
}
};
// 基类 鞋子
class shoes
{
public:
virtual void show() = 0;
virtual ~shoes() {}
};
// 耐克鞋子
class nikeshoes : public shoes
{
public:
void show()
{
std::cout << "我是耐克球鞋，让你酷起来！" << std::endl;
}
};
factory为抽象工厂，提供了创建鞋子createshoes()和衣服产品createclothe()对象的接口。nikeproducer为具体工厂，实现了创建耐克鞋子和耐克衣服的方式。// 总厂
class factory
{
public:
virtual shoes *createshoes() = 0;
virtual clothe *createclothe() = 0;
virtual ~factory() {}
};
// 耐克生产者/生产链
class nikeproducer : public factory
{
public:
shoes *createshoes()
{
return new nikeshoes();
}
clothe *createclothe()
{
return new nikeclothe();
}
};
main函数，构造耐克工厂对象，通过耐克工厂对象再创建耐克产品族的衣服和鞋子对象。同样，对象不再使用时，需要手动释放资源。int main()
{
// ================ 生产耐克流程 ==================== //
// 鞋厂开设耐克生产线
factory *nikeproducer = new nikeproducer();
// 耐克生产线产出球鞋
shoes *nikeshoes = nikeproducer->createshoes();
// 耐克生产线产出衣服
clothe *nikeclothe = nikeproducer->createclothe();
// 耐克球鞋广告喊起
nikeshoes->show();
// 耐克衣服广告喊起
nikeclothe->show();
// 释放资源
delete nikeshoes;
delete nikeclothe;
delete nikeproducer;
return 0;
}
[root@lincoding factory]# ./abstractfactory 我是耐克球鞋，让你酷起来！ 我是耐克衣服，时尚我最在行！
以上三种工厂模式，在新增产品时，都存在一定的缺陷。
那么有什么好的方法，在新增产品时，即不用修改工厂类，也不用新增具体的工厂类？
笔者在实际项目中看到一个封装性非常强的工厂类，在扩展新产品时，不需要修改工厂类，也不需要新增具体的工厂类，详细内容可以跳转至c++ 深入浅出工厂模式（进阶篇）阅读。
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
如何在没有core文件的情况下用dmesg+addr2line定位段错误
用QT制作3D点云显示器——QtDataVisualization
网友评论