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

目录

C++对象模型

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

总结

this指针

概念

示例

用途

当形参和成员变量同名时

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

例子

空指针访问成员函数

示例

const修饰成员函数

常函数(const member function)

常对象(const object)

关键字mutable


C++对象模型

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

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

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

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

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

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

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

  5. 虚函数表(Vtable):如果类中存在虚函数,编译器会生成一个虚函数表。虚函数表是一个指针数组,存储了虚函数的地址。每个对象中存在一个指向其对应类虚函数表的指针(虚函数指针)。

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

需要注意的是,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;
}