一、静态成员变量

在一个类中，若将一个成员变量声明为static，这种成员称为静态成员变量，与一般的数组成员不同，无论建立了多少个对象，都只有一个静态数据的拷贝。静态成员变量，属于某个类，所有对象共享。

静态变量，是在编译阶段就分配空间，对象还没有创建时，就已经分配空间。

-）静态成员变量必须在类中声明，在类外定义

-）静态数据成员不属于某个对象，在为对象分配空间中不包括静态成员所占空间。

-）静态数据成员可以通过类名或者对象名来引用

  #include<iostream>
 using namespace std;
 
 class PerSon
 {
 public:
 	//静态成员变量
 	//1.共享
 	//2.在编译阶段就分配内存
 	//3.必须在类内声明 类外进行初始化
 	static int m_A;
 private:
 	static int m_B;//私有权限数据 类外不可访问
 };
 int PerSon::m_A = 10;//静态成员变量
 int PerSon::m_B = 11;
 void test01()
 {
 	//访问方式
 	//1.通过对象进行访问
 	PerSon p1;
 	cout << "p1的m_A"<<p1.m_A << endl;
 	PerSon p2;
 	p2.m_A = 20;
 	cout << "p1的m_A" << p1.m_A << endl;
 	cout << "p2的m_A" << p2.m_A << endl;
 
 	//2.通过类名进行访问
 	cout << "m_A: " << PerSon::m_A << endl;
 
 	//静态成员变量也是有访问权限的
 	//PerSon::m_B = 100;//无法访问
 }
 int main()
 {
    	return 0;
 }

二、静态成员函数

在函数成员前 + static

该函数一直有一份

 #include<iostream>
 using namespace std;
 
 class PerSon
 {
 public:
 	void func2() //非静态成员函数 可以访问静态成员变量 也可以访问非静态成员变量
 	{
	m_C = 1000;
	m_A = 1000;
 	}
 	static int m_A;
 	static void func()
 	{
	m_C = 100;//静态成员函数不可以访问非静态成员函数，因为无法区分变量归属于谁
	m_A = 100;//静态成员函数 可以访问静态成员变量 因为都是共享数据
	cout << "静态成员函数调用" << endl;
 	}
 	int m_C;
 private:
 	static void func3() { cout << "aaa" << endl; };
 };
 
 void test02()
 {
 	//通过对象调用
 	PerSon p1;
 	p1.func();
 
 	//通过类名进行调用
 	PerSon::func();
 	PerSon::func3();//静态成员函数也是有访问权限的，私有的权限类外访问不到
 
 }
 int main()
 {
 	return 0;
 }

三、单例模式

一个类中只有唯一的一个实例对象

私有化：

默认构造函数

拷贝构造函数

唯一对象指针变成只读状态

对外提供公共接口 static ChairMan * getinstance()

  #include<iostream>
 using namespace std;
 
 class ChairMan
 {
 public:
 	//返回主指针
 	static ChairMan * getinstance()
 	{
	return singleMan;
 	}
 private:
 	//将构造函数私有化，不可以创建多个对象
 	ChairMan() { cout << "ChairMan默认函数调用<<endl"; };
 	//数据是共享的 我们只需要拿到一个对象指针即可
 //public:
 private:
 	static ChairMan *singleMan;
 };
 ChairMan * ChairMan::singleMan = new ChairMan; //唯一的对象指针
 
 void test01()
 {
 	//ChairMan c1;
 	//ChairMan c2;
 	//ChairMan * c3 = new ChairMan;
 	//ChairMan * c1= ChairMan::singleMan;
 	//ChairMan * c2 = ChairMan::singleMan;
 	ChairMan * c1 = ChairMan::getinstance();
 	ChairMan * c2 = ChairMan::getinstance();
 	if (c1 = c2)
 	{
	cout << "c1与c2相等" << endl;
 	}
 	else
 	{
	cout << "c1与c2不相等" << endl;
 	}
 }
 int main()
 {
 	test01();
  	return 0;
 }

四、对象模型初探

-）成员变量和成员函数分开储存

-）一个类中只有非静态成员变量属于类的大小，其他都不计算在类内部

-）空类大小为：1 class PerSon {

 };
  class ParSon
  {
  	int m_A; ////成员属性 算在类的大小中
  	//成员函数并不算在类的大小中
  	void func()
   	{
  
 	}
  	static int m_B; //静态成员变量，不属于类的大小中
   	static void func2()//静态成员函数，不属于类的大小中
   	{
 
 	}
   };
 void test01()
  {
 	//空类大小为：1
  	//空类也是可以实例化对象的，每个对象在内存中都应该有独一无二的地址
 	//PerSon p[10]:p[0] p[1]
   	cout << sizeof(PerSon) << endl;
  }
  int main()
 {
 	test01();
 	return 0;
 }

C++静态成员与单例模式

一、静态成员变量

二、静态成员函数

三、单例模式

四、对象模型初探