C++ | 说说类中的static成员-Toy模板网

这篇具有很好参考价值的文章主要介绍了C++ | 说说类中的static成员。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

C++ | 说说类中的static成员

【概念】：声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化

一、面试题引入

💬面试题：实现一个类，计算程序中创建出了多少个类对象

上面这个是曾经一家公司的面试题，要你用一个类去计算创建出多少个对象。分析一下可以知道我们去实例化出一个对象的时候，无非是调用构造或者是拷贝构造，或者是通过一些传参返回的方式去构造对象
那第一时间就会想到在全局定义一个count，然后在可能产生构造的地方进行累加

int count = 0;
class A {
	A()
	{
		count++;
	}

	A(const A& a)
	{
		count++;
	}
};

void func(A a)
{
	count++;
}
int main(void)
{
	A aa1;
	A aa2(aa1);
	
	func(aa1);
	return 0;
}

但是编译后可以发现，count++的地方都出现了报错，说是不明确的问题

C++ | 说说类中的static成员

但是你仔细去看输出窗口的话可以发现其实这个count是和【std库】中的count发生了冲突

C++ | 说说类中的static成员

那这个时候该怎么办呢？

💬有同学说：这还不简单，不要写成count不就可以了，改成Count都可以

确实，这不乏是一种直截了当的方法。但是同学，我们现在学习的是C++而不是C语言，改成大写的这种方式是C语言思路

C++ | 说说类中的static成员

还记得我们在细谈namespace命名空间说到的部分展开命名空间吗？和std库里发生冲突就是因为using namespace std;展开了std的命名空间，在这里我们只需要部分展开即可

using std::cout;
using std::endl;

此时通过调试再去观察就可以看出创建了多少个对象

C++ | 说说类中的static成员

但这个时候呢，我手比较欠缺👏，对这个count又去++了几下，此时最后的结果就出现问题了

C++ | 说说类中的static成员

二、static特性细述

可以看到对于上面这种问题在C语言中是无法避免的，因为count是一个全局变量，那么它的生命周期就是从定义开始到main函数结束的时候销毁，这任何地方都是可以访问到的，并且它还不具有常性可以做任意修改，这其实也就缺乏了一定的安全性

于是呢，在C++中就引入了这样一个东西，把count作为类的成员函数

class A {
public:
	A(int a = 0)
	{
		count++;
	}

	A(const A& a)
	{
		count++;
	}
private:
	int count = 0;
};

但是对于这个count而言还是属于某个对象的，但我们若要去统计的话它一定不是专属于某个对象的，而是要属于所有对象。此时我们就可以用static来修饰一下这个成员变量

static int count = 0;

此时这个count便被包裹在了这个类中，我们知道类也是一个作用域，可以起到隔绝外界的作用，那么此时我们的count就不会和库里面的count冲突了，直接展开std命名空间也不会存在问题
static其实我们在C语言中也有学到过，若一个变量被static修饰的话，它就不会放到在【栈区】了，而是在【静态区中】

此时就引出了static的第一条特性如下👇

静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

但此刻我为其设定缺省值的时候却报出了这样的错误，似乎不能在这里为它初始化呢？

C++ | 说说类中的static成员

之前学习了构造函数的【初始化列表】，在类内直接定义是因为缺省值是给到构造函数的初始化列表用的，初始化列表初始化的是非静态成员，是属于当前对象的；而静态成员是属于所有对象的，是共有的
所以我们考虑把它放到全局去进行一个定义，但是出了当前作用域又无法访问，此时就可以使用我们学习过的域作用限定符::

int A::count = 0;

那么就引出了static的第二条特性👇

静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

那此时我若是要在外界去访问一下这个静态成员呢？能不能做到

可以看到，直接打印访问是不可以的，因为需要域作用限定符::

C++ | 说说类中的static成员

不过呢，加上域作用限定符::又说它是私有的无法访问

