static

变量和函数 确保当前变量只在当前文件中生效，链接器在工作工程中不会去其他文件（全局作用域）搜寻这个变量，函数修饰同理。 类和结构体【22】C++类和结构体中的静态（static）_哔哩哔哩_bilibili

struct entity{
    static int x,y;//在类中声明该类具有一个成员变量，但是不会为其分配空间
	//静态方法、变量属于类本身而非类的任何实例，因此下面的定义也是定义在类的命名空间下的，没有this指针
    void print(){
        cout << x << " " << y;
    }
};
//int entity::x, entity::y; //需要在类外定义
int main(int argc, char const *argv[])
{
    entity a,b;
    a.x = 10, a.y = 20;
    b.x = 30, b.y = 40;
    a.print();
    cout << endl;
    b.print();
    return 0;
}

不能通过类的实例化对象去直接操作一个 static 变量，因为这块内存空间不属于任何的对象。 这么写的原因是为了跨类共享变量。 静态方法不能访问非静态内容，因为他们没有实例。 通过 static 避免意外访问

void f(){
    static int i = 0;//确保只有f能够操作i
    i++;
    cout << i << endl;
}

单例设计模式（局部静态）

暴力的使用全局变量声明对象会导致命名冲突、高耦合性。 在应用这个模式时，单例对象的类必须保证只有一个实例存在。 饿汉式 饿汉式可以保证

class singleton{
    private:
    static singleton *instance;
    public:
    static singleton& getInstance(){
        if(instance == nullptr){
            instance = new singleton();
        }
        return *instance;//解引用得到对象本身，返回其引用
    }
    void hello(){
        cout<<"hello"<<endl;
    }
};
singleton *singleton::instance = nullptr;//声明

int main(int argc, char const *argv[])
{
    singleton::getInstance().hello();//唯一实例访问点singleton::getInstance()
    //第一次get会给instance赋值为唯一的实例化对象
    return 0;
}

饿汉式的对象构造时机在静态指针 instance 初始化的时候（类加载完成后）。 懒汉式

class singleton_lazy{
    private:
        singleton_lazy(){}
        singleton_lazy(const singleton_lazy&) = delete;//禁止拷贝
        singleton_lazy& operator=(const singleton_lazy&) = delete;//禁止赋值
    public:
        ~singleton_lazy(){}
        static singleton_lazy& getInstance(){
            static singleton_lazy instance;
            return instance;
        }
        //返回的必须是一个静态对象的引用，否则会触发对象拷贝，造成资源浪费，且不满足单例对象
        void hello(){
            cout<<"hello"<<endl;
        }
};

int main(int argc, char const *argv[])
{
    singleton_lazy& sl = singleton_lazy::getInstance();
    sl.hello();
}

懒汉式的构造时机完全由调用 getInstance 的时机决定。 线程安全的懒汉式C++单例模式 (qq.com)