[C++] static关键字的作用

面向过程中的static

static修饰局部变量

static修饰局部变量时，使得被修饰的变量成为静态变量，存储在静态数据区。数据生命周期与程序相同。在main函数之前初始化，在程序退出时销毁。

局部静态变量使得该变量在退出函数后，不会被销毁，因此再次调用该函数时，该变量的值与上次退出时值相同。需要注意的是，生命周期并不代表其可以已知被访问。因为变量的访问还受到其作用域的限制。

void func()
{
    static int n = 0;
    cout << "f()" << ++n << endl;
}
int main()
{
    for (int i = 0; i < 5; ++i)
        func();
    return 0;
}

// output
f()1
f()2
f()3
f()4
f()5

静态局部变量的特点

1、该变量在静态数据区分配内存

2、静态局部变量在程序执行到该对象的声明处时首次初始化，即以后的函数调用不再进行初始化

3、静态局部变量一般在声明处初始化，如果没有显示初始化，会被程序自动初始化为0

4、它始终在全局数据区，知道程序运行结束，但其作用域为局部作用域，当定义它的函数或语句块结束时，其所用域随之结束

static修饰全局变量

在全局变量前加上关键字static，该变量就定义成为一个静态全局变量

static int n = 0;
void func()
{
    cout  << ++n << endl;
}
int main()
{
    n = 20;
    cout << n << endl;
    func();
    return 0;
}

// output
20
21

静态全局变量特点：

1、在静态数据区分配内存

2、未初始化的静态全局会被程序自动初始化为0

3、静态全局变量在声明它的整个文件都是可见的，在文件之外是不可见的

定义静态全局变量的好处：

1、静态全局变量不能被其他文件所用

2、其他文件中可以定义相同名字的变量，不会发生冲突

static修饰函数

在函数返回值类型前加上static的函数是静态函数、它只能在声明它的文件中可见，不能被其他文件使用

static void fn() {
    int n = 10;
    cout << n <<  endl;
}
int main() {
    fn();
    return 0;
}

// output 
10

定义静态函数的好处：

1、静态函数不能被其他文件所用

2、其他文件可以定义相同名字的函数，不会发生冲突

在面向过程中的static往往用于隐藏变量或者函数，只可以在本文件中使用，不可以在别的文件中使用。

面向对象中的static

静态数据成员

在类内数据成员的声明前加上static，该数据成员就是类内的静态数据成员

// Myclass.h
class Myclass
{
public:
    Myclass(int a, int b, int c);
    void getSum();
private:
    int a, b, c;
    static int sum;
};

// Myclass.cpp
int Myclass::sum = 0;
Myclass::Myclass(int a, int b, int c) : a(a), b(b), c(c)
{
    sum += a + b + c;
}

void Myclass::getSum()
{
    cout << "sum is: " << Myclass::sum << endl;
}

// main.cpp
int main()
{
    Myclass m(1, 2, 3);
    m.getSum();
    Myclass n(4, 5, 6);
    n.getSum();
    m.getSum();
    return 0;
}

// output
sum is: 6
sum is: 21
sum is: 21

静态数据成员的特点：

1、静态数据成员被当作是类的成员，无论这个类的对象被定义多少个，静态数据成员在程序中只有一份拷贝。这个拷贝被所有对象共享访问

2、静态数据成员存储在静态数据区，在定义时要分配空间，所以不能在类声明中定义。

3、静态数据成员遵从public、protected、private的访问原则。

4、静态数据成员可以实现信息隐藏。而全局变量不能是private成员。

静态成员函数

静态成员函数为类的全部服务而不是为某一个类的具体对象服务，静态成员函数不与任何对象相联系，因此它没有this指针。

所以它无法访问属于类的非静态数据成员，也无法访问非静态成员函数，它只能调用其他静态成员函数

// Myclass.h
class Myclass
{
public:
    Myclass(int a, int b, int c);
    static void getSum();
private:
    int a, b, c;
    static int sum;
};


// Myclass.cpp
int Myclass::sum = 0;
Myclass::Myclass(int a, int b, int c) : a(a), b(b), c(c)
{
    sum += a + b + c;
}

void Myclass::getSum()
{
    cout << "sum is: " << Myclass::sum << endl;
}

// main.cpp
int main()
{
    Myclass m(1, 2, 3);
    m.getSum();
    Myclass n(4, 5, 6);
    n.getSum();
    Myclass::getSum();
    return 0;
}

// output
sum is: 6
sum is: 21
sum is: 21

静态成员函数的特点：

1、出现在类外的函数不能定义为static

2、静态成员之间可以互相访问

3、非静态成员函数可以访问静态成员函数和数据

4、静态函数不能访问非静态成员函数和数据