C++ static

静态成员

• 静态成员: 被static修饰的成员变量/函数
  可以通过对象（对象.静态成员）、对象指针（对象指针->静态成员）、类访问（类名::静态成员）
• 静态成员变量
  存储在数据段（全局区，类似于全局变量），整个程序运行过程中只有一份内存
  不需要创建对象就存在
  对比全局变量，它可以设定访问权限（public、protected、private），达到局部共享的目的
  必须初始化，必须在类外面初始化，初始化时不能带static，如果类的声明和实现分离（在实现.cpp中初始化）
• 静态成员函数
  内部不能使用this指针（this指针只能用在非静态成员函数内部）
  不能是虚函数（虚函数只能是非静态成员函数）
  内部不能访问非静态成员变量\函数，只能访问静态成员变量\函数
  非静态成员函数内部可以访问静态成员变量\函数
  构造函数、析构函数不能是静态
  当声明和实现分离时，实现部分不能带static

  class Car {
  public:
      static int m_price;
      void run() {
          std::cout << "run" << std::endl;
      }
  };
  int Car::m_price = 0; //在类外面初始化成员变量

  class Car {
  protected:
      int m_age;
      static int m_price;
  public:
      void run() {
          std::cout << "run" << std::endl;
          m_price = 10;
      }
  };
  int Car::m_price = 0;

static 应用

#include <iostream>
#include <cstdio>
using namespace std;

class Car {
private:
    static int ms_count;
public: 
    Car() {
        ms_count++;
    }
    ~Car() {
        ms_count--;
    }
    static int getcount() {
        return ms_count;
    }
};
int Car::ms_count = 0;

Car g_car;

int main() {
    Car car;
    Car* p = new Car();
    delete p;
    cout << Car::getcount() << endl;


    return 0;
}

static 单例模式

单例模式：设计模式的一种,保证某个类只能创建一个对象

1. 构造函数/析构函数私有化
2. 定义一个私有的static成员变量指向唯一的那个单例对象
3. 提供一个公共的访问单例对象的接口

#include <iostream>
using namespace std;


class Rocket {
private:
    Rocket() {}
    ~Rocket() {}
    static Rocket* ms_rocket;
public:
    static Rocket* shareRocket() {
        //这里要考虑多线程安全 
        if (ms_rocket == NULL) {
            ms_rocket = new Rocket();
        }
        return ms_rocket;
    }
    static void deleteRocket() {
        //需要考虑多线程安全
        if (ms_rocket != NULL) {
            delete ms_rocket;
            ms_rocket = NULL;
        }
    }
    void run() {
        cout << "Rocket::run" << endl;
    }
};
Rocket* Rocket::ms_rocket = NULL;


int main() {
    Rocket* p1 = Rocket::shareRocket();  
    Rocket* p2 = Rocket::shareRocket();
    Rocket* p3 = Rocket::shareRocket();
    Rocket* p4 = Rocket::shareRocket();
    //delete(p1);
    p1->run();
    cout << p1 << endl;
    cout << p2 << endl;
    cout << p3 << endl;
    cout << p4 << endl;
    //Rocket rocket1;


    return 0;
}