C++对象模型和this指针介绍

已于 2023-05-02 00:01:21 修改
阅读量174 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-05-01 23:49:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_72724431/article/details/130452860
版权

一、成员变量和成员函数分开存储        

在C++中，类内的成员变量和成员函数分开存储。C++编译器会给每个空对象也分配一个字节的空间，是为了区分空对象占内存的位置，每个空对象都有一个独一无二的内存地址。只有非静态成员变量才属于类的对象上

示例：空对象占用的内存空间为1

#include<iostream>
using namespace std;

//成员变量和成员函数是分开存储的

class Person
{

};
void test01()
{
	Person p;  //创建对象p

	//统计对象p占多大空间
	//空对象占用的内存空间为	1
	//C++编译器会给每个空对象也分配一个字节的空间，是为了区分空对象占内存的位置，每个空对象都有一个独一无二的内存地址
	cout << "size of p = " << sizeof(p) << endl;
}
int main()
{
	test01();

	return 0;
}

运行结果：空对象占用的内存空间为1，原因是C++编译器会给每个空对象也分配一个字节的空间，是为了区分空对象占内存的位置

示例：非静态成员变量所占空间 

#include<iostream>
using namespace std;

//成员变量和成员函数是分开存储的

class Person
{
	//编译器按照int来分配内存，分配4个字节
	int m_A;//没有加static, 是非静态成员变量，属于类的对象上的
};
void test02()
{
	Person p;
	cout << "size of p = " << sizeof(p) << endl;
}
int main()
{
	test02();

	return 0;
}

运行结果： 非静态成员变量所占空间是4

示例：在上例基础上加入静态成员变量 

#include<iostream>
using namespace std;

//成员变量和成员函数是分开存储的

class Person
{
	//编译器按照int来分配内存，分配4个字节
	int m_A;//没有加static, 是非静态成员变量，属于类的对象上的
	static int m_B;//静态成员变量，类内声明，类外初始化，不属于类对象上 
};
int Person::m_B = 0;
void test02()
{
	Person p;
	cout << "size of p = " << sizeof(p) << endl;
}
int main()
{
	test02();

	return 0;
}

运行结果：还是4个字节，是因为静态成员变量不属于某一个类的对象里面 

 示例：在上例基础上加入非静态成员函数：

#include<iostream>
using namespace std;

//成员变量和成员函数是分开存储的

class Person
{
	//编译器按照int来分配内存，分配4个字节
	int m_A;//没有加static, 是非静态成员变量，属于类的对象上的
	static int m_B;//静态成员变量，类内声明，类外初始化，不属于类的对象上
	void func() //非静态成员函数， 不属于类的对象上
	{

	}
};
int Person::m_B = 0;
void test02()
{
	Person p;
	cout << "size of p = " << sizeof(p) << endl;
}
int main()
{
	test02();

	return 0;
}

运行结果：加入非静态成员函数后，还是4个字节 

示例：在上例基础上加入静态成员函数

#include<iostream>
using namespace std;

//成员变量和成员函数是分开存储的

class Person
{
	//编译器按照int来分配内存，分配4个字节
	int m_A;//没有加static, 是非静态成员变量，属于类的对象上的
	static int m_B;//静态成员变量，类内声明，类外初始化
	void func() //非静态成员函数
	{

	}
	static void func2()  //静态成员函数，不属于类的对象上
	{

	}
};
int Person::m_B = 0;
void test02()
{
	Person p;
	cout << "size of p = " << sizeof(p) << endl;
}
int main()
{
	test02();

	return 0;
}

运行结果：还是4个字节，是因为静态成员函数也不属于某一个类的对象里面  

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

二、this指针概念

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会公用同一份代码，那么问题是：这一块代码是如何区分哪个对象调用自己的呢？

C++通过提供特殊的对象指针，this指针解决上述问题。

this指针指向被调用的成员函数所属的对象。

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

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

this指针的用途 

1、当形参和成员变量同名时，可用this指针来区分

2、在类的非静态成员函数中返回对象本身，可使用return *this

示例：成员属性和传入形参的名称相同且没有使用this指针

#include<iostream>
using namespace std;

class Person
{
public:
	Person(int age)
	{
		age = age;
	}
	int age; 
};
//1 解决名称冲突
void test01()
{
	Person p1(18);
	cout << "p1的年龄为：" << p1.age << endl;

}
//2 返回对象本身用*this

int main()
{
	test01();

	return 0;
}

此时发现阴影部分没有区分，相同阴影的age是一样的

