C++笔记：静态成员函数和静态成员变量的使用

---

前言

---

静态成员的访问和静态成员变量的地址

#include <iostream>
using namespace std;
class Car {
public:
	int m_age;
	static int m_price;
	static void run(int m_price) {
		cout << "run(int m_price):" << m_price << endl;
	}
	 
};
int Car::m_price = 0;
class BigCar : public Car{

};
int main()
{
	//通过对象访问
	Car car;
	car.m_price = 100;
	car.run(car.m_price);

	//通过对象指针访问
	Car* p = new Car;
	p->m_price = 200;
	p->run(p->m_price);

	//通过类名访问
	cout << & Car::m_price << endl;
	cout << &BigCar::m_price << endl;

	cout << &Car::m_price << endl;
	cout << &BigCar::Car::m_price << endl;


	return 0;
}

out为

run(int m_price):100
run(int m_price):200
007CC3D4
007CC3D4
007CC3D4
007CC3D4

一个对象计数的问题

#include <iostream>
using namespace std;
class Car {
private:
	static int ms_count;//static只有一份内存；private在类外无法访问
public:
	Car() {
		ms_count++;
	}
	~Car() {
		ms_count--;
	}
	static int getCount() //加static后可以通过类名访问
	{
		return ms_count;
	}
};
int Car::ms_count= 0;

Car car;

int main()
{
	//通过对象访问
	Car car0;
	

	//通过对象指针访问
	Car* p = new Car;
	

	//通过类名访问
	cout << Car::getCount() << endl;


	return 0;
}

out

3

单例模式

单例模式的作用就是保证类只能创建一个对象

#include <iostream>
using namespace std;
class Car {
private:
	Car() {}//构造函数私有化	
	~Car() {}//析构函数私有化，防止delete
	static Car* ms_Car; //在类里面创建一个指针对象，尽量不要写成static Car ms_Car
public:
	static Car* sharedCar() {
		if (ms_Car == NULL)
		{
			ms_Car = new Car();

		}
		return ms_Car;
	}
	static void deleteCar()
	{
		if (ms_Car != NULL)
		{
			delete ms_Car;//将堆空间清理掉，但指针仍然有值
			cout << Car::ms_Car << endl;
			ms_Car = NULL;//将指针清空
			cout << Car::ms_Car << endl;
		}
	}
	void run() {
		cout << "run()" << endl;
	}

};

Car* Car::ms_Car = NULL;//将指针对象初始化

int main()
{

	//通过类名访问
	Car* p0 = Car::sharedCar();
	Car* p1 = Car::sharedCar();
	Car* p2 = Car::sharedCar();

	cout << p0 << endl;
	cout << p1 << endl;
	cout << p2 << endl;


	Car::deleteCar();//将堆空间清理掉，但指针仍然有值
	

	return 0;
}

out为

0135B580
0135B580
0135B580
0135B580
00000000