c++：类和对象（3），对象模型和this指针

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

• 空对象占用内存空间为：1
• c++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
• 每个空对象也应该有一个独一无二的内存地址

 只有非静态成员变量 属于类的对象上，其余都不属于类的对象上

---

this指针概念

this指针 指向 被调用的成员函数所属的对象

this指针的用途：

• 当形参和成员变量名相同时，可以用this指针来区分
• 在类的非静态成员函数中返回对象本身，可使用return *this

1.解决名称冲突 

 

2. 使用 this 指针返回对象本身

在上述示例中，我们创建了一个名为 Point 的类，其中包含两个私有成员变量 x 和 y。在成员函数 setX 和 setY 中，我们使用 this 指针来返回对象本身。

setX 函数通过将传入的参数 x 赋值给对象的成员变量，并返回 *this，即对象本身。

setY 函数通过将传入的参数 y 赋值给对象的成员变量，并返回 *this，即对象本身。

在 main 函数中，我们创建了一个 Point 对象 point，初始坐标为 (0,0)。然后，我们通过连续调用 setX 和 setY 方法，分别设置对象的 x 和 y 坐标。由于 setX 和 setY 方法都返回对象本身，我们可以使用点运算符 . 连续调用这些方法。最后，我们调用 print 方法，打印对象的坐标。

通过使用 this 指针返回对象本身，我们可以实现链式调用对象的成员函数，提高代码的可读性和灵活性。

---

空指针访问成员函数

在上述示例中，我们定义了一个名为 MyClass 的类，并在其中声明了一个名为 myFunction 的成员函数。

在 main 函数中，我们创建了一个空指针 ptr 并将其初始化为 nullptr。接下来，我们尝试通过空指针 ptr 调用 myFunction 成员函数。

由于 ptr 是空指针，它并不指向任何有效的对象。因此，当尝试通过空指针访问成员函数时，会导致未定义的行为。

为了避免空指针访问成员函数导致的问题，我们应该在调用成员函数之前确保指针指向一个有效的对象。

---

const修饰成员函数

常函数：

• 成员函数后加const后我们称为这个函数为常函数
• 常函数内不可以修改成员属性
• 成员属性声明时加关键字mutable后，在常函数中依然可以修改

#include <iostream>

using namespace std;

class MyClass 
{
private:
    mutable int count; // 声明一个 mutable 成员属性

public:
    MyClass()
    {
        count = 0;
    }

    int getValue() const
    {
        count++; // 在常函数中修改 mutable 成员属性

        return count;
    }
};

int main()
{
    const MyClass obj;

    cout << "First Access: " << obj.getValue() << endl;
    cout << "Second Access: " << obj.getValue() << endl;

    return 0;
}

 

常对象： 

• 声明对象前加const称该对象为常对象
• 常对象只能调用常函数

#include <iostream>

using namespace std;

class MyClass 
{
public:
    void myFunction() const 
    {
        cout << "This is a constant member function." << endl;
    }

    void myNonConstFunction() 
    {
        cout << "This is a non-constant member function." << endl;
    }
};

int main() {
    const MyClass obj1;  // 声明一个常对象
    obj1.myFunction();  // 可以调用常函数
    // obj1.myNonConstFunction();  // 错误！不可以调用非常函数

    MyClass obj2;  // 声明一个非常对象
    obj2.myFunction();  // 可以调用常函数
    obj2.myNonConstFunction();  // 可以调用非常函数

    return 0;
}

在上述示例中，我们定义了一个名为 MyClass 的类，并声明了一个常对象 obj1 和一个非常对象 obj2。

常对象 obj1 被声明为 const，因此它只能调用常函数。在此例子中，我们使用 obj1.myFunction() 来调用常函数 myFunction()，它可以在常对象上执行，因为它不会修改对象的状态。而对于非常函数 myNonConstFunction()，尝试在常对象上调用会导致编译错误。

非常对象 obj2 没有被声明为 const，所以它可以调用常函数和非常函数。我们可以使用 obj2.myFunction() 来调用常函数，也可以使用 obj2.myNonConstFunction() 来调用非常函数。

常对象的存在可以确保对象在使用期间不会被意外地修改，提供了一定的安全性和保护性。常对象通常用于需要只读访问的情况，常函数则用于在常对象上进行操作而不改变其状态。

请注意，常对象的成员变量也被隐式声明为 const，即使没有显式使用 const 修饰。这意味着在常对象上，所有的成员变量都是只读的，不能被修改。