运行结果：结果并不是18 ，是因为编译器认为三个age都是同一份，跟属性age不是一回事，所以并没有将属性age进行赋值操作

示例：成员属性和传入形参的名称相同且使用this指针  

#include<iostream>
using namespace std;

class Person
{
public:
	Person(int age)
	{
        //this指针指向被调用的成员函数所属的对象。
		this-> age = age;
	}
	int age; 
};
//1 解决名称冲突
void test01()
{
	Person p1(18);
	cout << "p1的年龄为：" << p1.age << endl;

}
//2 返回对象本身用*this

int main()
{
	test01();

	return 0;
}

 此时发现阴影部分有区分

 运行结果：this指针指向被调用的成员函数所属的对象，p1在调用成员函数，所以this指向p1,谁调用Person(int age)，this就指向谁。所以正常输出18。

 示例：返回对象本身用*this

#include<iostream>
using namespace std;

class Person
{
public:
	Person(int age)
	{
		this -> age = age;
	}

	//加入引用&每次返回一次就是返回p2
	Person& PersonAddAge(Person& p)  //若不加引用&，就是以值的方式进行返回，每返回一次就创建一个新的对象
	{
		this->age += p.age;   //目的为了p1与p2的年龄相加
		//this指向p2的指针，而*this指向的就是p2这个对象本体
		return *this; //返回p2的本体要用引用的方式返回
	}
	int age; 

};
//1 解决名称冲突
//2 返回对象本身用*this
void test02()
{
	Person p1(10);

	Person p2(10);

	//链式编程思想，类似于cout<<""<<""<<""<<.....
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);  //想多加几次十岁

	cout << "p2的年龄为：" <<p2.age<< endl;
}
int main()
{
	test02();

	return 0;
}

运行结果：实现了多次相加 

三、空指针访问成员函数

 C++中空指针也是可以调用成员函数的，但也要注意有没有用到this指针

如果用到this指针，需要加以判断保证代码的健壮性

示例：空指针调用成员函数没用this指针

#include<iostream>
using namespace std;

//空指针调用成员函数

class Person
{
public:

	void showClassName()
	{
		cout << "this is Person class" << endl;
	}
	void showPersonAge()
	{
		cout << "age = " << m_Age << endl;
	}
	int m_Age;
};
void test01()  
{
	Person* p = NULL;  //Person*类型的指针指向NULL

	p->showClassName();  //空指针调用成员函数showClassName()

	p->showPersonAge();  //空指针调用成员函数showPersonAge()
}
int main()
{
	test01();

	return 0;
}

 运行结果：程序崩了

 而且是因为这一行代码让程序崩溃

原因：这里默认是this->m_Age,但Person*类型是指向空指针，所以this没有指向确切的数据，所以发生错误

示例： 加以判断保证代码的健壮性

#include<iostream>
using namespace std;

//空指针调用成员函数

class Person
{
public:

	void showClassName()
	{
		cout << "this is Person class" << endl;
	}
	void showPersonAge()
	{

		//修改方式：加入判断提高代码的健壮性
		if (this == NULL)
		{
			return;
		}

		//这里默认是this->m_Age,但Person*类型是指向空指针，所以this没有指向确切的数据，所以发生错误
		//报错原因是因为传入的指针是NULL
		cout << "age = " << this->m_Age << endl;
	}
	int m_Age;
};
void test01()  
{
	Person* p = NULL;  //Person*类型的指针指向NULL

	p->showClassName();  //空指针调用成员函数showClassName()

	p->showPersonAge();  //空指针调用成员函数showPersonAge()
}
int main()
{
	test01();

	return 0;
}

 运行结果：正常调用

四、const修饰成员函数  

常函数：

常：有些数据限定了只读状态 

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

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

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

常对象： 

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

常对象只能调用常函数

 示例：可以修改情况

class Person
{
public:

	void showPerson()
	{
		m_A = 100;   //可以修改
	}

	int m_A;
};

示例：不可以修改情况

分析：每一个成员函数内部都有一个this指针

this指针的本质 是指针常量 指针常量的指向是不可以修改的

this指针是不可以修改指针的指向的，this类似于Person * const this;

示例：常函数 

#include<iostream>
using namespace std;

class Person
{
public:
	//this指针的本质 是指针常量 指针常量的指向是不可以修改的
	//const Person * const this;
	//在成员函数后面加const, 本质修饰的是this指向, 让指针指向的值也不可以修改
	void showPerson() const
	{
		this->m_B = 100;  //加入mutable后即使在常函数中变量也可以修改
		//this->m_A = 100;   //不可以修改
		//this = NULL;  //this指针是不可以修改指针的指向的
	}

