• 静态成员：被static修饰的成员变量\函数

  • 可以通过对象（对象.静态成员）、对象指针（对象指针->静态成员）、类访问（类名::静态成员）

• 静态成员变量

  • 存储在数据段（全局区，类似于全局变量），整个程序运行过程中只有一份内存
  • 对比全局变量，它可以设定访问权限（public、protected、private），达到局部共享的目的
  • 必须初始化，必须在类外面初始化，初始化时不能带static，如果类的声明和实现分离（在实现.cpp中初始化）

• 静态成员函数

  • 内部不能使用this指针（this指针只能用在非静态成员函数内部）
  • 不能是虚函数（虚函数只能是非静态成员函数)
  • 内部不能访问非静态成员变量\函数，只能访问静态成员变量\函数
  • 非静态成员函数内部可以访问静态成员变量\函数
  • 构造函数、析构函数不能是静态
  • 当声明和实现分离时，实现部分不能带static

• 非静态成员变量

  class Person {
  public:
      int m_age;
  };
  
  
  int main() {
  
      Person p1;
      p1.m_age = 10;
      Person p2;
      p2.m_age = 20;
      Person p3;
      p3.m_age = 30;
  }

  内存互不干扰，分别存各自实例的变量值

• 静态成员变量

  class Person {
  public:
      /// 此处不能初始化，初始化会编译报错
      static int m_age;
  };
  
  /// 初始化静态成员变量
  /// 静态成员变量需要在类外面初始化， 并且不能在初始化的时候重复添加 static 关键字
  int Car::m_age = 0;
  
  
  int main() {
      /// 方式一： 通过实例对象访问
      Person p1;
      p1.m_age = 10;
      Person p2;
      p2.m_age = 20;
      Person p3;
      p3.m_age = 30;
  
      /// 方式二： 通过类名访问
      Person::m_age = 400;
  
      /// 方式三： 对象指针
      Person *p = new Person()
      p->m_age = 400;
      delete p;
  
      /// 四次访问的是同一块内存，最终m_age的值为 400
  }

  使用 static 关键字后，m_age 变成静态成员变量，全局就一份内存，不依赖于实例对象而存在

• 静态成员函数

  class Person {
  public:
      /// 此处不能初始化，初始化会编译报错
      static int run() { 
          /// 作用域内不允许使用this
       }
  };
  
  int main() {
      /// 方式一： 通过实例对象访问
      Person p1;
      p1.run();
      /// 方式二： 通过指针
      Person *p2 = new Person();
      p2->run();
      /// 方式三： 通过类名
      Person::run();
  }

通过汇编对比普通成员变量和静态成员变量 普通成员变量: 操作栈空间内存 静态成员变量: 操作一个固定内存地址（ds 数据段） 普通全局变量: 操作一个固定内存地址（ds 数据段）

静态成员变量和普通的全局变量存放的相同区域，都是全局区

class Person {
public:
    static int m_age;
};

int Person::m_age = 10;

class Student: public Person {

}

int main() {
    
    /// 打印两个内存地址是一样的
    cout << &Student::m_age endl;
    cout << &Person::m_age endl;
    return 0;
}

静态全局变量与全局变量的区别就是被限制了作用域和访问方式

int Person::m_age = 10;
int Student::m_age = 5;

class Person {
public:
    static int m_age;
};

class Student: public Person {
    static int m_age;
}

int main() {
    
    /// 打印两个内存地址是不一样的
    cout << &Student::m_age endl;
    cout << &Person::m_age endl;
    return 0;
}

给派生类硬写一个同名的静态成员变量，那么就是两个独立的内存区域