C++ static、extern

1 在类外使用static

编译单元：一个编译单元是该文件本身以及include的内容。

extern

指定该变量可能不在当前编译单元内定义。可以是声明也可以是定义，如果是定义则等同于没有extern。

extern int s_Variable = 5; // 定义
extern int s_Variable; //声明

static

指定该变量或函数只能在该编译单元内使用。（可类比类中的private）从其他编译单元看不见这个变量或函数，即其他编译单元不可使用这个编译单元的静态变量或函数。可以用于定义和声明。

static int func();

声明这个函数是静态的，后文写函数实现即可。

1.1 例子：extern与static变量声明

Static.cpp：

int s_Variable = 5;

Main.cpp:

extern int s_Variable;

int main(){
    cout << s_Variable << endl;
}

由于Main.cpp中指明extern，此时编译器在连接时，会去当前编译单元之外的地方寻找变量s_Variable。

如果将Static.cpp改成如下：
Static.cpp：

static int s_Variable = 5;

此时连接时就会报错找不到s_Variable，因为s_Variable的作用域只在Static.cpp中。

1.2 例子：static函数声明

Static.cpp：

int func()
{
	return 9;
}

Main.cpp:

int func()
{
	return 8;
}

int main(){
    cout << func() << endl;
}

此时就会出现连接错误：函数重复定义。将Main.cpp的func修改如下：（修改Static.cpp的也行）

static int func()
{
	return 8;
}

程序正常运行，并且输出8。（如上情况中，连接时会优先使用本编译单元的静态函数，忽略其他编译单元的重复函数定义。Main.cpp中的static int func()会优先作用，忽略其他编译单元的int func()）

如果函数或变量不会在其他编译单元使用，那么就把它们定义为静态的。

2 类内static

2.1 静态变量

在一个类内声明变量是static，此后这个变量将成为该类所有实例化对象的共享数据。
这里用struct举例（class同理）

struct Entity
{
    int x, y;
    
    void Print()
    {
        cout << x << ", " << y << endl;
    }
};

int main(){
    Entity e;
    e.x = 2;
    e.y = 3;
    Entity e1 = {5, 8};
    e.Print();
    e1.Print();
    // 输出2,3和5,8
}

将Entity中的x,y 设置成静态成员变量后（此时不能再用Entity e1 = {5, 8}这种初始化方式）：

struct Entity
{
    static int x, y;
    
    void Print()
    {
        cout << x << ", " << y << endl;
    }
};

// 声明成静态后要加作用域的声明
int Entity::x;
int Entity::y;

int main(){
    Entity e;
    e.x = 2;
    e.y = 3;
    Entity e1;
    e1.x = 5;
    e1.y = 8;
    e.Print();
    e1.Print();
    // 输出都是5,8
}

一个小重点

没有声明那两行代码时，编译会报错，提示增加Entity::这两个声明。从这里也可以看出，x和y不再属于任何一个实例对象，而是Entity整个作用域的变量。 即Entity类的不同对象的静态成员xy分别指向同一地址。因此任意一个实例对象对xy的修改都会导致xy的变化。上述e.x或e1.x的调用方式实际上等价于Entity::x，也就是说xy并不属于某个具体对象，而是这个作用域。创建新类分配存储地址时也与xy无关。

2.2 静态函数

静态函数只能访问静态变量，不能访问非静态变量。

正常访问举例：

struct Entity
{
	// 变量和函数都是静态的
    static int x, y;
    
    static void Print()
    {
        cout << x << ", " << y << endl;
    }
};
// 需要声明
int Entity::x;
int Entity::y;

int main(){
	// 通过域名使用
    Entity::x = 1;
    Entity::y = 2;
    Entity::Print();
    
}

当xy不再是静态时，静态方法访问他们会报错（Print()中）。这是因为静态方法没有类实例，所以不知道非静态变量指的是什么。非静态方法会获取当前类的一个实例作为参数（this指针），因此知道xy是当前类的变量xy。上述静态方法和非静态方法等价于如下类外函数：

// 静态方法
static void Print()
{
    cout << x << ", " << y << endl;
    // 报错：Use of undeclared identifier 'x'
}

// 非静态方法
static void Print(Entity e)
{
    cout << e.x << ", " << e.y << endl;
}

3 Local static

局部变量的生存周期在执行完这个局部作用域的命令后结束（例如函数），但在这个局部作用域内将该变量设为static可以使他的生存周期到程序运行结束（生存周期改变）。但作用域还是这个作用域，这意味着作用域以外的地方想访问这个变量依旧是不行的（保留局部变量可见性的特点）。

3.1 例子：普通变量

void func()
{
    static int i = 0;
    i++;
    cout << i << endl;
}

int main(){
    func();
    func();
    func();
    func();
    // 输出为1,2,3,4
}

也就是说，单次func函数执行结束后i并没有消失。如果不是static，输出的结果将都是1。这里static相当于在func外定义了只有func函数可见的公共i，这保证了数据的安全性。当然不用static，用类设置i为私有静态成员也是一样的效果，只不过太麻烦，局部静态可以让代码更简洁。

3.2 例子：单例类

该类只能实例化一个对象。由于c++中并没有某个类只能生成一个对象的这种限制，因此需要其他方法来达成。
不用local static的情况下：

class Singleton
{
private:
    // 只有一个对象，静态变量
    static Singleton* s_Instance;
public:

    static Singleton& Get(){return *s_Instance;}
    // 一个没啥用的函数，用来看是否成功调用对象
    void Hello(){cout<<1<<endl;}
};

// 声明
Singleton* Singleton:: s_Instance = nullptr;

int main(){
    Singleton::Get().Hello();
}

使用local static，以下是一种比较推荐的单例类写法magic static：

class Singleton
{
public:
    static Singleton& Get()
    {
    	// 静态局部变量：
        static Singleton instance;
        return instance;
    }
private:
	// 构造函数中print信息，查看构造几次
    Singleton(){
        std::cout<<"constructor called!"<<std::endl;
    }
};

int main(){
    Singleton& a = Singleton::Get();
    Singleton& b = Singleton::Get();
	// 只有一行输出
}