	int m_A;
	mutable int m_B;  //特殊变量，即使在常函数中，也可以修改这个值, 加上关键字mutable
};
void test01()
{
	Person p;
	p.showPerson();//当p对象去调用showPerson()时候，this指向的是p,不能指向别的地了
}
int main()
{

	return 0;
}

 示例：常对象

在对象前加const变为常对象，常对象不允许修改指针指向的值

#include<iostream>
using namespace std;

class Person
{
public:
	//this指针的本质 是指针常量 指针常量的指向是不可以修改的
	//const Person * const this;
	//在成员函数后面加const, 本质修饰的是this指向, 让指针指向的值也不可以修改
	void showPerson() const
	{
		this->m_B = 100;  //加入mutable后即使在常函数中变量也可以修改
		//this->m_A = 100;   //不可以修改
		//this = NULL;  //this指针是不可以修改指针的指向的
	}
	void func()
	{
		m_A = 100;   //可以修改非常变量的值（属性）
	}
	int m_A;
	mutable int m_B;  //特殊变量，即使在常函数中，也可以修改这个值, 加上关键字mutable
};
void test01()
{
	Person p;
	p.showPerson();//当p对象去调用showPerson()时候，this指向的是p,不能指向别的地了
}
//常对象
void test02()
{
	const Person p;  //在对象前加const变为常对象
	//p.m_A = 100;
	p.m_B = 100;  //m_B是特殊值，在常对象下也可以修改

	//常对象只能调用常函数
	p.showPerson();

	//常对象不可以调用普通的成员函数，因为普通成员函数可以修改属性
	//p.func();  //调用普通函数，若可以修改则侧面修改了非常变量的值（属性），所以编译器是不给修改的 
}
int main()
{
	
	return 0;
}

常对象不可以调用普通的成员函数，因为普通成员函数可以修改属性，所以常对象只能调用常函数 

