【十】类的静态成员

1、类的静态成员

• 在C++中可以定义静态成员变量和静态成员函数
• 静态成员属于整个类所有，不需要依赖任何对象，会在全局数据区分配空间
• 静态成员可以是public、private和protected的
• 可以在类外，通过类名或者对象名直接访问public静态成员
• 不可以在类外，访问private或protected静态成员
• 类的成员函数不用通过作用域运算符，就可以直接访问静态成员变量

 
 
2、静态成员声明与定义

静态成员变量：

• 在类内部声明时直接通过static关键字修饰
• 静态成员变量不依赖于任何对象，需要在类外单独分配空间
• 要在类外进行初始化

静态成员函数：

• 在声明时直接通过static关键字修饰
• 其余部分与普通成员函数定义相同

示例：

exp-1.cpp

#include <stdio.h>

class Test
{
protected:
    static int cI;      //声明静态成员变量

public:
    static int GetI()   //静态成员函数
    {
        return cI;
    }

    static void SetI(int i)  //静态成员函数
    {
        cI = i;
    }

    void print()
    {
        printf("cI = %d\n", cI);
    }
};

int Test::cI = 0;   //定义静态成员变量，并初始化

int main()
{
    Test::SetI(5);

    printf("Test::cI = %d\n", Test::GetI());

    Test t1;
    Test t2;

    t1.print();
    t2.print();

    t1.SetI(10);
    t2.print();

    printf("Test::cI = %d\n", Test::GetI());

    return 0;
}

 
 
3、静态成员的分析

• 从命名空间的角度
  
  • 类的静态成员只是类这个命名空间中的全局变量和全局函数
  • 不同之处只是，类可以对静态成员进行访问权限的限制，而命名空间不行
• 从面向对象的角度
  
  • 类的静态成员属于类概念本身
  • 类的所有对象共享相同的静态成员

 
 
4、静态成员函数和普通成员函数的区别

思考：
  下面程序输出什么？

#include <iostream>

using namespace std;

struct c1
{
  int   i;
  int   j;
  short k;
  short l;
};

class c2
{
  int   i;
  int   j;
  short k;
  short l;
};

class c3
{
private:
  int   i;
  int   j;
  short k;
  short l;

  static int c;
public:
  c3()
  {

  }
  void print()
  {

  }
};

int c3::c = 0;

int main()
{

  cout << "sizeof(c1) = " << sizeof(c1) << endl;
  cout << "sizeof(c2) = " << sizeof(c2) << endl;
  cout << "sizeof(c3) = " << sizeof(c3) << endl;
  return 0;
}

运行结果：

Tip：

通过以上代码说明：

C++类对象中的成员变量和成员函数是分开存储的

• 成员变量
  
  • 普通成员变量：存储于对象中，与struct变量有相同的内存布局和字节对齐方式
  • 静态成员变量：存储于全局数据区中
• 成员函数
  
  • 存储于代码段中

C++对象模型初探

• C++中的class从面向对象理论出发，将变量和函数集中定义在一起，用于描述现实世界中的类
• 从计算机的角度，程序依然由数据段和代码段构成

思考：
  C++编译器如何完成面向对象理论到计算机程序的转化？

我的一种猜测：

综上所述：
  静态成员函数与普通成员函数的区别

• 静态成员函数不包含指向具体对象的指针
• 普通成员函数包含一个指向具体对象的指针

Tip：
  C++中类的普通成员函数都隐式包含一个指向当前对象的this指针。

 
 
5、利用静态成员实现类对象的单例模式

所谓单例模式，即该类只有一个实例对象！

示例：

#include <iostream>
using namespace std;

class SingleItem
{
private:
    SingleItem();
public:
    ~SingleItem();
    static SingleItem* GetInstance();   //用两个静态函数来构造和销毁对象的单实例
    static void DestroyInstance();

private:
    static SingleItem* cInstance;       //保存对象的单示例指针

};

SingleItem* SingleItem::cInstance = nullptr;

SingleItem::SingleItem()
{
    cout << "SingleItem()" << endl;
}

SingleItem::~SingleItem()
{
    cout << "~SingleItem()" << endl;
}


SingleItem* SingleItem::GetInstance()
{
    if (cInstance == nullptr)
    {
        cout << "GetInstance()" << endl;
        cInstance = new SingleItem;     //自动调用构造函数
    }
    return cInstance;
}


void SingleItem::DestroyInstance()
{
    if (cInstance != nullptr)
    {
        cout << "DestroyInstance()" << endl;
        delete cInstance;           //自动调用析构函数
        cInstance = nullptr;
    }
}

void func()
{
    SingleItem* p = SingleItem::GetInstance();
    SingleItem* pp = SingleItem::GetInstance();

    cout << p << '\t' << pp << endl;        //两次调用，得到的值是一样的

    SingleItem::DestroyInstance();

    p = nullptr;
    pp = nullptr;
}

int main()
{

    func();

    cout << "Press any key to continue..." << endl;
    cin.get();
    return 0;
}

 
 
6、小结

• C++类中可以包含属于类概念的静态成员
• 静态成员变量在全局数据区分配空间
• 静态成员函数不包含隐藏的this指针
• 通过类名可以直接访问静态成员
• 通过对象名可以访问静态成员，所有的对象可以共享同一个类的静态成员