设计模式之单身模式

单身模式

1.目的:保证一个类只可以创建唯一一个对象

2.实现:构造函数私有化----->类外不可创建对象

                                    ------>不可被继承

一.类的静态数据成员

1. 在类内定义,类外初始化

(1)定义

static 数据类型  静态成员名

(2)初始化

数据类型 类名:: 静态成员名=初始化值

 

注意:

静态数据成员必须初始化,且只能在类外初始化

在编译阶段系统就会为类的静态数据成员分配单元存储值

 

2.静态数据成员的访问

静态数据成员不通过对象访问

(1)静态数据成员被声明为公有成员

# include <iostream>
using namespace std;

//静态数据成员 
 
class My{
	public:
		static int x;  //类内声明 
		
};

int My::x=1;  //类外初始化

int main(void){
	cout<<"x="<<My::x<<endl;
	My::x=My::x+5;
	cout<<"x="<<My::x<<endl; 
} 

(2)静态数据成员被声明为私有成员

应在静态方法中访问

 

二.类的静态方法

1.定义

static 数据类型 静态方法名 (参数){

}

 

2.静态方法不通过对象调用

public 直接调用

private 调用不了

 

3.在静态方法中可以调用静态数据

#include <iostream>
using namespace std;

//静态方法

class My{
	
	private:
		static int x;
		
	public :
		
		static void print(){		//公有可访问私有,静态可访问静态 
			cout<<"x="<<x<<endl;
		}
		
		static int add(int n){
			x=x+n;
			return x;
		} 
};

int My::x=0;


int main(void){
	My::print();
	int sum=My::add(6);
	cout<<"t="<<sum<<endl;
}

 

三.区分静态数据和非静态数据

1.静态数据属于类,直接初始化,直接引用

2.非静态数据属于对象,通过构造进行初始化,通过对象引用

#include<iostream>
using namespace std;

class My{
	private:
		int x,y;
		static int z;
	public:
		My(){
			x=0;
			y=0;
		}
		
		My(int i,int j){
			x=i;
			y=j;
		}
		
		void print(){
			cout<<x<<","<<y<<endl; 
		} 
};

int My::z=0;

int main(void){
	My *pmy=new My(3,4);
	pmy->print();
} 

 

四.实例

类My 有成员变量x
要求:    声明构造函数并初始化x
        创建对象my1(3),my2(4),new my3(5)
        将三个对象的x存入静态变量sum中,并输出 

# include <iostream>
using namespace std;

/**
类My 有成员变量x
要求:	声明构造函数并初始化x
		创建对象my1(3),my2(4),new my3(5)
		将三个对象的x存入静态变量sum中,并输出 
*/

class My{
	private:
		int x;
		static int sum;
	public :
		My(){
			x=0;
		}
		
		My(int i){
			x=i;
		}
		
		static void addPrint(My*t1,My*t2,My*t3){
			sum=t1->x+t2->x+t3->x;
			cout<<"sum="<<sum<<endl; 
		}
}; 

int My::sum=0;

int main(void){
	My my1(3);
	My my2(4);
	My *pmy3=new My(5);
	My::addPrint(&my1,&my2,pmy3);
	delete(pmy3); 
}

 

五.单身模式具体代码实现

#include <iostream>
using namespace std;

class singleton {
	private:
		static singleton *Instance;
		singleton(){
			cout<<"单例模式\n"; 
		} 
	public:
		static singleton *create(){
			if(!Instance){
				Instance=new singleton();
			}
			return Instance;
		}
};

singleton* singleton::Instance=NULL;

int main(void){
	singleton *p;
	p=singleton::create();
	singleton *p2;
	p2=singleton::create();
	singleton *p3;
	p3=singleton::create();
}