初识C++(7)之static在类中的应用以及单例

• static类成员

C++primer里面说过，static类成员不像普通的类数据成员，static类数据成员独立于一切类对象存在。static类数据成员是与类关联的，

但不与该类定义的对象有任何关系。即static不会像普通类数据成员一样每一个类对象都有一份，全部类对象是共享一个static类成员的。

例如A类对象修改了static成员为1，那么B对象对应的static类对象成员的值也会是1。

注意：static类对象必须要在main函数进行初始化，否则无法使用

class Text  
{  
      public:  
      static int count;  
};  
    
int Text::count=0;//用static成员变量必须要初始化   
    
int main()  
{  
     Text t1;  
     cout<<t1.count<<endl;   
     return 0;  
}//程序输出0  

static修饰的变量先于对象存在，所以static修饰的变量要在类外初始化。因为static是所有对象共享的变量，必须要比对象先存在。

 class Text  
 {  
      public:  
      static int count;  
  };  
    
  int Text::count=0;//用static成员变量必须要初始化   
    
  int main()  
 {  
     Text t1;  
     Text t2;  
       
     t1.count = 100;     //t1对象把static成员count改为100   
     cout<<t2.count<<endl; //当t2对象打印static成员的时候，显示的是100而不是0   
     return 0;  
 }  

好处：

用static修饰的成员变量在对象中是不占内存的，因为他不是跟对象一起在堆或者栈中生成，用static修饰的变量在静态存储区生成的。所以用static修饰一方面的好处

是可以节省对象的内存空间。如同你创建100个Person对象，而这100个对象都有共有的一个变量，例如叫国籍变量，就是Person对象的国籍都是相同的。

那如果国籍变量用static修饰的话，即使有100个Person对象，也不会创建100个国籍变量，只需要有一个static修饰的国籍变量就可以了。这100个对象要用的时候，

就会去调用static修饰的国籍变量。否则有100个Person变量，就会创建100个国籍变量，在国籍变量都是相同的情况下，就等于浪费空间了。

• static类成员函数

由于static修饰的类成员属于类，不属于对象，因此static类成员函数是没有this指针的，this指针是指向本对象的指针。正因为没有this指针，所以static类成员函数

不能访问非static的类成员，只能访问 static修饰的类成员。

class Text  
  {  
      public:  
      static int fun()  
      {  
          return num;  
      }  
      static int count;  
      int num;  
 };  
 int Text::count=5;//用static成员变量必须要初始化   
   
 int main()  
 {  
     Text t1;  
     Text t2;  
     t1.num=100;  
       
     t1.fun();//发生错误，fun函数return的是非static类成员 如果return count就正确   
     return 0;  
 }  

以上程序参考：https://www.cnblogs.com/fuqia/p/8888938.html

 

• static在单例中的应用

所谓单例就是一个类只能被实例化一次，主要有两种实现方法：

1. 在类使用之前，就将类实例化，也叫饿汉模式。利用静态对象
2. 使用到类时，才进行实例化，也叫懒汉模式。利用静态对象指针

第一种饿汉模式：

#include <iostream>
using namespace std;

class Singleton
{
  private:
    Singleton(){
        cout << "构造" << endl;
        num = 10;
    }
    ~Singleton(){
        cout << "析构" << endl;
    }
    int num;
    static Singleton locla_s;
  public:
    static Singleton *getInstance()
    {
        return &locla_s;
    }
    void Print()
    {
    	std::cout << num << std::endl;
    }	
};

Singleton Singleton::locla_s;//值得注意的地方

int main()
{
    Singleton* P_Singleton = Singleton::getInstance();
    P_Singleton->Print();
	return 0;
}

结果：

构造
析构

 

改变主函数：

int main()
{
    Singleton * s2 = Singleton::getInstance();
    cout << s2 << endl;
    Singleton * s3 = Singleton::getInstance();
    cout << s3 << endl;
    return 0;
}

结果：

构造
0x601191
0x601191
析构

结论：

可见这种方式，即便主函数中没有对这个类有任何操作，也会在进入主函数之前启动构造函数，在退出主函数之前启动析构造

函数。在主函数中多次创建指针相同，表明是同一个实例化对象。

懒汉模式：

#include <iostream>
using namespace std;

class Singleton
{
  private:
    static Singleton *local_instance;
    Singleton(){cout  << "构造" << endl;}
    ~Singleton(){cout  << "析构" << endl;}

  public:
    static Singleton *getInstance()
    {
        if (local_instance == nullptr)
        {
            local_instance = new Singleton();
            cout << "new 新空间" << endl;
        }
        else
        {
            cout << "空间不变" << endl;
        }
        
        return local_instance;
    }
    static void delete_local()
    {
        delete local_instance;
    }
};

Singleton * Singleton::local_instance = nullptr;//值得注意


int main() 
{    
    // Singleton * s1 = Singleton::getInstance();
    // Singleton * s2 = Singleton::getInstance();
    // Singleton::delete_local();
    return 0;
}

结果：

没有任何输出结果

修改主函数：

int main() 
{    
    Singleton * s1 = Singleton::getInstance();
    Singleton * s2 = Singleton::getInstance();
    // Singleton::delete_local();
    return 0;
}

结果：

构造
new 新空间
空间不变

继续修改主函数：

int main() 
{    
    Singleton * s1 = Singleton::getInstance();
    Singleton * s2 = Singleton::getInstance();
    Singleton::delete_local();
    return 0;
}

结果：

构造
new 新空间
空间不变
析构

结论：

主函数中没有对这个类操作时，不会调用构造函数。在第一次调用是new新空间，调用构造函数，但是由于new的空间没有delete，所以无法调用析构函数。进一步修改主函数之后，就可以进行析构了。

对于单例的讨论网上有很多，但是大家的说法不尽相同，这里也仅仅我自己的一些看法，欢迎讨论，