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

2024-06-06 20:04
文章标签 c++ 函数 指针 使用 对象 存储 变量 成员 const 关键词

本文主要是介绍C++中成员函数和变量的存储、this指针的使用和const关键词以及常对象，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

      • 1.成员变量和成员函数分开存储
      • 2.this指针
        • 1.概念
        • 2.链式调用
      • 3.空指针调用成员函数
      • 4.const修饰成员函数
      • 5.常对象

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和printInfop.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: 40return 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. 总结：

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

这篇关于C++中成员函数和变量的存储、this指针的使用和const关键词以及常对象的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1037092。

相关文章

Android kotlin中 Channel 和 Flow 的区别和选择使用场景分析

Android kotlin中 Channel 和 Flow 的区别和选择使用场景分析

《Androidkotlin中Channel和Flow的区别和选择使用场景分析》Kotlin协程中,Flow是冷数据流,按需触发,适合响应式数据处理；Channel是热数据流,持续发送,支持... 目录一、基本概念界定FlowChannel二、核心特性对比数据生产触发条件生产与消费的关系背压处理机制生命周期
阅读更多...
java使用protobuf-maven-plugin的插件编译proto文件详解

java使用protobuf-maven-plugin的插件编译proto文件详解

《java使用protobuf-maven-plugin的插件编译proto文件详解》：本文主要介绍java使用protobuf-maven-plugin的插件编译proto文件,具有很好的参考价... 目录protobuf文件作为数据传输和存储的协议主要介绍在Java使用maven编译proto文件的插件
阅读更多...
c++ 类成员变量默认初始值的实现

c++ 类成员变量默认初始值的实现

《c++类成员变量默认初始值的实现》本文主要介绍了c++类成员变量默认初始值,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录C++类成员变量初始化c++类的变量的初始化在C++中，如果使用类成员变量时未给定其初始值，那么它将被
阅读更多...
C++中NULL与nullptr的区别小结

C++中NULL与nullptr的区别小结

《C++中NULL与nullptr的区别小结》本文介绍了C++编程中NULL与nullptr的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编... 目录C++98空值——NULLC++11空值——nullptr区别对比示例 C++98空值——NUL
阅读更多...
SpringBoot线程池配置使用示例详解

SpringBoot线程池配置使用示例详解

《SpringBoot线程池配置使用示例详解》SpringBoot集成@Async注解,支持线程池参数配置（核心数、队列容量、拒绝策略等）及生命周期管理,结合监控与任务装饰器,提升异步处理效率与系统... 目录一、核心特性二、添加依赖三、参数详解四、配置线程池五、应用实践代码说明拒绝策略（Rejected
阅读更多...
C++ Log4cpp跨平台日志库的使用小结

C++ Log4cpp跨平台日志库的使用小结

《C++Log4cpp跨平台日志库的使用小结》Log4cpp是c++类库,本文详细介绍了C++日志库log4cpp的使用方法,及设置日志输出格式和优先级,具有一定的参考价值,感兴趣的可以了解一下... 目录一、介绍1. log4cpp的日志方式2.设置日志输出的格式3. 设置日志的输出优先级二、Window
阅读更多...
Ubuntu如何分配​​未使用的空间

Ubuntu如何分配​​未使用的空间

《Ubuntu如何分配​​未使用的空间》Ubuntu磁盘空间不足,实际未分配空间8.2G因LVM卷组名称格式差异（双破折号误写）导致无法扩展,确认正确卷组名后,使用lvextend和resize2fs... 目录1：原因2：操作3：报错5：解决问题：确认卷组名称​6：再次操作7：验证扩展是否成功8：问题已解
阅读更多...
Qt使用QSqlDatabase连接MySQL实现增删改查功能

Qt使用QSqlDatabase连接MySQL实现增删改查功能

《Qt使用QSqlDatabase连接MySQL实现增删改查功能》这篇文章主要为大家详细介绍了Qt如何使用QSqlDatabase连接MySQL实现增删改查功能,文中的示例代码讲解详细,感兴趣的小伙伴... 目录一、创建数据表二、连接mysql数据库三、封装成一个完整的轻量级 ORM 风格类3.1 表结构
阅读更多...
使用Docker构建Python Flask程序的详细教程

使用Docker构建Python Flask程序的详细教程

《使用Docker构建PythonFlask程序的详细教程》在当今的软件开发领域,容器化技术正变得越来越流行,而Docker无疑是其中的佼佼者,本文我们就来聊聊如何使用Docker构建一个简单的Py... 目录引言一、准备工作二、创建 Flask 应用程序三、创建 dockerfile四、构建 Docker
阅读更多...
Python使用vllm处理多模态数据的预处理技巧

Python使用vllm处理多模态数据的预处理技巧

《Python使用vllm处理多模态数据的预处理技巧》本文深入探讨了在Python环境下使用vLLM处理多模态数据的预处理技巧,我们将从基础概念出发,详细讲解文本、图像、音频等多模态数据的预处理方法,... 目录1. 背景介绍1.1 目的和范围1.2 预期读者1.3 文档结构概述1.4 术语表1.4.1 核
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2