static修饰静态成员变量和静态成员函数

在成员变量和成员函数之前加上static关键词，称为静态成员

静态成员分为：

（1）静态成员变量

• 所有对象都共享同一份数据
• 编译阶段就分配内存
• 类内生命，类外进行初始化操作

（2）静态成员函数

• 程序共享一个函数
• 静态成员函数只能访问静态成员变量

实例代码1（静态成员变量）：

#include <iostream>

using namespace std;

class Person {
public:
    //静态成员变量特点：
    //1.所有对象都共享同一份数据
    //2.编译阶段就分配内存
    //3.类内声明，类外进行初始化操作
    static int m_A;

    //静态成员变量也是可以有访问权限的
private:
    static int m_B;

public:
    int getValue() {
        return Person::m_B;
    }
};

int Person::m_A = 100;
//即使m_B是私有的静态成员变量，依然可以在类外进行初始化
int Person::m_B = 200;

void test01() {
    //1.通过对象访问
    Person p1;
    cout << p1.m_A << endl;

    Person p2;
    p2.m_A = 50;
    cout << p2.m_A << endl;

    //2.通过类名访问，但只能是访问静态成员变量or静态成员函数
    cout << Person::m_A << endl;
}

void test02() {
    Person p;
    //错误，m_B是私有成员变量，无法访问
    //cout<<p.m_B<<endl;
}

int main() {
    test01();
    test02();
    Person p;
    cout << p.getValue() << endl;
}

 

实例代码2（静态成员函数）：

#include <iostream>

using namespace std;

class Person {
public:
    //静态成员函数特点：
    //1.程序共享一个函数
    //2.静态成员函数只能访问静态成员变量
    static void func1() {
        cout << "func1调用" << endl;
        m_A = 100;
        //m_B=100; //错误，不可以访问静态成员变量
    }

    static int m_A;
    int m_B;

    //静态成员函数也是可以有访问权限的
private:
    static void func2() {
        cout << "func2调用" << endl;
    }
};

int Person::m_A = 0;

void test() {
    //静态变量两种访问方式：
    //1.通过对象访问
    Person p1;
    p1.func1();

    //2.通过类名访问
    Person::func1();
    //Person::func2(); //私有权限无法访问
}

int main() {
    test();
}