C++ | 说说类中的static成员
那么就引出了static的第三条特性👇

静态成员也是类的成员，受public、protected、private 访问限定符的限制

那要怎么去访问呢？这里有两种方式

将count改为公有的之后就可以通过下面这两种方式去访问类中的静态成员变量

cout << A::count << endl;
cout << aa1.count << endl;
cout << aa2.count << endl;

【拓展一下】

对于这种方式也是可以的，如果你有认真看过详解类封装中的this指针就可以知道下面这种做法就是为当前的this指针传递了一个空的地址，虽然我们看到了->，但其实并没有去产生一个解引用，因为count是一个静态成员变量，虽然形式上放在类内，但上面说过了它是存放在内存中的静态区，所以无法用this指针访问到这个count

A* aa3 = nullptr;
aa3->count;

那么就引出了static的第四条特性👇

类静态成员即可用 [类名::静态成员]或者 [对象.静态成员]来访问

上面这样都可以访问是因为我将静态变量count设置成了公有，若一旦设置为私有的话，上面这些访问形式就都是非法的了

C++ | 说说类中的static成员

此时我们可以在类中写一个对外公开的接口，那么外界就可以通过这个接口访问到类内的私有成员变量了，在Java里面很喜欢这么去写，不过在C++中一般很少这样，C++一般会使用友元

int GetCount()
{
	return count;
}

C++ | 说说类中的static成员

可以看到成员函数都是用对象去调的，那我现在假设我没有对象呢【博主确实没有🐶】。此时还有办法获取到类内的静态成员变量吗？

此时就要使用到一个静态成员变量的双胞胎兄弟 —— 【静态成员函数】
只需要在GetCount()成员函数前加一个static作为修饰即可

static int GetCount()
{
	return count;
}

在外界还是使用域作用限定符::便可以访问到，可以说这个【静态成员函数】是专门为静态成员变量而生的

C++ | 说说类中的static成员

看来这个静态成员函数还挺厉害的，若是我现在类中又新增了一个普通成员变量，可以在里面进行访问吗？

通过运行可以看出似乎是不可以

C++ | 说说类中的static成员

那么就引出了static的第五条特性👇

静态成员函数没有隐藏的this指针，不能访问任何非静态成员
- 这其实很清楚，因为静态成员函数在静态区没有this指针，但普通的成员变量都是属于当前对象的，需要通过this指针来访问

三、疑难解惑

学习完上了上面这五条特性之后，来回答一下下面这三个问题吧

💬静态成员函数可以调用非静态成员函数吗？

这个当然也是不可以的，记住一点！在静态成员函数内部只能调用静态的成员变量或者函数

C++ | 说说类中的static成员
可以看到静态成员函数也是可以调用静态成员函数的

C++ | 说说类中的static成员

💬非静态成员函数可以调用类的静态成员函数吗？

这个是可以的，因为静态成员函数是公共的，公共的大家当然都可以用。包括像count也是可以使用的，这里不做演示

C++ | 说说类中的static成员

💬请问静态成员函数存放在哪里，静态区还是公共代码区？

答案揭晓，静态成员函数是存放在公共代码段的，我们在类和对象的封装思想中有谈到过，在一个类中对于成员变量而言和对象一起存放在【栈区】，但对于类内的成员函数而言，则不属于类，而是存放在【公共代码段】，那对于静态成员函数来说也是属于成员函数的一种，在编译过后都会被解析成指令，这些指令都是存放在公共代码段的
而对于静态成员变量来说是存放在静态区的，若是你去计算一下类的大小其实就一目了然了

C++ | 说说类中的static成员

四、在线OJ实训

在学习了C++中的静态成员相关知识后，我们通过一道在线OJ来练练手

链接：牛客JZ64 求1+2+3+…+n

1. 题目描述
C++ | 说说类中的static成员
2. 思路分析

