目的:为了可重用代码,提高代码的可扩展性和可维护性
本文仅记录单例模式与工厂模式
六大原则
单一职责:一个类和方法只做一件事
里氏替换:父类可替换为子类,但子类不可替换为父类(子类有自己的个性)
依赖倒置:实现类依赖抽象类,实现类之间没有依赖
接口隔离:建立单一接口
迪米特原则:一个对象应对其他对象有最少了解
,减少耦合
开闭原则:新功能应该添加新模块,而不是修改现有模块
工厂模式
属于创建者模型,提供创建对象的机制。工厂模式创建对象时不会对用户暴露创建逻辑,而是通过一个共同的接口来指向新创建的对象
实现方式有简单工厂、工厂方法
简单工厂
组成:工厂类(定义一个创建产品对象的方法)、产品类(具体产品)、抽象类(用于派生产品类)
特点:工厂类集中创建对象,新增产品需要修改工厂类
class Car
{
public:
virtual ~Car(){}
virtual void show()=0;
};
class Benz:public Car
{
public:
void show()
{
std::cout<<"this is Benz"<<std::endl;
}
};
class BMW:public Car
{
public:
void show()
{
std::cout<<"this is BMW"<<std::endl;
}
};
class Factory
{
public:
Car *CreateCar(CAR_TYPE type)
{
switch(type)
{
case 0:
return new Benz();
break;
case 1:
return new BWM();
break;
default:
return nullptr;
break;
}
}
};
int main()
{
Factory CarFactory;
Car *pBenz=CarFactory.CreateCar(0);
if(pBenz)
{
pBenz->show();
delete pBenz;
pBenz=nullptr;
}
return 0;
};
工厂方法
组成:抽象工厂类(提供创建产品对象的接口,具体工厂实现)、具体工厂类(实现创建产品对象)、产品类(具体产品)、抽象类(用于派生产品类)
特点:符合开闭原则,更利于扩展
class CarFactory
{
public:
virtual ~CarFactory(){}
virtual Car *CreateCar()=0;
};
class BenzFactory
{
public:
Car *CreateCar()
{
return new Benz();
}
};
class BWMFactory
{
public:
Car *CreateCar()
{
return new BWM();
}
};
int main()
{
CarFactory *BenzProducer=new BenzFactory();
Car *benz=BenzProducer->CreateCar();
benz->show();
delete benz;
delete BenzProducer;
return 0;
}
单例模式
属于创建者模型。单例模式保证一个类只有一个实例化对象,对外提供访问其对象的接口
懒汉式
首次调用才初始化
使用局部静态变量保证线程安全
class Single
{
public:
static Single *GetInstance();
private:
Single(){}
~Single(){}
};
Single *Single::GetInstance()
{
static Single signal;
return &signal;
}
饿汉式
程序运行时即初始化
class Single
{
public:
static Single *GetInstance();
static void deleteInstance();
private:
Single(){}
~Single(){}
private:
static Single *p_Single;
};
Single *Single::p_Single=new Single();
Single *Single::GetInstance()
{
return p_Single;
}
void Single::deleteInstance()
{
if(p_Single)
{
delete p_Single;
p_Single=nullptr;
}
}