单例模式：
懒汉式，在用到的时候才创建对象，分配空间，在多线程的时候会出现多次创建实例的情况
#include<iostream>
#include<pthread.h>
using namespace std;
pthread_mutex_t mutex;
class Singleton
{
private:
static Singleton *mInstance;
static int handlecount;
private:
Singleton()
{
}
public:
static Singleton *GetInstance()
{
pthread_mutex_lock(&mutex);
if(NULL==mInstance)
{
usleep(100000);//多线程涌入，当前一个还没创建的时候后面的就已经进入了判断环节
mInstance=new Singleton;
}
handlecount++;
pthread_mutex_unlock(&mutex);
return mInstance;
}
static int GetHandlecount()
{
return handlecount;
}
void release()
{
handlecount--;
if(handlecount==0&&mInstance!=NULL)
{
delete mInstance;
}
}
};
void * create1(void *arg)
{
Singleton *s1=Singleton::GetInstance();
cout<<s1<<endl;
}
Singleton * Singleton::mInstance=NULL;
int Singleton::handlecount=0;
int main()
{
/* Singleton *s1=Singleton::GetInstance();
cout<<s1<<" "<<s1->GetHandlecount()<<endl;
Singleton *s2=Singleton::GetInstance();
cout<<s2<<" "<<s2->GetHandlecount()<<endl;
if(s1==s2)
{
cout<<"他俩一样"<<endl;
}
Singleton *s3=Singleton::GetInstance();
cout<<s3<<" "<<s3->GetHandlecount()<<endl;
Singleton *s4=Singleton::GetInstance();
cout<<s4<<" "<<s4->GetHandlecount()<<endl;
s1->release();
cout<<s1<<" "<<s1->GetHandlecount()<<endl;
cout<<sizeof(s1)<<endl;*/
pthread_t tidp[20];
int ret ;
ret=pthread_mutex_init(&mutex,NULL);
if(ret !=0)
{
perror("pthream_mutex_create");
}
for(int i=0;i<20;i++)
{
ret=pthread_create(&tidp[i],NULL,create1,NULL);
if(ret !=0)
{
perror("pthream_create");
}
}
void *val;
for(int i=0;i<20;i++)
{
pthread_join(tidp[i],&val);
}
pthread_mutex_destroy(&mutex);
return 0;
}
单例模式——饿汉式（在事前就把空间分配好，就不会出现多线程涌入的时候出现多次创建的问题了）
#include<iostream>
#include<pthread.h>
using namespace std;
pthread_mutex_t mutex;
class Singleton
{
private:
static Singleton *mInstance;
static int handlecount;
private:
Singleton()
{
}
public:
static Singleton *GetInstance()
{
handlecount++;
return mInstance;
}
static int GetHandlecount()
{
return handlecount;
}
void release()
{
handlecount--;
if(handlecount==0&&mInstance!=NULL)
{
delete mInstance;
}
}
};
void * create1(void *arg)
{
Singleton *s1=Singleton::GetInstance();
cout<<s1<<endl;
}
Singleton * Singleton::mInstance=new Singleton;//线程之前就初始化过了，与后面的线程就关系不大了
int Singleton::handlecount=0;
int main()
{
pthread_t tidp[20];
int ret ;
for(int i=0;i<20;i++)
{
ret=pthread_create(&tidp[i],NULL,create1,NULL);
if(ret !=0)
{
perror("pthream_create");
}
}
void *val;
for(int i=0;i<20;i++)
{
pthread_join(tidp[i],&val);
}
pthread_mutex_destroy(&mutex);
return 0;
}简单工厂模式：
通过工厂来创建实例，而不是直接创建
1.工厂（Creator）角色
简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
2.抽象（Product）角色
简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
3.具体产品（Concrete Product）角色
简单工厂模式所创建的具体实例对象
//依赖: 一个类的对象 当另外一个类的函数参数 或者是 返回值
#include<iostream>
#include<cstring>
using namespace std;
class Fruit
{
public:
virtual void show()=0;
};
class Apple:public Fruit
{
public:
void show()
{
cout<<"This is Apple.."<<endl;
}
};
class Banana:public Fruit
{
public:
void show()
{
cout<<"This is Banana.."<<endl;
}
};
class Pear:public Fruit
{
public:
void show()
{
cout<<"This is Pear.."<<endl;
}
};
class Factory
{
public:
Fruit *CreateApple()
{
return new Apple;
}
Fruit *CreateBanana()
{
return new Banana;
}
Fruit *CreatePear()
{
return new Pear;
}
Fruit*Create(char *fruit)
{
if(strcmp(fruit,"Apple")==0)
{
return new Apple;
}
if(strcmp(fruit,"Banana")==0)
{
return new Banana;
}
if(strcmp(fruit,"Pear")==0)
{
return new Pear;
}
}
};
int main()
{
Fruit *f;
Factory *fa=new Factory;
f=fa->Create("Pear");
f->show();
f=fa->CreateApple();
f->show();
delete fa;
delete f;
return 0;
}在这个模式中，工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。不难发现，简单工厂模式的缺点也正体现在其工厂类上，由于工厂类集中了所有实例的创建逻辑，所以“高内聚”方面做的并不好。另外，当系统中的具体产品类不断增多时，可能会出现要求工厂类也要做相应的修改，扩展性并不很好。
工厂模式：
1.概念：
工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。
核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。
2.抽象工厂（Creator）角色
工厂方法模式的核心，任何工厂类都必须实现这个接口。
具体工厂（ Concrete Creator）角色
具体工厂类是抽象工厂的一个实现，负责实例化产品对象。
抽象（Product）角色
工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
具体产品（Concrete Product）角色
工厂方法模式所创建的具体实例对象
3 工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。
工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。
当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了“开放－封闭”原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。工厂方法模式退化后可以演变成简单工厂模式
#include<iostream>
#include<cstring>
using namespace std;
class Fruit
{
public:
virtual void show()=0;
};
class Apple :public Fruit
{
public:
void show()
{
cout<<"这块是苹果"<<endl;
}
};
class Banana :public Fruit
{
public:
void show()
{
cout<<"这块是香蕉"<<endl;
}
};
class Pear :public Fruit
{
public:
void show()
{
cout<<"这块是梨"<<endl;
}
};
class AbsFactory
{
public:
virtual Fruit* Create()=0;
};
class AppleFactory:public AbsFactory
{
public:
Fruit* Create()
{
return new Apple;
}
};
class BananaFactory:public AbsFactory
{
public:
Fruit* Create()
{
return new Banana;
}
};
int main()
{
Fruit *f;
AbsFactory *fa=new BananaFactory;
f=fa->Create();
f->show();
delete fa;
delete f;
return 0;
}抽象工厂模式：
1.概念：抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。
2.抽象工厂（Creator）角色
抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。
具体工厂（ Concrete Creator）角色
具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。
抽象（Product）角色
抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
具体产品（Concrete Product）角色
抽象模式所创建的具体实例对象
3.三种工厂模式的对比
简单工厂 ： 用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力）
工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）
抽象工厂 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
#include<iostream>
using namespace std;
#include<cstring>
class Fruit
{
public:
virtual void show()=0;
};
class NorthApple:public Fruit
{
public:
void show()
{
cout<<"This is NorthApple.."<<endl;
}
};
class NorthBanana:public Fruit
{
public:
void show()
{
cout<<"This is NorthBanana.."<<endl;
}
};
class SouthApple:public Fruit
{
public:
void show()
{
cout<<"This is SouthApple.."<<endl;
}
};
class SouthBanana:public Fruit
{
public:
void show()
{
cout<<"This is SouthBanana.."<<endl;
}
};
class Factory
{
virtual Fruit*CreateApple()=0;
virtual Fruit*CreateBanana()=0;
};
class SouthFactory:public Factory
{
Fruit*CreateApple()
{
return new SouthApple;
}
Fruit*CreateBanana()
{
return new SouthBanana;
}
};
class NorthFactory:public Factory
{
Fruit*CreateApple()
{
return new NorthApple;
}
Fruit*CreateBanana()
{
return new NorthBanana;
}
};
void Create(Factory *fa)
{
Fruit*f=NULL;
f=fa->CreateApple();
f->show();
delete f;
f=fa->CreateBanana();
f->show();
delete f;
}
int main()
{
Factory *fa=new SouthFactory;
Create(fa);
delete fa;
fa=new NorthFactory;
Create(fa);
delete fa;
return 0;
建造者模式：
概念： Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。
对象的创建：Builder模式是为对象的创建而设计的模式- 创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象- 关注对象创建的各部分的创建过程：不同的工厂（这里指builder生成器）对产品属性有不同的创建方法
class A
{
private：
B *b;
}
1) Builder：为创建产品各个部分，统一抽象接口。
2) ConcreteBuilder：具体的创建产品的各个部分，部分A， 部分B，部分C。
3) Director：构造一个使用Builder接口的对象。
4) Product：表示被构造的复杂对象。
ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
建造者模式和工厂模式的区别：
Factory模式中：
1、有一个抽象的工厂。
2、实现一个具体的工厂---汽车工厂。
3、工厂生产汽车A，得到汽车产品A。
4、工厂生产汽车B，得到汽车产品B。
这样做，实现了购买者和生产线的隔离。强调的是结果。
Builder模式:
1、引擎工厂生产引擎产品，得到汽车部件A。
2、轮胎工厂生产轮子产品，得到汽车部件B。
3、底盘工厂生产车身产品，得到汽车部件C。
4、将这些部件放到一起，形成刚好能够组装成一辆汽车的整体。
5、将这个整体送到汽车组装工厂，得到一个汽车产品。
这样做，目的是为了实现复杂对象生产线和其部件的解耦。强调的是过程
两者的区别在于：
Factory模式不考虑对象的组装过程，而直接生成一个我想要的对象。
Builder模式先一个个的创建对象的每一个部件，再统一组装成一个对象。
Factory模式所解决的问题是，工厂生产产品。
而Builder模式所解决的问题是工厂控制产品生成器组装各个部件的过程，然后从产品生成器中得到产品。
#include<iostream>
using namespace std;
class House//首先有一个房子
{
private:
string mwall;
string mdoor;
public:
void SetWall(string w)
{
mwall=w;
}
void SetDoor(string d)
{
mdoor=d;
}
string GetWall()
{
return mwall;
}
string GetDoor()
{
return mdoor;
}
};
class Builder//建造者
{
private:
House *house;
public:
Builder()
{
house=new House;
}
void Constructor(string w,string d)
{
build_wall(w);
build_door(d);
}
House *GetHouse()
{
return house;
}
private:
void build_wall(string w)
{
house->SetWall(w);
}
void build_door(string d)
{
house->SetDoor(d);
}
};
int main()
{
House* house;
Builder *builder=new Builder;
builder->Constructor("LongWall","BigDoor");
house=builder->GetHouse();
cout<<house->GetWall()<<endl;
cout<<house->GetDoor()<<endl;
return 0;
}带设计师的建造者模式#include<iostream>
#include "string"
using namespace std;
class House
{
private:
string mwall;
string mdoor;
public:
void SetWall(string w)
{
mwall=w;
}
void SetDoor(string d)
{
mdoor=d;
}
string GetWall()
{
return mwall;
}
string GetDoor()
{
return mdoor;
}
};
class Builder
{
protected:
House *house;
public:
virtual void Constructor()=0;
virtual void build_wall(string w) = 0;
virtual void build_door(string d)=0;
virtual House *GetHouse()=0;
};
class CommenBuilder:public Builder
{
public:
CommenBuilder()
{
house=new House;
}
void Constructor()
{
build_wall("普通居民房墙");
build_door("普通居民房门");
}
House *GetHouse()
{
return house;
}
private:
void build_wall(string w)
{
house->SetWall(w);
}
void build_door(string d)
{
house->SetDoor(d);
}
};
class VillaBuilder:public Builder
{
public:
VillaBuilder()
{
house=new House;
}
void Constructor()
{
build_wall("别墅房墙");
build_door("别墅房门");
}
House *GetHouse()
{
return house;
}
private:
void build_wall(string w)
{
house->SetWall(w);
}
void build_door(string d)
{
house->SetDoor(d);
}
};
class Designer
{
private:
House *house;
public:
void Constructor(Builder *builder)
{
builder->Constructor();
house=builder->GetHouse();
}
House *GetHouse()
{
return house;
}
};
int main()
{
House *house;
Builder *builder=new CommenBuilder;
Designer *designer=new Designer;
designer->Constructor(builder);
house=builder->GetHouse();
cout<<house->GetWall()<<endl;
cout<<house->GetDoor()<<endl;
return 0;
}原型模式：
概念：Prototype模式是一种对象创建型模式，它采取复制原型对象的方法来创建对象的实例。使用Prototype模式创建的实例，具有与原型一样的数据。
1）由原型对象自身创建目标对象。也就是说，对象创建这一动作发自原型对象本身。
2）目标对象是原型对象的一个克隆。也就是说，通过Prototype模式创建的对象，不仅仅与原型对象具有相同的结构，还与原型对象具有相同的值。
3）根据对象克隆深度层次的不同，有浅度克隆与深度克隆。
#include<iostream>
using namespace std;
class Preson
{
protected:
string name;
int age;
public:
Preson()
{
}
Preson(string n,int a)
{
name=n;
age=a;
}
virtual void show()=0;
};
class Student:public Preson
{
private:
int id;
public:
Student()
{
}
Student(string n,int a,int i):Preson(n,a)
{
id=i;
}
void show()
{
cout<<"name:"<<name<<"age:"<<age<<"id"<<id<<endl;
}
Student *Clone()
{
Student *temp=new Student;
*temp=*this;
return temp;
}
};
int main()
{
Student s1("zhao",20,1);
s1.show();
Student *s2;
s2=s1.Clone();
s2->show();
return 0;
}