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。

相关文章

SpringBoot中@Value注入静态变量方式

SpringBoot中@Value注入静态变量方式

《SpringBoot中@Value注入静态变量方式》SpringBoot中静态变量无法直接用@Value注入,需通过setter方法,@Value(${})从属性文件获取值,@Value(#{})用... 目录项目场景解决方案注解说明1、@Value("${}")使用示例2、@Value("#{}"php
阅读更多...
C++右移运算符的一个小坑及解决

C++右移运算符的一个小坑及解决

《C++右移运算符的一个小坑及解决》文章指出右移运算符处理负数时左侧补1导致死循环,与除法行为不同,强调需注意补码机制以正确统计二进制1的个数... 目录我遇到了这么一个www.chinasem.cn函数由此可以看到也很好理解总结我遇到了这么一个函数template<typename T>unsigned
阅读更多...
Python使用FastAPI实现大文件分片上传与断点续传功能

Python使用FastAPI实现大文件分片上传与断点续传功能

《Python使用FastAPI实现大文件分片上传与断点续传功能》大文件直传常遇到超时、网络抖动失败、失败后只能重传的问题,分片上传+断点续传可以把大文件拆成若干小块逐个上传,并在中断后从已完成分片继... 目录一、接口设计二、服务端实现（FastAPI）2.1 运行环境2.2 目录结构建议2.3 serv
阅读更多...
Spring Security简介、使用与最佳实践

Spring Security简介、使用与最佳实践

《SpringSecurity简介、使用与最佳实践》SpringSecurity是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架,本文给大家介绍SpringSec... 目录一、如何理解 Spring Security？—— 核心思想二、如何在 Java 项目中使用？——
阅读更多...
springboot中使用okhttp3的小结

springboot中使用okhttp3的小结

《springboot中使用okhttp3的小结》OkHttp3是一个JavaHTTP客户端,可以处理各种请求类型,比如GET、POST、PUT等,并且支持高效的HTTP连接池、请求和响应缓存、以及异... 在 Spring Boot 项目中使用 OkHttp3 进行 HTTP 请求是一个高效且流行的方式。
阅读更多...
Java使用Javassist动态生成HelloWorld类

Java使用Javassist动态生成HelloWorld类

《Java使用Javassist动态生成HelloWorld类》Javassist是一个非常强大的字节码操作和定义库,它允许开发者在运行时创建新的类或者修改现有的类,本文将简单介绍如何使用Javass... 目录1. Javassist简介2. 环境准备3. 动态生成HelloWorld类3.1 创建CtC
阅读更多...
使用Python批量将.ncm格式的音频文件转换为.mp3格式的实战详解

使用Python批量将.ncm格式的音频文件转换为.mp3格式的实战详解

《使用Python批量将.ncm格式的音频文件转换为.mp3格式的实战详解》本文详细介绍了如何使用Python通过ncmdump工具批量将.ncm音频转换为.mp3的步骤,包括安装、配置ffmpeg环... 目录1. 前言2. 安装 ncmdump3. 实现 .ncm 转 .mp34. 执行过程5. 执行结
阅读更多...
Java使用jar命令配置服务器端口的完整指南

Java使用jar命令配置服务器端口的完整指南

《Java使用jar命令配置服务器端口的完整指南》本文将详细介绍如何使用java-jar命令启动应用,并重点讲解如何配置服务器端口,同时提供一个实用的Web工具来简化这一过程,希望对大家有所帮助... 目录1. Java Jar文件简介1.1 什么是Jar文件1.2 创建可执行Jar文件2. 使用java
阅读更多...
C++统计函数执行时间的最佳实践

C++统计函数执行时间的最佳实践

《C++统计函数执行时间的最佳实践》在软件开发过程中,性能分析是优化程序的重要环节,了解函数的执行时间分布对于识别性能瓶颈至关重要,本文将分享一个C++函数执行时间统计工具,希望对大家有所帮助... 目录前言工具特性核心设计1. 数据结构设计2. 单例模式管理器3. RAII自动计时使用方法基本用法高级用法
阅读更多...
C#使用Spire.Doc for .NET实现HTML转Word的高效方案

C#使用Spire.Doc for .NET实现HTML转Word的高效方案

《C#使用Spire.Docfor.NET实现HTML转Word的高效方案》在Web开发中,HTML内容的生成与处理是高频需求,然而,当用户需要将HTML页面或动态生成的HTML字符串转换为Wor... 目录引言一、html转Word的典型场景与挑战二、用 Spire.Doc 实现 HTML 转 Word1
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2