C++学习总结16--静态成员(static)和单例模式

小记：静默如初，安之若素

1.静态成员

1. 静态成员变量
1）语法：

class 类名
{
   static 数据类型 变量名;//声明
};
数据类型 类名：：变量名 = 初值;//定义，求一个对象大小和静态成员变量无关

2）语法规则：（静态成员变量和普通成员变量的区别）
2.1） 普通的成员变量属于对象，而静态成员变量不属于对象（从内存角度进行分析）；
2.2）静态成员变量不能在构造函数中定义和初始化，需要在类的外部单独定义和初始化；
2.3）静态成员变量和全局变量一样存放在全局区，可以把静态成员变量理解成是被限制在类中去使用 的全局变量。
3）使用方法：

类名::静态成员变量//推荐
对象名.静态成员变量名//和上面方法本质一样

  1 #include <iostream>
  2 using namespace std;
  3 
  4 class A
  5 {
  6 public:
  7   //普通的成员变量在构造函数初始化
  8   A(int data = 0):m_data(data){}
  9   
 10   int m_data;
 11   static int s_data;//声明
 12 };
 13 
 14 //静态成员变量需要在类外部单独定义和初始化
 15 int A::s_data = 10;//定义
 16 
 17 int main(int argc, char *argv[])
 18 {
 19   A a1(20);
 20   cout << "size = " << sizeof(a1) << endl;//4
 21   
 22   cout << A::s_data << endl;//10
 23   cout << a1.s_data << endl;//10
 24   cout << a1.m_data << endl;//20
 25   
 26   A a2;
 27   //静态成员变量在该类的多个对象间共享
 28   a2.s_data = 123;
 29   //普通的成员变量在不同对象中相互独立
 30   a2.m_data = 213;
 31   
 32   cout << a1.s_data << endl;//123
 33   cout << a1.m_data << endl;//20
 34   cout << a2.s_data << endl;//123
 35   cout << a2.m_data << endl;//213
 36   
 37   return 0;
 38 }
~      

2. 静态成员函数
1）语法：

class 类名
{
   static 返回类型 函数名(形参表){...}//声明
};

2. 语法规则：静态成员函数没有this指针，没有const属性；
   3）使用方法：

类名::静态成员函数(实参表);//推荐
对象名.静态成员函数(实参表)//和上面方法本质一样

注：在静态成员函数中只能访问静态成员，不能访问普通的成员，在普通的成员函数中，即可以访问静态成员也可以访问普通的成员。

  1 #include <iostream>
  2 using namespace std;
  3 
  4 class A
  5 {
  6 public:
  7   //普通的成员变量在构造函数初始化
  8   A(int data = 0):m_data(data){}
  9 
 10   void func1(void)
 11   {
 12     cout << "not static function" << endl;
 13     cout << "s_data : " << s_data << endl;//10
 14     cout << "m_data : " << m_data << endl;//20
 15   }
 16   
 17   static void func2(void)
 18   { 
 19     cout << "static function" << endl;
 20     cout << "s_data : " << s_data << endl;//10
 21     //静态成员函数没有this指针，不能访问普通成员变量
 22     //cout << "m_data : " << m_data << endl;//error
 23   }
 24   
 25   int m_data;
 26   static int s_data;//声明
 27 };
 28 
 29 //静态成员变量需要在类外部单独定义和初始化
 30 int A::s_data = 10;//定义
 31 
 32 int main(int argc, char *argv[])
 33 { 
 34   //静态成员函数可以通过类名::直接调用
 35   A::func2();
 36   
 37   A a(20);
 38   //普通成员函数必须通过对象调用
 39   a.func1();//A::func1(&a);
 40   //静态成员函数也可以通过对象调用
 41   a.func2();//A::func2();
 42   
 43   return 0;
 44 }

2.单例模式

