Day 15 C++对象模型和this指针

最新推荐文章于 2024-10-08 09:44:01 发布

缺点灵气儿

最新推荐文章于 2024-10-08 09:44:01 发布

阅读量157

点赞数 1

分类专栏： C ++ 文章标签： c++

本文链接：https://blog.csdn.net/m0_74921567/article/details/132015628

版权

C ++ 专栏收录该内容

36 篇文章 1 订阅

订阅专栏

C++对象模型描述了类的成员变量和成员函数在内存中的布局。成员变量按顺序存储，每个对象有自己的拷贝，而成员函数不存储在对象中，通过this指针访问。this指针在非静态成员函数中指向当前对象，用于访问成员。常函数承诺不修改对象状态，常对象则限制修改成员变量。了解这些概念有助于理解C++的底层工作原理。

摘要由CSDN通过智能技术生成

常函数（const member function）

常对象（const object）

关键字mutable

C++对象模型

是指描述C++中对象在内存中的布局和组织方式的规范。它涉及到类的成员变量、成员函数以及继承关系等方面。

在C++对象模型中，一个类的对象通常由两部分组成：成员变量和成员函数。

C++对象模型描述了在C++中对象的内存布局和组织方式。以下是一些关键概念：

成员变量的布局：成员变量按照声明的顺序在内存中排列。对于非静态成员变量，每个对象都有其自己的独立拷贝。对于静态成员变量，所有对象共享同一份拷贝。

成员函数的存储：成员函数通常不直接存储在对象中，而是存储在类的代码段中。每个成员函数只有一份实现，在内存中共享。当调用成员函数时，通过this指针来访问当前对象的成员。

this指针：this指针是一个隐含的指向当前对象的指针。它允许在成员函数内部通过this->来访问当前对象的成员变量和成员函数。

继承关系的布局：当一个类继承自另一个类时，子类对象的内存布局包含了基类部分和派生类自身的部分。基类的成员变量按照声明顺序排列在子类对象的前部分。

虚函数表（Vtable）：如果类中存在虚函数，编译器会生成一个虚函数表。虚函数表是一个指针数组，存储了虚函数的地址。每个对象中存在一个指向其对应类虚函数表的指针（虚函数指针）。

多重继承：当一个类从多个基类派生时，对象内存布局会根据继承顺序依次包含各个基类的部分。

需要注意的是，C++对象模型的具体实现因编译器而异。不同的编译器可能存在一些细微差异，但大体上遵循了C++标准对于对象模型的规定。了解对象模型对于理解C++的底层运作机制和进行性能优化非常有帮助。

类内的成员变量和成员函数分开存储

成员变量在内存中按照定义的顺序排列，每个成员变量在内存中占据一定的空间。其中，基本数据类型的成员变量直接存储其值，而对象类型的成员变量存储的是对象的地址。

成员函数则不直接存储在对象内存中，而是存储在类的代码段中。每个成员函数只有一份，被所有对象共享。当调用成员函数时，通过this指针来访问当前对象的成员变量和调用其他成员函数。

总结

非静态成员变量占对象空间

静态成员变量不占对象空间

只有非静态成员变量才属于类的对象上

函数（包括静态成员函数）也不占对象空间，所有函数共享一个函数实例

this指针

概念

this指针是C++中的一个隐含指针，它指向当前对象。它可以在类的非静态成员函数中使用，用于访问当前对象的成员变量和成员函数。

具体来说，当我们在类的成员函数内部使用成员变量或调用其他成员函数时，编译器会将这些代码转换为使用this指针来访问。this指针是一个指向当前对象的常量指针，它的类型是当前类的指针类型。

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码

通过this指针可以区分那个对象调用这一块代码。

this指针是隐含于每一个非静态成员函数内的一种指针

this指针不需要定义，直接使用即可

对象指针访问属性要用 -> , 例如this->x = value（等价于(*this).x = value）

示例

class MyClass {
public:
  int x;
  
  void setX(int value) {
    this->x = value;  // 使用this指针访问成员变量
  }
  
  void printX() {
    std::cout << "x = " << this->x << std::endl;  // 使用this指针访问成员变量
  }
  
  void callAnotherFunction() {
    this->printX();  // 使用this指针调用其他成员函数
  }
};

在上面的示例中，setX()函数和printX()函数中使用了this指针来访问成员变量x。在setX()函数中，this->x = value（等价于(*this).x = value）将传入的value赋值给当前对象的成员变量x。在printX()函数中，使用this->x将当前对象的成员变量x输出到标准输出。

