C++学习——静态成员变量、静态成员函数

以下内容源于C语言中文网的学习与整理，非原创，如有侵权请告知删除。

一、静态成员变量详解

1、被static修饰

1不同的对象占用不同的内存，这使得不同对象的成员变量相互独立，因此它们的值不受其他对象的影响。例如有两个相同类型的对象 a、b，它们都有一个成员变量 m_name，那么修改 a.m_name 的值不会影响 b.m_name 的值。

但有时候我们希望在多个对象之间共享数据，对象 a 改变了某份数据后对象 b 可以检测到。比如计数，以 Student 类为例，如果我们想知道班级中共有多少名学生，就可以设置一份共享的变量，每次创建对象时让该变量加 1。

在C++中，我们可以使用静态成员变量来实现“多个对象共享某个数据”。

静态成员变量是一种特殊的成员变量，它被关键字static修饰，例如：

class Student{
public:
    Student(char *name, int age, float score);
    void show();
public:
    static int m_total;  //静态成员变量
private:
    char *m_name;
    int m_age;
    float m_score;
};

这段代码声明了一个静态成员变量 m_total，用来统计学生的人数。

2、要在类外初始化 

注意，static 成员变量属于类，不属于某个具体的对象。

因此上面例子即使创建多个对象，也只为 m_total 分配一份内存，所有对象使用的都是这份内存中的数据。当某个对象修改了 m_total，也会影响到其他对象。

static 成员变量必须在类声明的外部初始化，初始化格式如下：

//变量的数据类型                                  
data_type class_name::variable_name = value;
          //类名      //变量名         //变量的值

比如将上面的 m_total 初始化： int Student::m_total = 0;（在初始化时不能再加 static，但要加数据类型）。被 private、protected、public 修饰的静态成员变量都可以用这种方式初始化。

static 成员变量的内存既不是在声明类时分配，也不是在创建对象时分配，而是在类外部初始化时分配。反过来说，没有在类外初始化的 static 成员变量不能使用。

static 成员变量既可以通过对象来访问，也可以通过类来访问。请看下面的例子：

//通过类类访问 static 成员变量
Student::m_total = 10;
//通过对象来访问 static 成员变量
Student stu("小明", 15, 92.5f);
stu.m_total = 20;
//通过对象指针来访问 static 成员变量
Student *pstu = new Student("李华", 16, 96);
pstu -> m_total = 20;

3、不占用对象的内存 

static 成员变量不占用对象的内存，而是在所有对象之外开辟内存，即使不创建对象也可以访问。

换言之，static 成员变量和普通的 static 变量类似，都在内存分区中的全局数据区分配内存。

#include 
using namespace std;
 
class Student {
public:
	Student(char *name, int age, float score);
	void show();
private:
	static int m_total;  //静态成员变量
private:
	char *m_name;
	int m_age;
	float m_score;
};
 
//初始化静态成员变量
int Student::m_total = 0;
 
Student::Student(char *name, int age, float score) : m_name(name), m_age(age), m_score(score) {
	m_total++;  //操作静态成员变量
}
void Student::show() {
	cout << m_name << "的年龄是" << m_age << "，成绩是" << m_score << "（当前共有" << m_total << "名学生）" << endl;
}
 
int main() {
 
	cout << sizeof(Student) << endl;
 
	//创建匿名对象
	(new Student("小明", 15, 90))->show();
	(new Student("李磊", 16, 80))->show();
	(new Student("张华", 16, 99))->show();
	(new Student("王康", 14, 60))->show();
 
	return 0;
}

运行结果是：

12
小明的年龄是15，成绩是90（当前共有1名学生）
李磊的年龄是16，成绩是80（当前共有2名学生）
张华的年龄是16，成绩是99（当前共有3名学生）
王康的年龄是14，成绩是60（当前共有4名学生）

从上面代码运行结果可知，静态成员变量m_total不占据对象的内存（否则输出结果应为16）。每次创建对象时，会调用构造函数使 m_total 的值加 1。

4、总结

