饿汉单例模式：（是线程安全的）
一个类不管创建多少次对象，永远只能得到该类型一个对象的实例！
class Singleton
{
public:
static Singleton* getInstance()//获取类的唯一实例对象接口方法
{
return &instance;
}
private:
static Singleton instance;//定义一个唯一的类的实例对象
Singleton()
{
}
Singleton(const Singleton&)=delete;
Singleton& operator=(const Singleton&)=delete;
};
Single Single::instance;
int mian()
{
Singleton* p1 = Singleton::getInstance();
Singleton* p2 = Singleton::getInstance();
Singleton* p3 = Singleton::getInstance();//以上三个地址一样！
return 0;
}
懒汉单例模式：
唯一的实例对象，直到第一次获取它的时候，才产生对象！！！
是否线程安全？是不是可重入函数？
不是线程安全的：instance==nullptr可能会进去多次！因为三个步骤到第二步时间片到了就完了！
class Singleton
{
public:
static Singleton* getInstance()//获取类的唯一实例对象接口方法
{
if(instance == nullptr)
{
instance = new Singleton();//1.开辟内存2.构造函数3.赋值
}
return instance;
}
private:
static Singleton* instance;//定义一个唯一的类的实例对象
Singleton()
{
}
Singleton(const Singleton&)=delete;
Singleton& operator=(const Singleton&)=delete;
};
Singleton* Singleton::instance = nullptr;
int mian()
{
Singleton* p1 = Singleton::getInstance();
Singleton* p2 = Singleton::getInstance();
Singleton* p3 = Singleton::getInstance();//以上三个地址一样！
return 0;
}
改进：
static Singleton* getInstance()//获取类的唯一实例对象接口方法
{
if(instance == nullptr)
{
lock_guard<std::mutex> guard(mtx);
if(instance == nullptr)//锁+二重判断！
{
instance = new Singleton();//1.开辟内存2.构造函数3.赋值
}
}
return instance;
}
经过改造才是一个线程安全的懒汉式的单例模式！
也可以这样写：
简单工厂、工厂方法、抽象工厂：
工厂模式：主要是封装了对象的创建！
简单工厂：
class Car
{
public:
Car(string name):_name(name){}
virtual void show() = 0;
protected:
string _name;
};
class Bmw:public Car
{
public:
Bmw(string name):Car(name){}
void show()
{
cout << "获取Bmw汽车" << endl;
}
};
class Audi:public Car
{
public:
Audi(string name):Car(name){}
void show()
{
cout << "获取Audi汽车" << endl;
}
};
enum CarType
{
BMW,AUDI
};
class SimpleFactory()
{
public:
Car* createCar(CarType ct)
{
switch(ct)
{
case BMW:
return new Bmw("X1");
case AUDI:
return new Audi("A6");
default:
cerr << "参数错误！" << ct << endl;
break;
}
return nullptr;
}
};
int main()
{
//SimpleFactory* factory = new SimpleFactory();
unique_ptr<SimpleFactory> factory(new SimpleFactory());
//Car* p1 = factory->createCar(Bmw);
//Car* p2 = factory->createCar(AUDI);
unique_ptr< Car> p1(factory->createCar(Bmw));
unique_ptr< Car> p2(factory->createCar(AUDI));
p1->show();
p2->show();
return 0;
}
工厂方法：
抽象工厂：
// 系列产品2
class Light
{
public:
virtual void show() = 0;
};
class BmwLight : public Light
{
public:
void show() { cout << "BMW light!" << endl; }
};
class AudiLight : public Light
{
public:
void show() { cout << "Audi light!" << endl; }
};
// 工厂方法 => 抽象工厂(对有一组关联关系的产品簇提供产品对象的统一创建)
class AbstractFactory
{
public:
virtual Car* createCar(string name) = 0; // 工厂方法 创建汽车
virtual Light* createCarLight() = 0; // 工厂方法 创建汽车关联的产品，车灯
};
// 宝马工厂
class BMWFactory : public AbstractFactory
{
public:
Car* createCar(string name)
{
return new Bmw(name);
}
Light* createCarLight()
{
return new BmwLight();
}
};
// 奥迪工厂
class AudiFactory : public AbstractFactory
{
public:
Car* createCar(string name)
{
return new Audi(name);
}
Light* createCarLight()
{
return new AudiLight();
}
};
int main()
{
// 现在考虑产品 一类产品（有关联关系的系列产品）
unique_ptr<AbstractFactory> bmwfty(new BMWFactory());
unique_ptr<AbstractFactory> audifty(new AudiFactory());
unique_ptr<Car> p1(bmwfty->createCar("X6"));
unique_ptr<Car> p2(audifty->createCar("A8"));
unique_ptr<Light> l1(bmwfty->createCarLight());
unique_ptr<Light> l2(audifty->createCarLight());
p1->show();
l1->show();
p2->show();
l2->show();
return 0;
}
不是一个产品一个工厂，而是一个工厂一系列的产品都做！
简单工厂：把对象创建封装在一个接口函数里面，通过传入不同的标识，返回创建的对象，客户不用自己负责new对象，不用了解对象创建的详细过程。提供创建对象实例的接口函数不闭合，不能对修改闭合
工厂方法：提供了一个纯虚函数（创建产品），定义派生类负责创建对应的产品，在不同的工厂里面创建，能够对现有工厂以及产品的修改关闭。实际上很多产品是有关联关系的，属于一个产品族，不应该放在一个工厂里面创建，这样一是不符合实际的产品对象创建逻辑，二是工厂类太多了。
抽象工厂：
把有关联关系的，属于一个产品族的所有产品创建的接口函数，放在一个抽象工厂里面，派生类应该负责创建该产品族里面所有的产品