static类成员

静态成员：被static修饰的成员变量、函数 

静态成员变量 

1、静态成员变量存储在数据段(全局区，类似于全局变量)，整个程序运行过程中只有一份内存

2、对比全局变量，他可以设定访问权限(public、protected、private)，达到局部共享的目的

3、必须初始化，而且必须在类外面初始化，初始化时不能带static，如果类的声明和实现分离，在实现.cpp文件初始化。

静态成员函数

1、内部不能使用this指针(this指针只能用在非静态成员函数内部)

2、不能是虚函数（(虚函数只能是非静态成员函数)

3、内部不能访问非静态成员变量/函数，只能访问静态成员变量\函数

4、非静态成员函数内部可以访问静态成员变量\函数

5、构造函数、析构函数不能是静态

我们知道 C++ 类的静态成员变量是需要初始化的，但为什么要初始化呢。其实这句话 “静态成员变量是需要初始化的” 是有一定问题的，应该说 “静态成员变量需要定义” 才是准确的，而不是初始化。两者的区别在于：初始化是赋一个初始值，而定义是分配内存。静态成员变量在类中仅仅是声明，没有定义，所以要在类的外面定义，实际上是给静态成员变量分配内存。可以通过以下几个例子更形象的说明这个问题：

//test.cpp
#include <stdio.h>
class A {
public:
static int a; //声明但未定义，还未分配内存
};
int main() {
printf("%d", A::a);
return 0;
}

编译以上代码会出现 “对‘A::a’未定义的引用” 错误。这是因为静态成员变量 a 未定义，也就是还没有分配内存，显然是不可以访问的。再看如下例子：

//test.cpp
#include <stdio.h>
class A {
public:
static int a; //声明但未定义
};
int A::a = 3; //定义了静态成员变量，同时初始化。也可以写"int A:a;"，即不给初值，同样可以通过编译
int main() {
printf("%d", A::a);
return 0;
}
 

 这样就对了，因为给 a 分配了内存，所以可以访问静态成员变量 a 了。因为类中的静态成员变量仅仅是声明，暂时不需分配内存，所以我们甚至可以这样写代码：

//a.cpp
class B; //这里我们使用前置声明，完全不知道B是什么样子
class A {
public:
static B bb;//声明了一个类型为B的静态成员，在这里编译器并未给bb分配内存。
//因为仅仅是声明bb,所以编译器并不需要知道B是什么样子以及要给其对应的对象分配多大的空间。
//所以使用前置声明"class B"就可以保证编译通过。
};

注意：尽量通过静态方法访问静态变量

#include <iostream>
#include <string>
using namespace std;

class Person
{
public:
	static void funSta(double rate)
	{
		inteRate = rate;
	}
	static double reSta()
	{
		return inteRate;
	}
private:
	static double inteRate;

};

//double Person::inteRate = 30;

int main()
{
	//cout << Person::ins << endl;
	Person::funSta(0.05);
	cout << Person::reSta() << endl;

	system("pause");
	return 0;
}

单例模式

单例模式：设计模式的一种，保证某个类永远只创建一个对象

1、构造函数\析构函数私有化

2、定义一个私有的static成员变量指向唯一的那个单例对象

3、提供一个公共的访问对象的接口

#include <iostream>
using namespace std;

class Rocket
{
private:
	Rocket(){}
	~Rocket() {}
	static Rocket* ms_rocket;
public:
	static Rocket* shareRocket()
	{
		//这里要考虑多线程安全问题
		if (ms_rocket == NULL)
		{
			ms_rocket = new Rocket();
		}
		return ms_rocket;
	}

	static void deleteRocket()
	{
		if (ms_rocket != NULL)
		{
			delete ms_rocket;
			//避免产生野指针：指向已经回收掉的内存
			ms_rocket = NULL;
		}
	}

	void run()
	{
		cout << "对象创建成功！" << endl;
	}
};

Rocket* Rocket::ms_rocket = NULL;

int main()
{
	//Rocket r1;
	//Rocket *r = new Rocket();
	Rocket* rocket = Rocket::shareRocket();
	rocket->run();
	//delete rocket;  析构函数私有化
	return 0;
}