（1）一个类中可以有一个或多个静态成员变量，所有的对象都共享这些静态成员变量。

（2）static 成员变量和普通 static 变量一样，都在内存分区中的全局数据区分配内存，到程序结束时才释放。这就意味着，static 成员变量不随对象的创建而分配内存，也不随对象的销毁而释放内存。而普通成员变量在对象创建时分配内存，在对象销毁时释放内存。

（3）静态成员变量必须初始化，而且只能在类体外进行。初始化时可以赋初值，也可以不赋值。如果不赋值，那么会被默认初始化为 0。因为全局数据区的变量都有默认的初始值 0，而动态数据区（堆区、栈区）变量的默认值是不确定的，一般认为是垃圾值。

（4）静态成员变量既可以通过对象名访问，也可以通过类名访问，但要遵循 private、protected 和 public 关键字的访问权限限制。

二、静态成员函数详解

在类中，static 除了可以声明静态成员变量，还可以声明静态成员函数。

1、与普通成员函数的区别

普通成员函数有 this 指针，可以访问类中的任意成员；静态成员函数没有 this 指针，只能访问静态成员。

编译器在编译一个普通成员函数时，会隐式地增加一个形参 this 指针，并把当前对象的地址赋值给 this 指针，所以普通成员函数只能在创建对象后通过对象来调用，因为它需要当前对象的地址。

编译器在编译一个静态成员函数时，不会为它增加形参 this 指针，但是静态成员函数可以通过类来直接调用，所以不管有没有创建对象，我们都可以调用静态成员函数。

静态成员函数没有 this 指针，不知道指向哪个对象，因此无法访问对象的普通成员变量和普通成员函数，只能访问静态成员变量和调用静态成员函数。

在C++中，静态成员函数的主要目的是访问静态成员。

普通成员函数也可以访问静态成员，但由于静态成员函数只对静态成员进行操作，它似乎更专一？是因为这个缘故才有静态成员函数？有没有必须用到静态成员函数的情形呢？）

2、例子说明

下面是一个完整的例子，该例通过静态成员函数来获得学生的总人数和总成绩：

#include 
using namespace std;
 
class Student{
public:
    Student(char *name, int age, float score);
    void show();
public:  //声明静态成员函数
    static int getTotal();
    static float getPoints();
private:
    static int m_total;  //总人数
    static float m_points;  //总成绩
private:
    char *m_name;
    int m_age;
    float m_score;
};
 
int Student::m_total = 0;
float Student::m_points = 0.0;
 
Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){
    m_total++;
    m_points += score;
}
void Student::show(){
    cout<"的年龄是"<"，成绩是"<
}
//定义静态成员函数
int Student::getTotal(){
    return m_total;
}
float Student::getPoints(){
    return m_points;
}
 
int main(){
    (new Student("小明", 15, 90.6)) -> show();
    (new Student("李磊", 16, 80.5)) -> show();
    (new Student("张华", 16, 99.0)) -> show();
    (new Student("王康", 14, 60.8)) -> show();
 
    int total = Student::getTotal();
    float points = Student::getPoints();
    cout<<"当前共有"<"名学生，总成绩是"<"，平均分是"<
 
    return 0;
}

小明的年龄是15，成绩是90.6
李磊的年龄是16，成绩是80.5
张华的年龄是16，成绩是99
王康的年龄是14，成绩是60.8
当前共有4名学生，总成绩是330.9，平均分是82.725

（1）静态成员函数一般通过类来调用，也可以通过对象来调用，上例演示如何通过类来调用。 

（2）总人数 m_total 和总成绩 m_points 由各个对象累加得到，必须声明为 static 才能共享。

（3）函数getTotal()、getPoints() 分别用来获取总人数和总成绩，为了访问 static 成员变量，我们将这两个函数声明为 static。当然也可以将它们声明为普通成员函数，但由于它们都只对静态成员进行操作，加上 static 语义更加明确。

（4）和静态成员变量类似，静态成员函数在声明时要加 static，在定义时不能加 static。