另外，callAnotherFunction()函数中使用this指针调用printX()函数。this->printX()等价于(*this).printX()，它调用了当前对象的printX()成员函数。

用途

当形参和成员变量同名时

在非静态成员函数中，可以使用this指针来区分它们。this->age = age表示将传入的参数值赋给当前对象的成员变量age。通过使用this指针，我们明确指出要操作的是成员变量而不是形参。

在非静态成员函数中，如果希望返回对象本身

可以使用return *this语句。这样可以实现链式调用，即在一个对象上连续调用多个成员函数。

例子

class MyClass {
public:
  int x;
  
  MyClass& setX(int value) {  // 返回对象本身的引用
    this->x = value;
    return *this;
  }
  
  void printX() {
    std::cout << "x = " << this->x << std::endl;
  }
};

int main() {
  MyClass obj;
  obj.setX(5).printX();  // 链式调用
  return 0;
}

空指针访问成员函数

在C++中，空指针也可以调用成员函数，但是需要注意使用到this指针时的判断，以确保代码的健壮性和安全性。

当空指针调用成员函数时，由于没有有效的对象实例，this指针将为nullptr。如果在成员函数中没有使用this指针访问成员变量或调用其他成员函数，则可以安全地使用空指针调用。

当成员函数中使用了this指针时，就需要进行合适的判断来避免空指针解引用错误。

示例

#include <iostream>

class MyClass {
public:
  void memberFunction() {
    std::cout << "Inside memberFunction" << std::endl;
  }
};

int main() {
  MyClass* ptr = nullptr;

  // 空指针调用成员函数
  ptr->memberFunction();

  return 0;
}

在上述代码中，我们声明了一个名为MyClass的类，其中有一个成员函数memberFunction()。在主函数中，将一个空指针ptr初始化为nullptr。然后，我们尝试使用空指针ptr来调用成员函数memberFunction()。尽管ptr是空指针，但由于memberFunction()函数内部没有使用this指针访问成员变量或调用其他成员函数，因此可以安全地运行该程序。输出结果为"Inside memberFunction"。

请注意，在实际应用中，应该始终确保指针是有效的，以避免潜在的错误和崩溃。

const修饰成员函数

常函数（const member function）

常函数是指在成员函数的声明和定义的末尾加上const关键字。常函数承诺不会修改类的任何非静态成员变量。这意味着在常函数内部，不能对非静态成员变量进行赋值操作或调用可能修改成员状态的非const函数。

class MyClass {
public:
  void someFunction() const {
    // 在常函数中只能访问类的成员变量，不能修改它们
  }
};

成员函数后加const后我们称为这个函数为常函数

常函数内不可以修改成员属性

成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象（const object）

常对象是指在对象声明之前加上const关键字，从而将其声明为常对象。常对象的特点是其成员变量的值在创建后不能被修改，并且只能调用常函数。

const MyClass obj;

声明对象前加const称该对象为常对象

常对象只能调用常函数

关键字`mutable`

即使在常函数中，普通的成员变量依然无法修改，包括在常对象中。但是，如果某个成员变量声明时使用了关键字mutable，则可以在常函数中修改该成员变量的值。mutable关键字的作用是允许常函数改变被修饰的成员变量。

综上所述，常函数和常对象的使用可以提高代码的安全性和可读性。

常函数用于声明不会修改类状态的函数

而常对象用于保护成员变量的不可修改性，并限制只能调用常函数。

class Person {
public:
	Person() {
		m_A = 0;
		m_B = 0;
	}

	//this指针的本质是一个指针常量，指针的指向不可修改
	//如果想让指针指向的值也不可以修改，需要声明常函数
	void ShowPerson() const {
		//const Type* const pointer;
		//this = NULL; //不能修改指针的指向 Person* const this;
		//this->mA = 100; //但是this指针指向的对象的数据是可以修改的

		//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
		this->m_B = 100;
	}

	void MyFunc() const {
		//mA = 10000;
	}

public:
	int m_A;
	mutable int m_B; //可修改 可变的
};


//const修饰对象  常对象
void test01() {

	const Person person; //常量对象  
	cout << person.m_A << endl;
	//person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
	person.m_B = 100; //但是常对象可以修改mutable修饰成员变量

	//常对象访问成员函数
	person.MyFunc(); //常对象只能调用const的函数

}

int main() {

	test01();

	system("pause");

	return 0;
}