C++中成员函数和变量的存储、this指针的使用和const关键词以及常对象

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

1. 成员变量：

   • 成员变量是类的数据部分，它们存储了类的实例（对象）的状态信息。
   • 当创建一个类的实例时，会为该实例分配内存来存储其成员变量。这些变量通常存储在堆（对于动态分配的对象）或栈（对于局部或自动分配的对象）上。
   • 成员变量在内存中的存储位置是连续的（对于简单的数据类型），或者是指向实际数据的指针（对于复杂的数据类型，如字符串或动态数组）。

2. 成员函数：

   • 成员函数是类的行为部分，它们定义了对象可以执行的操作。
   • 与成员变量不同，成员函数本身并不存储在类的实例的内存中。相反，成员函数的代码（即函数体）存储在代码段（也称为文本段或文本区）中，这是程序的一部分，其中包含了程序的执行指令。
   • 当成员函数被调用时，它使用特定的机制（如this指针在C++中）来访问和修改对象的状态（即成员变量）。this指针是一个指向调用该成员函数的对象的指针，它允许成员函数知道它正在操作哪个对象。

#include <iostream>

class MyClass {
public:
    // 成员变量
    int myInt;
    double myDouble;

    // 成员函数
    MyClass(int i, double d) : myInt(i), myDouble(d) {} // 构造函数
    void printValues() {
        std::cout << "myInt: " << myInt << ", myDouble: " << myDouble << std::endl;
    }
};

int main() {
    // 创建MyClass的实例（对象）
    MyClass obj(10, 3.14);

    // 调用成员函数
    obj.printValues();

    return 0;
}

在这个示例中：

• MyClass 是一个类，它有两个成员变量 myInt 和 myDouble，以及一个成员函数 printValues。
• 在 main 函数中，我们创建了一个 MyClass 的实例 obj，并通过构造函数初始化了它的成员变量。
• 当我们调用 obj.printValues() 时，成员函数 printValues 被执行。尽管我们调用的是 obj 的方法，但 printValues 函数的代码本身并不存储在 obj 所占用的内存中。相反，它的代码存储在程序的代码段中。

从内存的角度来看：

• obj 的成员变量 myInt 和 myDouble 会被分配在栈上（如果 obj 是在 main 函数中局部声明的）或者在堆上（如果 obj 是通过 new 运算符动态分配的）。
• 成员函数 printValues 的代码则存储在程序的代码段（或文本段）中，这是程序在加载到内存时就已经确定好的。

当 printValues 被调用时，它会通过 this 指针（尽管在上面的示例中没有显式使用）知道它正在操作哪个对象（即 obj），并可以访问和修改该对象的成员变量。

注意：空对象占用的内存空间大小为：1。非静态成员变量，属于类的对象上。静态成员变量，不属于类的对象上边。

2.this指针

1.概念

在C++中，this指针是一个隐式的指针，它指向调用成员函数的对象本身。当一个成员函数被调用时，编译器会自动将调用该函数的对象的地址赋值给this指针。this指针主要用于以下目的：

1. 区分成员变量和局部变量：当成员变量和函数参数或局部变量重名时，this->前缀可以用来明确指出引用的是成员变量。

2. 返回对象本身的引用：在成员函数中，this指针可以被返回以获取对调用对象的引用。

3. 用于链式调用：一些成员函数返回*this的引用，允许链式调用多个成员函数。

4. 在构造函数中初始化其他成员：在构造函数中，可以使用this指针来区分成员变量和构造函数参数。

下面是一个使用this指针的示例：

#include <iostream>
#include <string>

class Person {
private:
    std::string name;
    int age;

public:
    Person(std::string name, int age) : name(name), age(age) {}

    // 使用this指针来区分成员变量和参数
    void setName(std::string name) {
        this->name = name; // 这里的this->name指的是类的成员变量
    }

    void setAge(int age) {
        this->age = age; // 这里的this->age也是类的成员变量
    }

    // 返回一个指向调用对象的引用，用于链式调用
    Person& printAndModifyName(const std::string& newName) {
        std::cout << "Original name: " << this->name << std::endl;
        this->name = newName;
        std::cout << "Modified name: " << this->name << std::endl;
        return *this; // 返回当前对象的引用
    }

    void printInfo() const {
        std::cout << "Name: " << this->name << ", Age: " << this->age << std::endl;
    }
};

