C++零碎记录（五）-Toy模板网

这篇具有很好参考价值的文章主要介绍了C++零碎记录（五）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

9. 静态成员

① 静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员。

② 静态成员分为：

1. 静态成员变量
--所有对象共享同一份数据
--在编译阶段分配内存
--类内声明，类外初始化
2. 静态成员函数
--所有对象共享同一个函数
--静态成员函数只能访问静态成员变量

③ 调用静态成员函数有两种方法：

1. 通过对象调用
2. 通过类名调用

9.1 静态成员变量

#include<iostream>
using namespace std;

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

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

int Person::m_A = 100;

void test01()
{
    Person p;
    cout << p.m_A << endl;

    Person p2;
    p2.m_A = 200;

    //100 ? 200，共享同一份数据，所以p.m_A为200
    cout << p.m_A << endl;
}

void test02()
{
    //静态成员变量 不属于某个对象上，所有对象都共享同一份数据
    //因此静态成员变量有两种访问方式
    
    //1、通过对象进行访问
    Person p;
    cout << p.m_A << endl;

    //2、通过类名进行访问
    cout << Person::m_A << endl;

    //cout << Person::m_B << endl; //报错，私有作用域，出了类是不可以访问的
}

int main()
{
    test01();

    test02();

    system("pause");
}

运行结果：

100
200
200
200
请按任意键继续. . .

9.2 静态成员函数

#include <iostream>
using namespace std;

//静态成员函数
//所有对象共享同一个函数
//静态成员函数只能访问静态成员变量
class Person
{
public:
    //静态成员函数
    static void func()
    {
        m_A = 100; //静态成员函数可以访问静态成员变量，这个数据是共享的，只有一份，所以不需要区分哪个对象的。                                
        //m_B = 200; //静态成员函数不可以访问非静态成员变量，无法区分到底是哪个对象的m_B属性，非静态成员变量属于特定的对象上面
        cout << "static void func调用" << endl;
    }
    
    static int m_A; //静态成员变量
    int m_B; //非静态成员变量

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

int Person::m_A = 0;

//有两种访问方式
void test01()
{
    //1、通过对象访问
    Person p;
    p.func();

    //2、通过类名访问
    Person::func();   //静态成员函数，所有对象共享同一个函数，可以直接通过类名访问。

    //Person::func2(); //类外访问不到私有静态成员函数
}

int main()
{
    test01();

    system("pause");

    return 0;

}

运行结果：

static void func调用
static void func调用
请按任意键继续. . .

9.3 成员变量和成员函数分开存储

① 在C++中，类内对的成员变量和成员函数分开存储，只有非静态成员变量才属于类的对象上。

#include <iostream>
using namespace std;

class Person01
{
public:
    
};

class Person02
{
public:
    int m_A; //非静态成员变量  属于类的对象上

    static int m_B;  //静态成员变量 不属于类对象上

    //void fun(){} //非静态成员函数 不属于类对象上

    static void func2() {} //静态成员函数 不属于类的对象上
};

int Person02::m_B = 0;

void test01()
{
    Person01 p;

    //空对象占用内存空间为：1
    //C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
    //每个空对象也应该有一个独一无二的内存空间
    cout << "size of p = " << sizeof(p) << endl;
}

void test02()
{
    Person02 p2;

    cout << "size of p2 = " << sizeof(p2) << endl;  //通过打印内存空间大小，检测静态成员变量、非静态成员函数等在不在对象内存上....      
}

int main()
{
    test01();
    test02();  

    system("pause");

    return 0;

}

运行结果：