对于C++中的static关键字（static变量、static成员函数or普通函数）的学习理解

今天coding的时候突然忘记了static关键字的作用，故今天在CSDN上看到一篇大佬写的static关键字的详细讲解，因此把这一篇博客当做一份学习记录，希望自己日后coding时再忘记可以回头看看自己写的学习理解，嘻嘻！

参考：

C++类中的静态成员变量和静态成员函数的作用

下面是我自己做的一份学习总结（光看是没有用的，必须要自己输出or至少Copy一遍！！！）

众所周知，数据成员可以分为静态变量、非静态变量两种。今天我们就来学习一下何谓之静态变量。

        静态成员：对类中的成员加入static修饰符，即是静态成员了，可以使用类名::静态成员名访问此静态成员，因为静态成员就存在于内存中，而非静态成员则需要实例化才会被分配内存，所以静态成员不能访问非静态成员，因为静态成员存在于内存，所以非静态成员可以直接访问类中的静态成员。

        非静态成员：all没有加static 关键字修饰的成员都是非静态成员，当类被实例化后，可以通过实例化的类名进行访问，非静态成员的生存期取决于该类的生存期，而静态成员则不存在生存期     的概念，因为静态成员始终驻留在内存中。

一个类中可以包含静态成员和非静态成员，也可以包括静态构造函数和非静态构造函数。

下面，我分两个方面来分析static关键字的作用:

        一方面:就面向过程的思想来介绍static的作用（不涉及类）

        另一方面：就面向对象的思想来介绍static的作用，也即是介绍static在类中的作用。

①面向过程中的static关键字：

1、静态全局变量

2、静态局部变量

3、静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其他文件使用。

1、静态全局变量

        定义：在全局变量前加上关键字static，该变量就被定义成一个静态全局变量。静态全局变量有以下好处：即在其他文件中可以定义相同名字的变量，而不会发生冲突。（这条好处可以用特点C来解释）

特点：

A -该变量在全局数据区分配内存

B-初始化：如果对于该static的全局变量你不去不显式初始化，那么该变量将会被默认初始化为0

下面这段codes你可以拿去验证这一条结论：

#include<iostream>
using namespace std;
static double db;//初始化static的全局变量

void main()
{
	cout << "db = "<< db << endl;
    system("pause");
}

运行结果：

C-该变量只在本源文件可见，严格地讲，应该从定义之处开始到本文件结束。
下面这段codes你可以拿去验证这一条结论：

//test.h中写下

static double db;

//main.cpp中写下

#include<iostream>
using namespace std;
static double db;
int main()
{
    cout<<"db = "<<db<<endl;
    system("pause");
    return 0;
}

依然build成功，运行结果同特点B之测试代码。

D-文件作用域下声明的const的常量默认为static存储类型。

静态变量都在全局数据区分配内存，包括静态局部变量（就比如函数参数，语句块{}内定义的变量）。

补充知识 ：

对于一个完整的程序，其代码在内存中的分布情况如下：

1-代码区

2-全局数据区

3-栈区

4-堆区

一般在程序中，由new产生的动态数据区放在堆区中(当然，堆区的数据你需要手动申请空间，手动释放空间)，函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间，静态数据（即是函数内部的静态局部变量）也存放在全局数据区中。全局数据区的数据并不会因为函数的退出而释放空间，而是等整个程序结束之后由OS自动释放掉。

2、静态局部变量

        定义：在局部变量前加上static关键字时，就是静态局部变量了。

通常，在函数体内定义了一个变量，每当程序运行到该语句时都会给该局部变量分配栈内存，但随着程序退出函数体，系统就会收回栈内存，局部变量也就相应地失效了。但是有时候我们需要在两次调用之间对变量的值进行保存，通常的想法是定义一个全局变量来实现，但是这样一来，变量已经不再属于函数本身了，也即不再仅受函数的控制，这样就会给程序的维护带来不便。
静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区，而不是保存在栈中，每次更新其值都会保持到下一次调用，直到下次赋新值。

特点：

        A-该变量在全局数据区分配内存

        B-初始化：如果不给它显式初始化，那么就会被隐式初始化为0，后面的函数调用不再进行初始化。

下面这段codes你可以拿去验证这一条结论：

#include<iostream>
using namespace std;
void test_func()
{
	static double cc;
	cout << "cc = " << cc << endl;
}
void main()
{
	test_func();
	test_func();
	test_func();
    system("pause");
    return 0;
}

运行结果：。这样就验证了上述这条特点了，你若一开始定义静态局部变量的时候不去初始化，那么系统自动给你赋值为0。

当然，你若把上述函数中的代码改成：

void test_func()
{

	static double cc = 1;
	cc++;
	cout << "cc = " << cc << endl;
}

 那么运行结果则是：

 

 相信，现在你对于静态局部变量的这个特点的使用有清晰头绪了。

        C-它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域。当定义它的函数或语句块结束时，其作用域也随之结束。（因为，全局数据区的数据并不会因为函数的退出而释放空间，而是等整个程序结束之后由OS自动释放掉。）

3、静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其他文件使用。

定义静态函数的好处：静态函数不能被其他文件使用。那么你就可以在其他文件中定义与该static函数同名的函数了，这样build时也不会发生冲突。

②面向对象中的static关键字：

1、静态成员属性

2、静态成员函数

        注意对于static关键字的一个重要思想：当你想定义一个类时，你想马上就可以使用到其某个成员函数的话，那么就把该成员函数声明为static便是非常好的一个途径！因为这样该成员函数就属于类而不属于该类的对象了。同理，当你想马上使用到其某个成员变量时，就把该成员变量声明为static的并在类外定义它（给初值），然后你就可以通过::符号访问到他们了！这种思想来自爱编程的大丙这个老师！

