C++简明图解分析静态成员与单例设计模式

静态成员概述

1、静态成员包括静态成员数据、静态成员函数

2、成员数据、成员函数被 static修饰 就叫静态成员数据、静态成员函数

3、不管这个类创建了多少个对象，静态成员只有一份，这一份被所有属于这个类的对象共享。

4、静态成员 是属于类 而不是具体的某个对象。

5、静态成员 是在定义完类的时候 就存在了。

静态成员数据

静态变量，是在编译阶段就分配空间，对象还没有创建时，就已经分配空间。

静态成员变量必须在类中声明，在类外定义。

静态数据成员不属于某个对象，在为对象分配空间中不包括静态成员所占空间。

class Data
{
public:
  int num;//普通成员变量
  static int data;//静态成员变量(类内声明)
};
//定义的时候 不需要加static
int Data::data=100;//类外定义+初始化
void test01()
{
  //data是静态成员变量 是属于类 可以通过类名称::直接访问
  cout<<Data::data<<endl;//100
  //赋值
  Data::data = 200;
  cout<<Data::data<<endl;//200
  //data静态变量 是所有对象 共享的 可以通过对象名访问
  Data ob1;
  ob1.data = 300;
  cout<<Data::data<<endl;//300
  Data ob2;
  cout<<ob2.data<<endl;//300
  //普通成员变量 属于对象的 只能通过对象名访问
  ob1.num = 100;
  cout<<"ob2.num = "<<ob2.num<<endl;//随机值
  //cout<<Data::num<<endl;//普通成员变量不能通过类名称访问
}

static修饰静态成员函数

静态成员函数：只能访问私有静态数据

引出：

class Data
{
private:
  int num;//普通成员变量
  static int data;//静态成员变量(类内声明)
public:
  //普通成员函数 依赖于 对象的 必须对象调用
  int getData(void)
  {
      return data;
  }
};
//定义的时候 不需要加static
int Data::data=100;//类外定义+初始化
void test01()
{
  //cout<<Data::data<<endl;//err 静态data是私有的 类外不能直接访问
  //cout<< Data::getData()<<endl;//err getData() 必须对象调用
  Data ob;
  cout<<ob.getData()<<endl;
  //存在问题：data静态的 在创建对象之前 就已经存在
  //如果类没有实例化对象 难道 就不能使用data了吗？ 
  //解决上述问题 就要用到静态成员函数
}

静态成员函数：

class Data
{
private:
  int num;//普通成员变量
  static int data;//静态成员变量(类内声明)
public:
  //普通成员函数 依赖于 对象的 必须对象调用
  int getData(void)
  {
      return data;
  }
  //静态成员函数  属于类 而不属于对象
  static int getDataStatic(void)
  {
      return data;
  }
};
//定义的时候 不需要加static
int Data::data=100;//类外定义+初始化
void test01()
{
  //cout<<Data::data<<endl;//err 静态data是私有的 类外不能直接访问
  //cout<< Data::getData()<<endl;//err getData() 必须对象调用
  Data ob;
  cout<<ob.getData()<<endl;
  //存在问题：data静态的 在创建对象之前 就已经存在
  //如果类没有实例化对象 难道 就不能使用data了吗？
  //解决上述问题 就要用到静态成员函数
  //1、静态成员函数 属于类 就可以通过类名称直接访问
  cout<<Data::getDataStatic()<<endl;
  //2、也可以通过对象名访问（对象共享静态成员函数）
  cout<<ob.getDataStatic()<<endl;
}

注意：

1、静态成员函数的目的 操作静态成员数据。

2、静态成员函数 不能访问 非静态成员数据。（静态成员函数内部没有this指针）

3、普通成员函数 可以操作 静态成员数据 非静态成员数据。

4、静态成员变量 和 静态成员函数 都有权限之分。

const修饰静态成员

如果一个类的成员，既要实现共享，又要实现不可改变，那就用 static const 修饰

class Data
{
public:
  const static int data;//静态成员变量(类内声明)
public:
  //静态成员函数  属于类 而不属于对象
  static int getDataStatic(void)
  {
      //num = 200;//err 静态成员函数 不能访问普通成员变量
      return data;
  }
};
//定义的时候 不需要加static
const int Data::data=100;//类外定义+初始化
void test02()
{
  //访问
  cout<<Data::data<<endl;
  //赋值
  //Data::data = 200;//err data静态成员只读
  cout<<Data::data<<endl;
}

const修饰对象 叫常对象

const int num = 10;//系统不会给num开辟空间 num被放入符号表中 如果后期对&num 这时系统才会给num开辟空间

