一、成员变量和成员函数分开存储

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

  1. 空对象也会占用内存

    C++编译器会给每个空对象也分配一个字节空间,是为了标志此对象占内存的位置。每个空对象也应该有一个独一无二的内存地址

    1
    class Person{};
    1
    cout << "size of p = " << sizeof(p) << endl;

    空对象占用1个字节内存

  2. 只有类的非静态成员变量,属于类的对象

    1
    2
    3
    class Person{
    int m_A;
    };
    1
    cout << "size of p = " << sizeof(p) << endl;

    只含一个int非静态成员变量的对象占用4个字节内存

  3. 类的静态成员变量,不属于类的对象

    1
    2
    3
    4
    5
    class Person{
    int m_A;
    static int m_B;
    };
    int Person::m_B = 100;
    1
    cout << "size of p = " << sizeof(p) << endl;

    对象还是占用4个字节内存

  4. 成员变量和成员函数是分开存储的

    1
    2
    3
    4
    5
    class Person{
    int m_A;
    static int m_B;
    void func(){}
    };
    1
    cout << "size of p = " << sizeof(p) << endl;

    对象还是占用4个字节内存

二、this指针

有上述可知,C++中成员变量和成员函数是分开存储的。

每一个非静态成员函数只会产生一份函数实例,也就是多个同类型的对象会共用一块代码,而代码如何区分哪个对象调用自己。

这里就用到了this指针,this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针

this指针不需要定义,直接使用即可

this指针的用途:

  • 形参和成员变量同名时,可以用this指针来区分

  • 在类的非静态成员函数中返回对象本身,可使用return *this

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include<iostream>
using namespace std;

class Person{
public:
Person(int money){
//this指针指向被调用的成员函数所属的对象
this->money = money; //如果不加this,则赋值两侧会认为是同一个money
}

Person& PersonAddMoney(Person &p){
this->money += p.money; //将传入的p对象的money加到此对象上
return *this; //this是指向对象的指针,*this就是指向对象本体
}

int money;
};

void test01(){
Person p1(18);
cout << "p1的财产为:" << p1.money << endl;
}

void test02(){
Person p1(10);
Person p2(10);
p2.PersonAddMoney(p1).PersonAddMoney(p1).PersonAddMoney(p1);//链式编程
cout << "p2的财产为:" << p2.money << endl;

}

int main(){

//test01();
test02();

system("pause");
return 0;
}

三、空指针访问成员函数

C++中空指针也可以调用成员函数,但是也要注意有没有用到this指针

如果用到this指针,需要加判断保证代码的健壮性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <iostream>
using namespace std;

class Person{
public:

void showClassName(){
cout << "This is Person class." << endl;
}

void showPersonAge(){
if(this == NULL){
return ;
}
cout << "age = " << this->m_Age << endl; //报错原因是传入的指针为空
}

int m_Age;
};

void test01(){
Person * p = NULL;
p->showClassName(); //空指针也可以正常执行
p->showPersonAge(); //如果不加if语句会报错
}

int main(){

test01();

system("pause");
return 0;
}

四、const修饰成员函数

常函数:

  • 成员函数后加const后我们称为这个函数为常函数

    1
    void showPerson() const {}
  • 常函数不可以修改成员属性

    常函数也存在this指针,而this指针的本质是指针常量,指针的指向是不可修改的。

    在成员函数后面加this,修饰的是this指向,让指针指向的值也不可以修改。

    1
    2
    3
    4
    5
    6
    7
    8
    class Person{
    public:
    void showPerson() const {
    this->m_A = 100; //报错
    }

    int m_A;
    }
  • 成员属性声明时加关键字mutable,在常函数中依然可以修改

    1
    mutable int m_B;

    创建了一个特殊的变量,即使在常函数中也可以修改,常对象也可以修改

常对象

  • 对象前加const,创建的是常对象

    1
    const Person p;
  • 常对象无法修改成员变量,值可以修改加mutable的变量

  • 常对象只能调用常函数,不能调用普通成员函数,因为普通成员函数可以修改属性

    参考:黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难
    链接https://www.bilibili.com/video/BV1et411b73Z