C++（static）静态成员变量和静态成员函数

static int a = 10;//在静态区分配空间，不在堆栈

在静态区分配空间，不在堆栈分配空间。因此，只有等到所以程序全部执行完成后，才会释放空间。

一.static修饰变量

void text() {
	static int a = 10;
	a++;
	cout <<"a=" << a << endl;
}
int main(int arg, char** args) {
	text();
	text();
}

结果：

二.static修饰函数

此函数的作用域只在本文件，其他文件无法调用。

文件一：
#include <iostream>
using namespace std;
extern  void test();
int main() {
	test();
}
文件二：
#include <iostream>
using namespace std;
static void test() {
	cout << "123" << endl;
}

结果：

三.static在类中使用

1. static成员变量实现了同类对象间信息共享。
2. static成员类外存储，求类大小，并不包含在内。
3. static成员是命名空间属于类的全局变量，存储在data区（静态区）。
4. static成员只能在类外初始化。
5. 可以通过类名访问（无对象生成时亦可），也可以通过对象访问。

1.创建与初始化

静态成员变量初始化，一定在类外。

class AA {
public:
static int m_c;
	AA(int a, int b) {
		m_a = a;
		m_b = b;
	}	
	~AA() {
		cout << "m_a=" << m_a << "	m_b=" << m_b << "	m_c=" << m_c << "	m_d=" << m_d << endl;
	}
private:
	int m_a;
	int m_b;
	static int m_d;
};
int AA::m_c = 0;//public下静态变量初始化
int AA::m_d = 1;//private下静态变量初始化
int main(int arg, char** args) {
	AA a1(1, 2);
}

结果：

2.使用问题
例子1：

class AA {
public:
	AA(int a, int b) {
		m_a = a;
		m_b = b;
	}
	static int m_c;
	int get_c() {
		m_c++;
		return m_c;
	}
private:
	int m_a;
	int m_b;
};
int AA::m_c = 0;
int main(int arg, char** args) {
	AA a1(1, 2);
	AA a2(10, 20);
	cout <<"a1(1, 2)下的c：" << a1.get_c() << endl;
	cout << "a2(10, 20)下的c：" << a2.get_c() << endl;
}

结果：

原因：因为static分配变量在静态区，因此类AA下所有变量（a1、a2）共用一个m_c。

因此，类中public下的static变量可以使用下面。访问。但是private不可用。

cout<<AA::m_c << endl;

3.在public、private下static变量使用
在public下：可以通过AA::m_c = 100直接访问和修改static变量值。

class AA {
public:
	AA(int a, int b) {
		m_a = a;
		m_b = b;
	}
	static int m_c;
private:
	int m_a;
	int m_b;
};
int AA::m_c = 0;
int main(int arg, char** args) {
	AA::m_c = 100;
	cout << AA::m_c << endl; 
}

在private下：必须提供函数，才能访问和修改static变量值。

class AA {
public:
	AA(int a, int b) {
		m_a = a;
		m_b = b;
	}
	static void set_md(int d) {
		m_d = d;
	}
	static int get_md() {
		return m_d;
	}
private:
	int m_a;
	int m_b;
	static int m_d;
};
int AA::m_d = 1;
int main(int arg, char** args) {
	AA::set_md(100);
	cout << AA::get_md() << endl;	
}

结果：

4.分文件编写使用j静态函数对static成员变量初始化
必须先在.cpp文件中先初始化，在调用静态函数进行初始化。
Account_1.h

class Account_1 :public Account
{
private:
	static double rate;//静态变量
public:
	Account_1(int id, char* name, double money, char* date) :Account(id, name, money, date) {}
	static void setRate(const double & rate1);//静态函数
	void calculateMoney();
};

Account_1.cpp

#include "Account_1.h"
double Account_1::rate = 0;//使用静态函数给静态变量初始化，必须先进行初始化，否则会报错
void Account_1::setRate(const double &rate) //调用静态函数
{
	Account_1::rate = rate;
}
void Account_1::calculateMoney() {
	this->money = this->money + this->money * rate;
}

四.class含有static变量所占空间

class A {
private:
	int a;
	int b;
	static int c;
};
int main() {
	cout << sizeof(A) << endl;
}

结果：

结果：居然是8，不是12。因为static成员是命名空间属于类的全局变量，存储在data区（静态区）。

五.练习题：求学生总人数、总分、平均分系统。

#include <iostream>
using namespace std;

class Student {
private:
	int m_id;
	double m_score;
	static int count;
	static double total_score;
public:
	Student(int id,double score) {
		m_id = id;
		m_score = score;
		count++;
		total_score += m_score;
	}
	static double get_total_score() {
		return total_score;
	}
	static double get_count() {
		return count;
	}
};
int Student::count = 0;
double Student::total_score = 0.0;
int main(int arg, char** args) {
	Student S1(1, 50.1), S2(2, 10.1), S3(3, 0.1);
	//double mean_score = 0.0;
	cout << "学生人数：" << Student::get_count() << endl;
	cout << "学生总分：" << Student::get_total_score() << endl;
	cout << "学生平均分" << Student::get_total_score() / Student::get_count() << endl;
}