int main() {
    Person p("Alice", 30);
    p.printInfo(); // 输出原始信息

    // 链式调用printAndModifyName和printInfo
    p.printAndModifyName("Bob").printInfo(); // 输出修改后的信息

    return 0;
}

在这个例子中，setName和setAge成员函数使用this指针来区分成员变量和参数。printAndModifyName成员函数返回*this的引用，允许链式调用。printInfo成员函数是一个常量成员函数，它使用this指针（尽管在这个特定的例子中并不需要显式使用this，因为编译器会自动处理）来访问成员变量。

尽管this指针在成员函数中经常被隐式使用，但在某些情况下，如需要显式区分成员变量和参数，或者需要返回对象的引用以进行链式调用时，你可以使用this指针。然而，在大多数情况下，你不需要（也不应该）在代码中显式地写出this指针。

2.链式调用

链式调用（Chaining）是一种在面向对象编程中常用的技术，它允许在单个语句中连续调用同一个对象的多个方法。为了支持链式调用，这些方法通常返回对调用对象的引用（通常是*this）。

#include <iostream>
#include <string>

class Person {
private:
    std::string name;
    int age;

public:
    Person(std::string name, int age) : name(name), age(age) {}

    // 设置名字，并返回对当前对象的引用以支持链式调用
    Person& setName(const std::string& newName) {
        name = newName;
        return *this; // 返回当前对象的引用
    }

    // 设置年龄，并返回对当前对象的引用以支持链式调用
    Person& setAge(int newAge) {
        age = newAge;
        return *this; // 返回当前对象的引用
    }

    // 打印信息
    void printInfo() const {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Person p("Alice", 30);

    // 链式调用 setName 和 setAge 方法
    p.setName("Bob").setAge(40);

    // 打印信息
    p.printInfo(); // 输出：Name: Bob, Age: 40

    return 0;
}

在这个示例中，setName 和 setAge 方法都返回 *this，即当前对象的引用。这样，我们就可以在单个语句中连续调用这两个方法，实现链式调用。最后，我们调用 printInfo 方法来打印修改后的信息。

链式调用可以使代码更加简洁和易读，特别是在需要连续设置多个属性或执行多个操作时。但是，过度使用链式调用也可能导致代码难以理解和维护，因此应该根据具体情况谨慎使用。

3.空指针调用成员函数

在C++中，尝试通过空指针（nullptr 或 NULL）调用成员函数通常是未定义行为（Undefined Behavior, UB），但这是因为对成员函数本身的调用并不直接通过指针解引用。然而，如果成员函数内部试图访问或修改对象的成员变量（即使用this指针），并且该指针是空的，那么这会导致运行时错误或未定义行为。

成员函数并不存储在对象的内存中，而是存储在代码段中。当通过对象指针调用成员函数时，编译器实际上是在函数内部隐式地传递一个指向对象的指针（即this指针）。但是，如果传递的是一个空指针，那么在函数内部使用该指针来访问成员变量就会是危险的。

虽然很多编译器在通过空指针调用成员函数时可能不会立即报错（特别是当函数不实际使用this指针时），但这并不意味着这是安全的或可移植的。未定义行为意味着程序可能崩溃、产生不正确的结果或表现出其他不可预测的行为。

下面是一个示例，展示了通过空指针调用成员函数并尝试访问成员变量时可能发生的问题：

#include <iostream>

class MyClass {
public:
    int value = 42;

    void printValue() {
        std::cout << "Value: " << this->value << std::endl; // 如果this是空指针，这里会崩溃
    }
};

int main() {
    MyClass* ptr = nullptr;
    ptr->printValue(); // 这是未定义行为，可能会导致程序崩溃
    return 0;
}

在这个例子中，printValue成员函数试图通过this指针访问成员变量value。但是，因为ptr是一个空指针，所以this指针也是空的，这会导致尝试访问无效的内存地址，从而可能导致程序崩溃。

为了避免这种情况，你应该始终确保在调用成员函数之前，对象指针不是空的。可以通过检查指针是否为空来避免这种错误：

if (ptr != nullptr) {
    ptr->printValue();
} else {
    std::cout << "Pointer is null!" << std::endl;
}

4.const修饰成员函数

在C++中，使用const修饰成员函数表示该函数不会修改其所属对象的任何非静态成员变量（除非这些成员变量被声明为mutable）。这允许我们在常对象上调用这些函数，因为编译器知道这些函数不会改变对象的状态。

1. 声明：在成员函数的声明后添加const关键字，以表示该函数是常量成员函数。