来分析一下这道题该怎么去做，题目本身要求的意思很简单，就是求解1 ~ n的阶乘，但是限制条件有很多，例如：不能用分支判断、循环、条件判断、乘除法等等，这就令很多同学抓耳挠腮了，这要怎么去写呀？

💬有同学说：这还不简单，用个递归呗

递归是我们求解阶乘以及前n项和最常见的，不过既然是递归，那一定存在递归出口，那你肯定得去用if条件判断一下是否到底了递归出口吧

在同学们冥思苦想后，有一位同学提到了我们刚学习的static成员，那我们就用它来试试💪

首先要考虑清楚，此处是有两个变量在一直递增的，一个是1 ~ n这些数，一个则是累加和，不过它们都是上一轮的基础上去进行一个递增，我们知道对于静态成员变量只会在定义的时候初始化一次，后面每一次的值都是在上一次的基础上变化的

static int sum;
static int i;

所以此刻便可以将这个递增的变量设置为i，将累加和设置为sum，它们均为静态变量，根据我们上面所学知识要将其在类的外部进行定义初始化

int Count::sum = 0;
int Count::i = 1;

可以把这个累加的逻辑放在类的构造函数中，然后考虑去实例化具有n个大小的对象数组，那么就会调用n次构造函数去进行一个累加

Count()
{
	sum += i;
	i++;
}

Count c[n];

最后在类的内部提供的一个静态成员函数，外界便可以通过它来获取到静态成员变量sum

static int GetSum()
{
    return sum;
}

return Count::GetSum();

3. 代码展示

最后展示一下整体代码和运行结果

class Count{
public:
    Count()
    {
        sum += i;
        i++;
    }
    static int GetSum()
    {
        return sum;
    }

private:
    static int sum;
    static int i;
};

int Count::sum = 0;
int Count::i = 1;

class Solution {
public:
    int Sum_Solution(int n) {
        Count c[n];
        return Count::GetSum();
    }
};

C++ | 说说类中的static成员

五、一道巧妙的笔试题

在学习了上面有关类中static成员的相关知识后，接下去我们通过一道很巧妙的笔试题来加深大家的理解

💬 设计一个类，在类外面只能在栈/堆上创建对象

首先我们理解一下题目所要表述的含义，即我们需要去设计一个类，这个类呢可以指定在【栈】或者【堆】上去开辟空间创建对象
看到下面我们在类外自行去【栈区】、【堆区】、【静态区】创建了对象，这也是大家能想到的常规的做法

A a1;				// 栈区
static A a2;		// 静态区
A* a3 = new A();	// 堆区

不过呢这其实并不符合我们的题意，题意是让类内去提供一个接口，可以使得外界只能在【栈】或【堆】中创建对象，接下去就来看看我是怎么做的吧

首先我做了一件 “很绝”的事，那就是将当前类A的构造函数私有化，那么在类外就无法轻易地去实例化出对象了，这和我们在Java中讲工具类的时候将其构造器私有化是一个意思

class A {
public:
private:
	// 构造函数私有化
	A(){}
	int _a;
};

💬 那有同学就会问了，这类外都实例化不出对象了，还谈何在【栈】或【堆】上开辟空间存储对象呢？

这就需要思考了，既然类外无法实例化了，那还有类内呢，我们可以在类内的成员函数中来实例化出当前类的对象。于是我便写了这么两个成员函数，在函数内部实例化出对象供类外去进行调用

A GetStackObj()
{
	A a;
	return a;
}

A* GetHeapObj()
{
	return new A;
}

但是呢这却有一个问题，我们知道成员函数都是需要对象去进行调用的，可是呢在类外我们都实例化不出对象，此时要如何去调用这两个函数呢？
还记得我们本文学习了什么吗？没错，就是static成员，除了static成员变量外还有【static成员函数】，此时我们就可以将这两个成员函数定义为【静态成员函数】，除了可以使用对象.函数名()的形式来调用外，还可以使用类名::函数名()来进行调用。那此时我们在类外就可以像下面这样去进行调用

