C++static关键字

1. static 局部变量

1. 该变量在全局数据区分配内存；
2. 其生存周期为整个程序周期，它始终驻留在全局数据区，直到程序运行结束；
3. 但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束；
4. 静态局部变量在程序执行到该对象的声明处时被首次初始化，仅初始化这一次，以后的函数调用不再进行初始化，但其值可以随时修改。
5. 其初始化的时候进行了声明+定义，若在声明时未赋以初值，则系统自动赋予0值 。而对自动变量不赋初值，则其值是不定的。

根据静态局部变量的特点，可以看出它是一种生存期为整个程序生命周期。

虽然离开定义它的函数后不能使用，但如再次调用定义它的函数时，它又可继续使用，而且保存了前次被调用后留下的值。

因此，当多次调用一个函数且要求在调用之间保留某些变量的值时，可考虑采用静态局部变量

2. static 全局变量

#include<iostream>
using namespace std;
static int i = 5;
int j = 3;//默认为extern

1. 全局变量 j 和静态全局变量 i 都存放于程序的全局数据区域，
2. 它们的生存周期都是程序的整个运行期，
3. 但是 j 的作用域为全局作用域，可以通过extern在其他文件中使用，而 i 的作用域为文件作用域，只能在文件A中使用。

#include<stdio.h>
static int data1 = 10;
static int data2;
int main()
{
    static int data3 = 20;
    static int data4;
    int i = 3;
    while(i)
    {
        static data5 = 30;
        printf("data5 = %d\n", data5);
        i--;
        data5++;
    }
    data4 = 40;///初始化只有一次，为赋值则自动赋值为零，其后可以修改值
    printf("data1 = %d\n", data1);
    printf("data2 = %d\n", data2);
    printf("data3 = %d\n", data3);
    printf("data4 = %d\n", data4);
    //printf("data5 = %d\n", data5);超出data5的作用域无法访问
    return 0;

结果：

//data5初始化为30 后就不在执行“static int data5 = 30”这条指令了,但是再次进去其作用域，这个变量还是存在的，且之前的值还是保存的
data5 = 30
data5 = 31
data5 = 32
data1 = 10
data2 = 0
data3 = 20
/初始化只有一次，为赋值则自动赋值为零，其后可以修改值
data4 = 40

#include<stdio.h>
static int data1 = 10;
static int data2;
int main()
{
    static int data3 = 20;
    static int data4;
    int i = 3;
    while(i)
    {
        int data5 = 30;
        printf("data5 = %d\n", data5);
        i--;
        data5++;
    }
    return 0;
}

///局部变量，超过作用域就自动销毁了
data5 = 30
data5 = 30
data5 = 30

3. static 函数

1. 静态函数只能被本文件中的函数调用，而、不可以通过extern 被同一工程中的其他文件调用。
2. 但是当同一工程中的其他文件 #include “” 之后，源文件中的static 函数可以被调用了。

1.cpp:
#include <iostream>
using namespace std;
static int v  = 10;
static void test()
{
    cout << 1 << endl;
}

#include<stdio.h>
//#include "1.cpp"
int main()
{
    extern void text();///声明
    test();
}
///不可以，编译不通过

#include<stdio.h>
#include "1.cpp"
static int data1 = 10;
static int data2;
int main()
{
    extern void text();///声明
    test();//可行
    cout << v << endl;//可行
}

4. static修饰数据成员

#include<iostream>
using namespace std;

class Myclass
{
public:
    Myclass(int a = 0) :data1(a)
    {
        cout << "Myclass(int)" << endl;
    }
    void Show()
    {
        cout << "Show()" << endl;
        cout << data1<< " " << data2 << endl;
    }
    ~Myclass()
    {
        cout << "~Myclass()" << endl;
    }
public:
    static int data3;
private:
    int data1;
    static int data2;
};

//如果不对data2、data3初始化，编译会报错误
//无法解析的外部符号 "public: static int Myclass::data1" (?data1@Myclass@@2HA)
//无法解析的外部符号 "private: static int Myclass::data2" (?data2@Myclass@@0HA)
int Myclass::data1 = 20;
int Myclass::data2 = 30;
//初始化方式为作用域+变量+初始值
int main()
{
    Myclass class1(10);
    class1.Show();
    cout << class::data3 << endl;
    return 0;
}

1. static修饰的数据成员不在栈上分配内存而在.data段分配内存，
2. static修饰的数据成员不能通过调用构造函数来进行初始化，因此static修饰的数据成员必须在类外进行初始化且只会初始化一次。
3. 对于非static数据成员，每个类对象都有自己的拷贝。而static数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝 ，由该类型的所有对象共享访问。
   4**. 一个对象改变了静态成员变量，其他对象访问到的也随之改变了。**
4. 它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它；
5. 静态数据成员和普通数据成员一样遵从public,protected,private访问规则；

5. static修饰成员方法

#include<iostream>
using namespace std;

class Myclass
{
public:
    Myclass(int a = 0) :data1(a)
    {
        cout << "-------Myclass(int)-------" << endl;
    }
    void Show()
    {
        cout << "-------Show()-------" << endl;
        cout << "data1=" << data1 << " " << "data2=" << data2 << endl;
    }
    void mul()
    {
        cout << "------mul()-------" << endl;
        data1 *= add(data1);
    }
    static int add(int a)
    {
        cout << "--------add(int)-------" << endl;
        data3 += a;
        data2 += a;
        //data1 += a;无法使用data1
        cout << "data2=" << data2 << " " << "data3=" << data3 << endl;
        return (data3 + data2) / 2;
    }
    static void show()
    {
        cout << "-------show()---------" << endl;
        //Show();无法调用Show()
        add(data3);
    }
    ~Myclass()
    {
        cout << "--------~Myclass()-------" << endl;
    }
public:
    static int data3;
private:
    int data1;
    static int data2;
};

int Myclass::data2 = 20;
int Myclass::data3 = 30;
int main()
{
    Myclass class1(10);
    class1.Show();
    cout << "data3=" << class1.data3 << endl;
    Myclass::show();
    Myclass::add(20);
    class1.mul();
    class1.Show();
    return 0;
}

1. 静态成员函数没有this指针，不能访问非静态成员函数和非静态数据成员，只能访问静态的；
2. 非静态成员函数可以任意地访问静态成员函数和静态数据成员；
3. 在类外调用static成员方法和使用类的数据成员时只需要加上类的作用域即可。他们都不依赖对象的调用。