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

2024-06-06 20:04

本文主要是介绍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 是一个类,它有两个成员变量 myIntmyDouble,以及一个成员函数 printValues
  • main 函数中,我们创建了一个 MyClass 的实例 obj,并通过构造函数初始化了它的成员变量。
  • 当我们调用 obj.printValues() 时,成员函数 printValues 被执行。尽管我们调用的是 obj 的方法,但 printValues 函数的代码本身并不存储在 obj 所占用的内存中。相反,它的代码存储在程序的代码段中。

从内存的角度来看:

  • obj 的成员变量 myIntmyDouble 会被分配在栈上(如果 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;
}

在这个例子中,setNamesetAge成员函数使用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;
}

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

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

3.空指针调用成员函数

在C++中,尝试通过空指针(nullptrNULL)调用成员函数通常是未定义行为(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

相关文章

postgresql使用UUID函数的方法

《postgresql使用UUID函数的方法》本文给大家介绍postgresql使用UUID函数的方法,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录PostgreSQL有两种生成uuid的方法。可以先通过sql查看是否已安装扩展函数,和可以安装的扩展函数

MySQL字符串常用函数详解

《MySQL字符串常用函数详解》本文给大家介绍MySQL字符串常用函数,本文结合实例代码给大家介绍的非常详细,对大家学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录mysql字符串常用函数一、获取二、大小写转换三、拼接四、截取五、比较、反转、替换六、去空白、填充MySQL字符串常用函数一、

如何使用Lombok进行spring 注入

《如何使用Lombok进行spring注入》本文介绍如何用Lombok简化Spring注入,推荐优先使用setter注入,通过注解自动生成getter/setter及构造器,减少冗余代码,提升开发效... Lombok为了开发环境简化代码,好处不用多说。spring 注入方式为2种,构造器注入和setter

MySQL中比较运算符的具体使用

《MySQL中比较运算符的具体使用》本文介绍了SQL中常用的符号类型和非符号类型运算符,符号类型运算符包括等于(=)、安全等于(=)、不等于(/!=)、大小比较(,=,,=)等,感兴趣的可以了解一下... 目录符号类型运算符1. 等于运算符=2. 安全等于运算符<=>3. 不等于运算符<>或!=4. 小于运

使用zip4j实现Java中的ZIP文件加密压缩的操作方法

《使用zip4j实现Java中的ZIP文件加密压缩的操作方法》本文介绍如何通过Maven集成zip4j1.3.2库创建带密码保护的ZIP文件,涵盖依赖配置、代码示例及加密原理,确保数据安全性,感兴趣的... 目录1. zip4j库介绍和版本1.1 zip4j库概述1.2 zip4j的版本演变1.3 zip4

Python 字典 (Dictionary)使用详解

《Python字典(Dictionary)使用详解》字典是python中最重要,最常用的数据结构之一,它提供了高效的键值对存储和查找能力,:本文主要介绍Python字典(Dictionary)... 目录字典1.基本特性2.创建字典3.访问元素4.修改字典5.删除元素6.字典遍历7.字典的高级特性默认字典

使用Python构建一个高效的日志处理系统

《使用Python构建一个高效的日志处理系统》这篇文章主要为大家详细讲解了如何使用Python开发一个专业的日志分析工具,能够自动化处理、分析和可视化各类日志文件,大幅提升运维效率,需要的可以了解下... 目录环境准备工具功能概述完整代码实现代码深度解析1. 类设计与初始化2. 日志解析核心逻辑3. 文件处

一文详解如何使用Java获取PDF页面信息

《一文详解如何使用Java获取PDF页面信息》了解PDF页面属性是我们在处理文档、内容提取、打印设置或页面重组等任务时不可或缺的一环,下面我们就来看看如何使用Java语言获取这些信息吧... 目录引言一、安装和引入PDF处理库引入依赖二、获取 PDF 页数三、获取页面尺寸(宽高)四、获取页面旋转角度五、判断

Spring Boot中的路径变量示例详解

《SpringBoot中的路径变量示例详解》SpringBoot中PathVariable通过@PathVariable注解实现URL参数与方法参数绑定,支持多参数接收、类型转换、可选参数、默认值及... 目录一. 基本用法与参数映射1.路径定义2.参数绑定&nhttp://www.chinasem.cnbs

C++中全局变量和局部变量的区别

《C++中全局变量和局部变量的区别》本文主要介绍了C++中全局变量和局部变量的区别,全局变量和局部变量在作用域和生命周期上有显著的区别,下面就来介绍一下,感兴趣的可以了解一下... 目录一、全局变量定义生命周期存储位置代码示例输出二、局部变量定义生命周期存储位置代码示例输出三、全局变量和局部变量的区别作用域