1、静态成员属性（其实成员数据、数据成员、成员属性都是一个意思！！！自己心里clear即可）

        定义：在类内成员属性(或者说是成员变量)的声明前加上关键字static，那么该成员属性就是类内的静态成员属性。

静态成员属性有以下

特点：
        A-对于非静态成员属性，每个类的对象都会有自己的这一份拷贝。无论定义了多少个这个类的对象，静态数据成员在程序中只能够有一份拷贝，可供该类的所有对象共享访问。即静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象而言都是一样的，它的值可以更新。

        B-静态数据成员存储在全局数据区，静态数据成员定义时要分配空间，所以不能在类声明中定义。应该在类外定义。总而言之，静态数据成员只能在类内声明，在类外定义（或者说赋值）！，也即：用static关键字修饰的类内的成员属性，对于它们而言，你只能够在类内声明，在类外初始化！这句话你必须要记住！

当然，静态数据成员的初始化与一般数据成员的初始化不同，它的初始化格式为（在类外定义（初始化））的形式是：

< 数据类型 >< 类名 > :: < 静态数据成员名 >  =  < 值 > 

比如：int MyClass::sum = 0;

请看以下代码：

#include<iostream>
using std::cout;
using std::endl;
class MyClass
{

private:
	int m_a;
	int m_b;
	int m_c;
	static int sum;//static int sum = 0;//报错！！！
	//因为 static修饰的成员属性 必须要在类内声明 且要在类外实现（定义）
public:
	MyClass(int a,int b,int c):m_a(a), m_b(b), m_c(c)
	{
		this->sum = 0;
		this->sum = m_a + m_b + m_c;
	}

	int func()
	{
		return this->sum;
	}
	static void func2()
	{
		cout << "lalala" << endl;
	}
};
int MyClass::sum = 0;

void main()
{

	MyClass mc(1, 2, 3);
	int ret = mc.func();
	cout << ret << endl;
	MyClass mc2(2, 22, 13);
	ret = mc2.func();
	cout << ret << endl;
	//从这里我们就可以看出来，对于static的成员属性来说，都是 只有一份拷贝的，对于all
	//的对象都只有一份拷贝，都用的这个static的成员
	system("pause");
}

从以上代码你可以清楚为何我说一定要记住这条B特点了！       

         C-静态数据成员和普通数据成员一样遵从public、private、protected访问规则。

        D-由于静态数据成员在全局数据区分配内存，属于本类的所有对象共享，它不属于特定的类对象，在没有产生类对象时作用域就可见。即使在没有产生类的实例时，我们都可以操作它。

在上述B特点的main.cpp中加入

mc.func2();
mc2.func2();
MyClass::func2();//即使你没有创建对象(也即实例化)，你也可以通过类名来访问到static的静态成员函数

运行结果： 

相信到这里，你应该清楚的学会了特点D所讲述的知识了。

补充知识：

补1：静态数据成员主要用途：当各个对象都含有相同的某项属性时，就可以使用static来修饰该成员属性了。

小案例（助于理解）：比如存款类中每一个人都有自己的小金库（从工资，额外收入等途径累加起来赋值给这个成员属性），再比如对一个存款类，每个实例的利息都是相同的，so利息可以设为存款类的静态数据成员。这有两个好处，一是不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省了存储空间。一旦利息需要改变时，只需要我们手动改变一次，这样所有存款类对象的利息就会全都改变过来了。

补2：同全局变量相比，使用静态数据成员有这个优势：

        静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其他全局名字空间中的变量的名字产生冲突的可能性；

2、静态成员函数

        定义：就是在类的成员函数的返回值类型前 加一个static关键字，就变成了静态的成员函数。

        与静态数据成员一样，我们也可以创建一个静态成员函数，它为整个类而服务，而不是为某一个类的具体对象服务。普通的成员函数一般都隐藏了一个this指针，this指针指向调用该函数的类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this指针是缺省的、但是与普通函数相比，静态成员函数由于是不与任何的对象有联系的，因此它不具有this指针，从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其他静态成员函数。
请将上述静态成员函数的特点B中的代码中的static void func2()的代码改成如下形式：

	static void func2()
	{
		m_a = 1;//错误！静态成员函数不可以访问非静态成员变量and非静态成员函数
		func();//错误！static成员函数只可以调用static的成员函数，而不可以调用普通的函数
		sum = 1;//正确！静态成员函数可以访问静态成员变量
		cout << "lalala" << endl;
	
	}

当你把这段代码拷贝到你的编译器上时，你就会发现问题如我在注释中所述！

最后，关于静态成员函数，有以下几点总结：

（1）静态成员之间可以互相访问，包括静态成员函数访问静态数据成员和访问静态成员函数；

（2）非静态成员函数可以任意地访问静态成员函数和静态数据成员；

你可以拿这段代码来验证上述所说：（在上述代码的基础上修改int func()这个函数即可验证）

	int func()
	{
		func2();//正确！非静态成员可以访问静态成员（成员属性or成员函数）！
		sum = 11;//正确！非静态成员可以访问静态成员（成员属性or成员函数）！
		return this->sum;
	}

（3）静态成员函数不能访问非静态成员函数和非静态数据成员（上述已验证过，此处不重复验证）

（4）由于没有this指针的额外开销，so静态成员函数与类的全局函数相比，运行速度上会有少许的增长；