   class MyClass {
   public:
       int value;
   
       // 这是一个常量成员函数
       int getValue() const { return value; }
   
       // 这是一个非常量成员函数
       void setValue(int v) { value = v; }
   };
   

2. 调用：常量成员函数可以在常对象或非常对象上调用，而非常量成员函数只能在非常对象上调用。

   int main() {
       MyClass obj;
       obj.setValue(10); // 正确：非常对象上调用非常量成员函数
       std::cout << obj.getValue() << std::endl; // 正确：非常对象上调用常量成员函数
   
       const MyClass constObj;
       // constObj.setValue(20); // 错误：不能在常对象上调用非常量成员函数
       std::cout << constObj.getValue() << std::endl; // 正确：常对象上调用常量成员函数
   
       return 0;
   }
   

3. 函数体中的限制：在常量成员函数的函数体中，你不能修改任何非静态成员变量的值（除非它们被声明为mutable）。如果尝试这样做，编译器会报错。

   class MyClass {
   public:
       int value;
   
       // 错误：尝试在常量成员函数中修改非静态成员变量
       void someFunction() const {
           value = 10; // 错误：不能修改成员变量在常量成员函数中
       }
   };
   

4. 重载与const成员函数：你可以根据成员函数是否带const来重载它。这意味着你可以有一个非const版本的成员函数和一个const版本的成员函数，它们具有相同的名称和参数列表，但一个带const而另一个不带。

   class MyClass {
   public:
       int value;
   
       int* getValuePtr() { return &value; } // 非常量版本
       const int* getValuePtr() const { return &value; } // 常量版本
   };
   

5. this指针的const版本：在常量成员函数中，this指针的类型是指向常量对象的指针（即const MyClass* const this）。这确保了成员函数不能通过this指针来修改对象的状态。

6. mutable关键字：尽管const成员函数通常不会修改其所属对象的状态，但某些情况下可能需要在const成员函数中修改某个成员变量。为此，可以使用mutable关键字来修饰该成员变量，这样即使在const成员函数中也可以修改它。

   class MyClass {
   public:
       mutable int mutableValue; // 可以在const成员函数中修改
   
       void someConstFunction() const {
           mutableValue = 10; // 正确：可以在const成员函数中修改mutable成员变量
       }
   };
   

5.常对象

常对象在C++中是一个特殊的对象，它是指用const修饰符声明的对象。常对象具有以下特性和限制：

1. 定义：

   • 常对象在声明时必须进行初始化，因为它不能被修改。
   • 定义格式通常如下：const 类名 对象名; 或者 类名 const 对象名;

2. 特性：

   • 不可修改：常对象的数据成员在对象创建后不能被更新。
   • 函数调用限制：常对象只能调用类的常成员函数（即成员函数声明中包含const关键字的函数）。这是因为非const成员函数可能会尝试修改对象的状态，而常对象是不允许修改的。

3. 初始化：

   • 常对象必须在定义时进行初始化，否则编译器会报错。

4. 语法示例：

   class MyClass {
   public:
       int value;
       void setValue(int v) { value = v; } // 非const成员函数
       void printValue() const { std::cout << "Value: " << value << std::endl; } // const成员函数
   };
   
   int main() {
       const MyClass obj1{42}; // 常对象，初始化时设置value为42
       // obj1.setValue(100); // 错误：不能调用非const成员函数来修改常对象
       obj1.printValue(); // 正确：可以调用const成员函数
   
       MyClass obj2{50}; // 非常对象
       obj2.setValue(100); // 正确：可以修改非常对象
       obj2.printValue(); // 正确：可以调用const成员函数
   
       return 0;
   }
   

5. 注意事项：

   • 当尝试在常对象上调用非const成员函数时，编译器会报错，因为这违反了常对象的不可修改性。
   • 类的常成员函数可以访问常对象和非常对象的成员（包括数据成员和成员函数），但是它们不能修改任何非静态成员变量（除非这些变量被声明为mutable）。

6. 总结：

   • 常对象是一种特殊的对象，它在整个生命周期中都是只读的，不能被修改。
   • 常对象只能调用类的常成员函数，这是为了确保对象的不可修改性。
   • 常对象在定义时必须进行初始化，并且之后不能被重新赋值。