1. 定义：一个类只允许创建唯一的对象，并提供它的访问方法。
2. 实现思路
1）禁止在类的外部创建对象：私有化构造函数；
2）类的内部维护唯一的对象：通过静态成员变量实现
3）提供单例对象的访问方法：静态成员函数
4）创建方式：
4.1）饿汉式：无论用或不用，程序启动即创建（空间换时间）

  1 //单例模式：饿汉式
  2 #include <iostream>
  3 using namespace std;
  4 
  5 class Singleton
  6 {
  7 public:
  8   //3)通过静态成员函数获取单例对象
  9   static Singleton& getInstance(void)//必须加引用
 10   { 
 11     return s_instance;
 12   }
 13   
 14   void print(void) const
 15   {
 16     cout << m_data << endl;
 17   }
 18   
 19 private:
 20    //1)私有化构造函数 
 21    Singleton(int data = 0):m_data(data)
 22    {
 23      cout << "singleton create" << endl; 
 24    }
 25    Singleton(const Singleton&);
 26 
 27    //2)通过一个静态成员变量来维护唯一的对象
 28    static Singleton s_instance;
 29 
 30 private:
 31    int m_data;
 32 };
 33 
 34 Singleton Singleton::s_instance(12345);
 35 
 36 int main(int argc, char * argv[])
 37 {
 38   cout << "main begin" << endl;
 39   //Singleton s1;//error  
 40   Singleton& s1 = Singleton::getInstance();
 41   Singleton& s2 = Singleton::getInstance();
 42   cout << "&s1 = " << &s1 << endl;
 43   cout << "&s2 = " << &s2 << endl;
 44   s1.print();//12345
 45   s2.print();//12345
 46   
 47   return 0;
 48 }
~    
运行结果：
singleton create
main begin
&s1 = 0x601194
&s2 = 0x601194
12345
12345

4.2）懒汉式：用时再创建，不用即销毁（时间换空间）

 1 //单例模式：懒汉式
  2 #include <iostream>
  3 using namespace std;
  4 
  5 class Singleton
  6 {
  7 public:
  8   //3)通过静态成员函数获取单例对象
  9   static Singleton& getInstance(void)//必须加引用
 10   { 
 11     if(s_instance == NULL)
 12     { 
 13       s_instance = new Singleton(54321);
 14     }
 15     ++s_count;
 16     return *s_instance;
 17   }
 18   //单例可以被多个人同时适用，应该是最后一个使用者负责回收
 19   void release(void)
 20   {
 21     if(--s_count == 0)
 22     { 
 23       if(s_instance != NULL)
 24       { 
 25         delete s_instance;
 26         s_instance = NULL;
 27       }
 28     }
 29   }
 30   void print(void) const
 31   { 
 32     cout << m_data << endl;
 33   }
 34 
 35 private:
 36    //1)私有化构造函数 
 37    Singleton(int data = 0):m_data(data)
 38    { 
 39      cout << "singleton create" << endl;
 40    }
 41    Singleton(const Singleton&);
 42    ~Singleton(void)
 43    { 
 44      cout << "singleton destroy" << endl;
 45    }
 46 
 47    //2)通过一个静态成员变量来维护唯一的对象
 48    static Singleton *s_instance;
 49    //计数:记录使用单例对象的人数
 50    static int s_count;
 51 
 52 private:
 53    int m_data;
 54 };
 55 
 56 Singleton *Singleton::s_instance = NULL;
 57 int Singleton::s_count = 0;
 58 
 59 int main(int argc, char * argv[])
 60 {
 61   cout << "main begin" << endl;
 62   //Singleton s1;//error  
 63   Singleton& s1 = Singleton::getInstance();
 64   cout << "&s1 = " << &s1 << endl;
 65   s1.print();//12345
 66 
 67   Singleton& s2 = Singleton::getInstance();
 68   cout << "&s1 = " << &s1 << endl;
 69   cout << "&s2 = " << &s2 << endl;
 70   s1.release();
 71   s2.print();//12345
 72   s2.release();
 73 
 74   return 0;
 75 }