class Data
{
private:
  int data;
  mutable int num;
public:
  //遍历 成员的函数 不会去修改成员的值
  //如果函数不会更改成员数据 就让编译器知道 这是一个const函数
  void myPrintData(void) const
  {
      //data =10000;//err const修饰函数 函数不能操作普通成员变量
      cout<<this->data<<endl;
      //cout<<data<<endl;
      //mutable修饰的成员变量 可以修改
      num = 200;
  }
  //编译器认为 普通成员函数 存在修改成员变量 可能
  void setData(int data) const
  {
      //this->data = data;
      return;
  }
  Data()
  {
      cout<<"无参构造"<<endl;
  }
  Data(int data)
  {
      this->data =data;
      cout<<"有参构造"<<endl;
  }
  Data(const Data &ob)
  {
      this->data = ob.data;
      cout<<"拷贝构造"<<endl;
  }
  ~Data()
  {
      cout<<"析构函数"<<endl;
  }
};
void test03()
{
  //常对象
  const Data ob1(200);
  //常对象 只能调用const修饰的函数 遍历成员数据
  ob1.setData(20000);
  ob1.myPrintData();
}

运行结果：

const修饰成员函数

用const修饰的成员函数时，const修饰this指针指向的内存区域，成员函数体内不可以修改本类中的任何普通成员变量， 当成员变量类型符前用mutable修饰时例外。

int myFun(void) const //const修饰的是成员函数
{}//函数内部不能修改 普通成员变量  mutable修饰时例外

class Data2
{
public:
  int a;
  mutable int b;
public:
  Data2(int a, int b):a(a),b(b)
  {
//        this->a = a;
//        this->b = b;
  }
  //const修饰的是整个成员函数 表明在函数内部只能对数据成员 读操作
  void showData2(void) const
  {
      //a=100;//err
      //如果在const修饰的成员函数中 修改成员数据的值 请事先对成员数据进行mutable修饰
      b = 200;//ok
      cout<<"a="<<a<<", b="<<b<<endl;
  }
};
void test02()
{
  Data2 ob(10,20);
  ob.showData2();
}

静态成员案例

案例1：静态成员 统计类 实例化对象的 个数

#include <iostream>
using namespace std;
class Data
{
public:
  Data()
  {
      cout<<"无参构造"<<endl;
      count++;
  }
  Data(const Data &ob)
  {
      cout<<"拷贝构造函数"<<endl;
      count++;
  }
  ~Data()
  {
      count--;
      cout<<"析构函数"<<endl;
  }
  static int count;
};
int Data::count = 0;
int main(int argc, char *argv[])
{
  Data ob1;
  Data ob2;
  {
      Data ob3;
      Data ob4;
      cout<<"对象的个数:"<<Data::count<<endl;
  }
  cout<<"对象的个数:"<<Data::count<<endl;
  return 0;
}

运行结果：

单例模式

单例模式 所设计的类 只能实例化一个对象。

单例模式的步骤：

1、不允许Printer实例对象(把构造、拷贝构造函数私有化）

2、定义一个静态对象指针 保存唯一的对象地址

3、定义一个静态 成员函数 拿到唯一的对象的地址 方便外界使用

案例：

单例模式设计--打印机（重要）

步骤1：在单例类内部定义了一个Singleton类型的静态对象，作为外部共享的唯一实例

步骤2：提供一个公共静态的方法，让客户可以访问它的唯一实例。

步骤3：为了防止在外部对实例化其他对象，将其默认构造函数和拷贝构造函数设计为私有

#include <iostream>
using namespace std;
class Printer
{
public:
  //2、提供一个方法 获得单例指针
  static Printer* getSignlePrint(void)
  {
      return signlePrint;
  }
  //4、设置功能函数(自定义)
  void printText(char *str)
  {
      cout<<"打印"<<str<<endl;
      count++;
  }
  int count;
private:
  //1、定义一个静态的 对象指针变量 保存唯一实例地址
  static Printer *signlePrint;
private:
  //3、防止 该类实例化其他对象 将构造函数全部 私有
  Printer(){count=0;}
  Printer(const Printer &ob){}
};
Printer *Printer::signlePrint = new Printer;
int main(int argc, char *argv[])
{
  //打印任务1
  Printer *p1 = Printer::getSignlePrint();
  p1->printText("入职报告1");
  p1->printText("体检报告2");
  p1->printText("离职证明3");
  //打印任务2
  Printer *p2 = Printer::getSignlePrint();
  p2->printText("入职报告1");
  p2->printText("体检报告2");
  p2->printText("离职证明3");
  cout<<"打印任务数量:"<<p2->count<<endl;
  return 0;
}

运行结果：

到此这篇关于C++简明图解分析静态成员与单例设计模式的文章就介绍到这了,更多相关C++静态成员内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/qq_34981463/article/details/125054976