&鉴心
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++11 笔记】关键字剖析 —— this
闻韶
01-22 1018
C++ 关键字：this
c++类和对象---c++对象模型和this指针
m0_50046535的博客
04-14 410
1、成员变量和成员函数分开储存 在c++中，类内成员变量和成员函数分开储存，只有非静态成员变量才属于类的对象上 class person { public: int m_A;//非静态成员变量，属于类的对象，占用四个字节内存 static int m_B;//静态成员变量，不属于类的对象上 void func(){}//非静态成员函数，不属于类的对象上 static void func1() {}//静态成员函数，不属于类的对象上 private: }; int person::m_B
C++之this
qq_44559016的博客
05-18 324
C++之this
c++基础知识：this指针
qq_48335434的博客
05-22 2764
this指针简介
c++this指针 返回对象本身
qq_53079283的博客
05-09 537
为了在成员函数中能够方便地引用该对象自身的成员变量或方法，C++提供了一个指向当前对象的指针，即this指针。this指针指向的是当前对象的地址，因此可以通过this指针访问当前对象的成员变量或方法。在上述代码中，类Student中的setName和setAge方法都返回了*this指针，即当前对象的指针，以便可以链式调用这两个方法，并且可以在链式调用中方便地操作对象的多个属性。在C++中，如果在成员函数中需要返回当前对象自身，可以使用this指针返回本身，即返回当前对象的指针。
【C++】this 指针的概念
深入挖掘，筑基为先；知其然，知其所以然。
05-30 1843
我们知道在 C++中成员变量和成员函数是分开存储的，每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码。那么，问题来了？这一块代码是如何区分哪个对象调用自己的呢？
C++学习之面向对象模型this指针
huhuhuhl的博客
09-16 127
引入 C++对象模型可分为： 语言中直接支持面向对象程序设计的部分，主要涉及如：构造函数、析构函数、虚函数、继承（单继承、多继承、虚继承）、多态等等。 对于各种支持的底层实现机制：在c语言中，“数据”和“处理数据的操作（函数）”是分开来声明的，也就是说，语言本身并没有支持“数据和函数”之间的关联性。在c++中，通过抽象数据类型（abstract data type，ADT），在类中定义数据和函...
每天学点C++（C++实例教程：教程+源码）模型对象和this指针.zip
06-21
在C++编程语言中，模型对象和`this`指针是两个非常重要的概念，它们对于理解和编写复杂的面向对象程序至关重要。...提供的“C++模型对象和this指针”实例教程和源码正是这样的学习资源，值得仔细研究和学习。
C++对象模型
08-13
《C++对象模型》 ...总结来说，C++对象模型是理解和使用C++进行面向对象编程的基础。理解对象的创建、存储、调用机制以及与之相关的构造、析构、拷贝、多态性等概念，能帮助开发者编写更高效、更健壮的C++代码。
两种面向对象的C++线程模型.rar_C++面向对象_面向对象
09-21
本文将深入探讨两种主要的面向对象的C++线程模型：标准库中的`std::thread`和Boost库的`boost::thread`。 首先，让我们了解C++11引入的标准库`<thread>`。这个库提供了一个`std::thread`类，用于创建和管理线程。...
C++ 多重继承和虚拟继承对象模型、效率分析
09-04
C++的多重继承和虚拟继承是面向对象编程中两种高级特性，它们允许类从多个基类继承特性，但同时也引入了复杂性和效率问题。...理解这些概念及其在对象模型和效率上的影响是编写高效、可维护的C++代码的关键。
C++初阶+类和对象（上）.pdf
01-17
本节课将介绍C++中的类和对象的概念，包括面向过程和面向对象的初步认识、类的引入、类的定义、类的访问限定符及封装、类的作用域、类的实例化、类对象模型、this指针等内容。 1. 面向过程和面向对象初步认识 ...
Self Summary: C++函数返回引用和指针的问题，局部对象与new对象的问题
Steven Li's Zone
07-27 4744
C++的局部对象的概念： 作用域在局部范围内（例如函数）的对象。这样的对象可以把对象的引用或者指针存在栈中，随着函数的结束而销毁，而把创建的对象内容存在堆中。如果需要在堆上创建对象，要么使用new运算符，要么使用malloc系列函数。 而关键是理解好“自动存储”的概念[1]： Object obj; 此时，obj是在栈上分配的吗？ 要回答这个问题，我们首先要理解这个语
C++基础系列(一) 对象指针
u012514113的专栏
10-19 574
在程序中定义了一个函数，那么在编译时系统就会为这个函数代码分配一段存储空间，这段存储空间的首地址称为这个函数的地址，而且函数名表示的就是这个地址。其返回值是一个 int 类型的指针，是一个地址。没有括号，*与int结合，int*为返回类型，p就是一个函数名，这时就是一个指针函数，只不过返回值类型为int*。有括号，*与p结合，*p就是个指针，指向返回值为整型且有两个整型参数的函数的指针，因此称为函数指针。可以简单粗暴的理解为，指针函数的*是属于数据类型的，而函数指针的星号是属于函数名的。
c++怎么返回对象
songjian1104的专栏
11-30 2357
返回对象，无非两种方式，返回栈对象和堆对象指针，栈对象指针不能返回，因为可能使用不该使用的内存，堆对象也不能直接返回，因为会产生内存泄漏。下面，我们分析两种返回方式的优缺点，及针对缺点的解决方案。 返回栈对象： 优点：不用手动释放内存，避免了内存泄漏； 缺点：会产生对象拷贝，如果对象比较大，比如，对象里面有大数组，会产生性能开销。 返回堆对象指针： 优点：不会产生对象拷贝，对性能友好； 缺点：函数调用之后手动释放对象，代码管理难度和内存泄漏风险提高。 那有没有办...
C++之函数返回指针类型
YANJINING
07-17 1161
C++之函数返回指针类型 #include <iostream> #include <cstdlib> #include <ctime> #include <malloc.h> using namespace std; template<class T> int get_array_length(T &arr); int *get_random(); int main() { system("chcp 65001");
C++方法返回值--类对象/类指针
quietbxj的博客
05-07 1456
返回为对象，会自动调用拷贝构造函数，效率较低； 返回对象指针，效率高；但不释放会造成内存泄漏（使用智能指针来解决）。
c++（16）this指针详解
tr_ainiyangyang的博客
07-06 7244
在c++类的静态成员变量和静态成员函数中，多次涉及到了this指针。下面注重介绍一下前面讲static成员变量占用的时候提到，如果sizeof类的大小，是不会计算static成员变量的，同样的也不会计算成员函数，换句话说，其实成员函数是在类外的。那么当我们创建完对象，使用对象的成员函数，它是怎么知道我们访问的是哪个对象的成员变量的？我们知道编译器在编译一个普通成员函数时，会隐式地增加一个形参 this，并把当前对象的地址赋值给 this，所以普通成员函数能在创建对象后通过对象来调用并访问该对象的成员变量。
函数模板与类模板
最新发布
程序员_小兵
07-12 1545
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值