day11_静态函数与静态成员

静态成员

• 静态成员:被static修饰的成员变量\函数

  • 可以通过对象(对象.静态成员)、对象指针(对象指针->静态成员)、类访问(类名::静态成员)

• 静态成员变量

  • 存储在数据段(全局区，类似于全局变量)，整个程序运行过程中只有一份内存
  • 对比全局变量，它可以设定访问权限(public、protected、private)，达到局部共享的目的
  • 必须初始化，必须在类外面初始化，初始化时不能带static，如果类的声明和实现分离(在实现.cpp中初始化)

• 静态成员函数

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

• 不能是虚函数(虚函数只能是非静态成员函数)

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

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

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

• 当声明和实现分离时，实现部分不能带static

#include <iostream>
using namespace std;

class Person {
public:
	static int ms_count;
};

class Student : public Person {

};

int Person::ms_count = 0;

int main() {

	Person::ms_count = 20;
	Student::ms_count = 10;

	cout << Person::ms_count << endl;

	getchar();
	return 0;
}

//class Car {
//private:
//	static int m_count;
//public:
//	Car() {
//		m_count++;
//	}
//	~Car() {
//		m_count--;
//	}
//	static int getCount() {
//		return m_count;
//	}
//};
//
//int Car::m_count = 0;
//
//int main() {
//	/*Car car1;
//	Car car2;
//	Car *p = new Car();
//	delete p;
//
//	cout << car1.getCount() << endl;*/
//
//	cout << Car::getCount() << endl;
//
//	/*Car car1;
//	car1.m_count = 10;
//	car1.getCount();
//
//	p->m_count = 10;
//	p->getCount();
//
//	Car::m_count = 20;
//	Car::getCount();*/
//
//	getchar();
//	return 0;
//}

//class Car {
//public:
//	static int m_price;
//	void run() {
//		cout << "run()" << endl;
//
//	}
//};
//
//// 初始化静态成员变量
//int Car::m_price = 0;
//
//int main() {
//	Car car;
//	car.m_price = 10;
//
//	Car car2;
//	car2.m_price = 20;
//
//	Car::m_price = 30;
//
//	Car *p = new Car();
//	p->m_price = 40;
//
//	Car car3;
//	cout << car3.m_price << endl;
//
//
//	getchar();
//	return 0;
//}

静态函数的应用

/*
单例模式：
在程序运行过程中，可能会希望某些类的实例对象永远只有一个

1.把构造函数私有化
2.定义一个私有的静态成员变量指针，用于指向单例对象
3.提供一个公共的返回单例对象的静态成员函数
*/

//class Person {
//public:
//	static int ms_count;
//	virtual void run() {
//
//	}
//};
//
//int Person::ms_count = 0;
//
//class Student : public Person {
//public:
//	static int ms_count;
//	void run() {
//		ms_count = 10;
//	}
//};
//
//int Student::ms_count = 0;
//
//
//int main() {
//
//	Person::ms_count = 10;
//	Student::ms_count = 20;
//
//	cout << Person::ms_count << endl;
//	cout << Student::ms_count << endl;
//
//
//	getchar();
//	return 0;
//}

class Rocket {
public:
	// C++：静态成员函数
	// Java、OC：类方法
	static Rocket * sharedRocket() {
		// API p_thread
		if (ms_rocket == NULL) {
			ms_rocket = new Rocket();
		}
		return ms_rocket;
	}
	static void deleteRocket() {
		static Rocket *ms_rocket;
		if (ms_rocket == NULL) return;

		delete ms_rocket;
		ms_rocket = NULL;
	}
	static Rocket *ms_rocket;
private:
	Rocket() {
		cout << "Rocket()" << endl;
	}
	~Rocket() {
		cout << "~Rocket()" << endl;
	}
};

Rocket *Rocket::ms_rocket = NULL;

int main() {
	int *p = new int();
	*p = 5;
	delete p;
	p = NULL;

	cout << *p << endl;

	// mac
	// xcode


	Rocket *p1 = Rocket::sharedRocket();
	// ......
	Rocket::deleteRocket();


	Rocket *p2 = Rocket::sharedRocket();
	Rocket::deleteRocket();

	/*Rocket *p1 = Rocket::sharedRocket();
	Rocket *p2 = Rocket::sharedRocket();
	Rocket *p3 = Rocket::sharedRocket();
	Rocket *p4 = p3->sharedRocket();

	cout << p1 << endl;
	cout << p2 << endl;
	cout << p3 << endl;
	cout << p4 << endl;*/

	getchar();
	return 0;
}