A::GetStackObj();	// 栈区
A::GetHeapObj();	// 堆区

所以上面的这道笔试题就很好得运用了本节所学习的知识，希望读者在学习完之后也可以做到灵活运用

六、有关static修饰变量的一些注意要点

说完static修饰成员变量和成员函数，这里再来补充一点有关static修饰变量的注意点，我们主要通过题目来进行讲解

有一个类A，其数据成员如下：则构造函数中，成员变量一定要通过初始化列表来初始化的是：（）

class A {
private:
   int a;
public:
   const int b;
   float* &c;
   static const char* d;
   static double* e;
};

A.a b c
B.b c
C.b c d e
D.b c d
E.b
F.c

【答案】：B

【解析】：
对初始化列表不了解的可以先看看C++ | 谈谈构造函数的初始化列表

对于【const成员变量】、【引用成员变量】、【无默认构造函数的自定义类型】都是必须通过初始化列表进行初始化的，因此b、c很明确要选上，对于d而言，虽然它有const修饰，但前面又有[static]作为修饰，所以是一个静态成员变量，不属于类，存放在静态区中，当程序开始执行的时候就被初始化了，对于e而言也是同理，所以答案选择【B】

设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？（）

C c;
int main()
{
	A a;
	B b;
	static D d;
	return 0；
}

A.D B A C
B.B A D C
C.C D B A
D.A B D C

【答案】：B

【解析】：

这题的话通过调试来看一下就很清楚了，主要是观察static的修饰对局部变量的作用域和生命周期的更改

可以观察到，因为对象d有static修饰，它的生命周期发生了变化，本来应该是最早析构的，却等到了b和a析构完了之后它才去析构，所以生命周期发生了延长，但还是比最先定义出来的对象d先析构，因为d后于c被实例化出来

C++ | 说说类中的static成员

虽然它的生命周期发生了变化，但是作用域却没有发生改变，从下图可以看出在fun()函数中访问不到main函数中定义的对象d

C++ | 说说类中的static成员

在一个cpp文件里面,定义了一个static类型的全局变量,下面一个正确的描述是：( )

A. 只能在该cpp所在的编译模块中使用该变量
B. 该变量的值是不可改变的
C. 该变量不能在类的成员函数中引用
D. 这种变量只能是基本类型(如int,char)不能是C++类类型

【答案】：A

【分析】：

首先那来看一下本题的代码，定义了一个静态的全局变量c，还有两个类，class A 和 class B

static int c = 1;

class A {
public:
	A()
	{
		cout << "A的构造函数" << endl;
	}

	void func()
	{
		cout << "A的成员函数" << endl;
		cout << c << endl;
	}

	~A()
	{
		cout << "A析构函数" << endl;
	}
private:
	int _a = 1;
};

class B {
public:
	B()
	{
		cout << "B的构造函数" << endl;
	}

	void func()
	{
		cout << "B的成员函数" << endl;
	}

	~B()
	{
		cout << "B析构函数" << endl;
	}
private:
	int _b = 1;
};

然后通过一些测试看到，静态全局变量是可以更改的，而且可以在类的成员函数中进行调用，并且看大这个 static B b就可以知道其也可以为自定义类型即C++的类类型

C++ | 说说类中的static成员

但是对于A选项确实就是这样，涉及到一些链接属性的解析，可以看看这篇文章

【总结一下】：

做了上面的三题，我们来总结一下：
- 对于static修饰的成员变量，存放在静态区，而不在栈区，是不属于当前类的，因此需要在类外初始化
- 对于static修饰的局部变量，其生命周期会延长，但作用域不会发生变化
- 对于static修饰的全局变量，只在当前编译模块中（即当前文件内）生效，其他文件不可访问。因此其作用域发生了变化，但是生命周期没有变化（从定义到结束都不会被释放）