2021-11-08 C++封装继承多态---C++对象模型和this指针、友元、运算符重载（附代码理解）

最新推荐文章于 2023-06-06 12:37:31 发布
最新推荐文章于 2023-06-06 12:37:31 发布
阅读量731 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011514176/article/details/121189854
版权

3. C++对象模型和this指针

3.1 成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储，只有非静态成员变量才属于类的对象上。

#include<iostream>
using namespace std;
class person
{
	int m_a; //非静态成员变量  属于类的对象上的
	static int m_b;//静态成员变量    不属于类的对象上的
	void func() {} //非静态成员变量    不属于类的对象上的
	static void func2() {} 
};
int person::m_b = 10;
void test01()
{
	person p;
	//空对象占用的内存空间为：？？？  1个字节
	//c++ 编译器会给每个空对象也分配一个字节空间，为了区分对象占内存的位置
	//每个空对象也应该有一个独一无二的内存
	cout << "size of p=="<<sizeof(p) << endl;
}
void test02()
{
	person p;
	cout << "size of p==" << sizeof(p) << endl;
}
int main() {
	test02();
	
	system("pause");
	return 0;
}

3.2 this指针概念

我们知道在C++中成员变量和成员函数是分开存储的
每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码那么问题是:这—块代码是如何区分那个对象调用自己的呢?
C++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象
this指针是隐含每一个非静态成员函数内的—种指针
this指针不需要定义，直接使用即可
this指针的用途:·当形参和成员变量同名时，可用this指针来区分 ·在类的非静态成员函数中返回对象本身，可使用return *this

#include<iostream>
using namespace std;
//1 解决名称冲突

//2 返回对象本身用 return *this
class person
{
public:
	person(int age)
	{
		//this 指针指向的是 被调用的成员函数 所属于的对象
		this->age = age;
	}
	person &personaddage(person& p)
	{
		this->age += age;
		//this 指向p2的指针， *this 指向的就是p2的对象的本体
		return *this;
	}
	int age;
};
//1 解决名称冲突
void test01()
{
	person p1(18);
	cout << "p1的年龄" <<p1.age<< endl;
}
//2 返回对象本身用 return *this
void test02()
{
	person p1(18);
	person p2(18);
	//链式编程思想  &personaddage 为了套猴
	p2.personaddage(p1).personaddage(p1).personaddage(p1);
	cout << "p2的年龄" << p2.age << endl;
}
int main() {
	//test01();
	test02();
	
	system("pause");
	return 0;
}

3.3 空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针
如果用到this指针，需要加以判断保证代码的健壮性

#include<iostream>
using namespace std;
//
class person
{
public:
	void showclassname()
	{
		cout << "this is person class" << endl;
	}
	void showpersonage()
	{
		//报错原因是因为传入的指针为空指针
		if (this == NULL)  //加上这个就可以了
		{
			return;
		}
		cout<<"age=" <<m_age<< endl;
	}
	int m_age;
};
void test01()
{
	person* p =NULL;
	p->showclassname();
	p->showpersonage();
}

int main() {
	test01();
	
	system("pause");
	return 0;
}

3.4 const修饰成员函数

常函数常对象
成员函数后加const后我们称为这个函数为常函数声明对象前加const称该对象为常对象
常函数内不可以修改成员属性常对象只能调用常函数
成员属性声明时加关键字mutable后，在常函数中依然可以修改
#include<iostream>
using namespace std;
//
class person
{
public:
	//常函数
	// this 指针本质为指针常量，指向不可以修改
	// const person * const this ; == this指针
	// 在成员函数后面加上const之后，修饰的是this的指向，让指针指向的值也不可以修改
	void showperson() const
	{
		//this 指针是  隐含在每一个非静态成员函数中的 一种指针
		//this->m_a = 100;
		//this = NULL;  //this 指针是不可以修改指针的指向的
		this->m_b = 100;
	}
	int m_a;
	mutable int m_b; //特殊变量，即使在常函数中，也可以修改这个值。加上关键字mutable
};

void test01()
{
	person p;
	p.showperson();
	cout << "good baby" << endl;
}
//常对象
void test02()
{
	const person p2; //在对象前加const，变成了常对象
	//p2.m_a = 100;
	p2.m_b = 100; // m_b是特殊值，在常对象里面也可以修改的
	//常对象只可以调用常函数
}
int main() {
	test01();
	system("pause");
	return 0;
}

4.友元

生活中你的家有客厅(Public)，有你的卧室(Private)
客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去但是呢，你也可以允许你的好闺蜜好基友进去。
在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术
友元的目的就是让一个函数或者类访问另—个类中私有成员
友元的关键字为friend
友元的三种实现: .全局函数做友元 ·类做友元 ·成员函数做友元

4.1全局函数做友元

#include<iostream>
using namespace std;
//建筑物的类
class building
{
	//goodgay 是building好朋友  可以访问私有成员
	friend void goodgay(building* building);
public:
	building()
	{
		m_sittingroom = "客厅";
		m_bedroom = "卧室";
	}
public:
	string m_sittingroom; //客厅
private:
	string m_bedroom; //卧室
};
//全局函数
void goodgay(building *b)
{
	cout <<"好基友全局函数 正在访问" <<b->m_sittingroom <<endl;
	cout << "好基友全局函数 正在访问" << b->m_bedroom << endl;  //私有怎么访问
}

void test01()
{
	building b2;
	goodgay(&b2);
}
int main() {
	test01();
	system("pause");
	return 0;
}

4.2类做友元

#include<iostream>
using namespace std;
//建筑物的类
class Building;
class goodgay
{
public:
	goodgay();
	void visit(); //参观函数 访问building中的属性
	Building * building;
private:
};

class Building
{
	friend class goodgay;  // goodgay类是本类的好朋友，可以访问私有成员
public:
	Building();  //初始化
public:
	string m_sittingroom;
private:
	string m_bedroom;
};

//类外写成员函数
Building::Building()
{
	m_sittingroom = "客厅";
	m_bedroom = "卧室";
}
goodgay::goodgay()
{
	//创建建筑物的对象
	building = new Building;
}

void goodgay::visit()
{
	cout<<"好基友正在访问：" <<building->m_sittingroom << endl;
	cout << "好基友正在访问：" << building->m_bedroom << endl;
}
void test01()
{
	goodgay gg;
	gg.visit();
}
int main() {
	test01();
	system("pause");
	return 0;
}

4.3成员函数做友元

#include<iostream>
using namespace std;
//
class Building;
class goodgay
{
public:
	goodgay();
	void visit(); //参观函数 访问building中的私有的成员
	void visit2(); //参观函数 不访问building中的私有的成员
	Building* building;
};
class Building
{
	//告诉编译器 goodgay类下的visit成员函数作为本类的好朋友，可以访问私有成员
	friend void goodgay::visit();
public:
	Building();
public:
	string m_sittingroom;
private:
	string m_bedroom;
};

//类外写成员函数
Building::Building()
{
	m_sittingroom = "客厅";
	m_bedroom = "卧室";
}
goodgay::goodgay()
{
	//创建建筑物的对象
	building = new Building;
}

void goodgay::visit()
{
	cout << "visit函数正在访问：" << building->m_sittingroom << endl;
	cout << "visit函数正在访问：" << building->m_bedroom << endl;
}
void goodgay::visit2()
{
	cout << "visit2函数正在访问：" << building->m_sittingroom << endl;
	//cout << "visit2函数正在访问：" << building->m_bedroom << endl;
}
void test01()
{
	goodgay gg;
	gg.visit();
	gg.visit2();
}
int main() {
	test01();
	system("pause");
	return 0;
}

5运算符重载

5.1加号运算符重载

三种重载方法！

#include<iostream>
using namespace std;

class person
{
public:
	//1 成员函数重载+号
	person operator+(person & p)
	{
		person temp;
		temp.m_a = this->m_a + p.m_a;
		temp.m_b = this->m_b + p.m_b;
		return temp;
	}
	int m_a;
	int m_b;
};
//2 全局函数重载+号
person operator+(person& p1, person& p2)
{
	person temp;
	temp.m_a = p1.m_a + p2.m_a;
	temp.m_b = p1.m_b + p2.m_b;
	return temp;
}
//函数重载的版本
person operator+(person& p1, int num)
{
	person temp;
	temp.m_a = p1.m_a + num;
	temp.m_b = p1.m_b + num;
	return temp;
}
void test01()
{
	person p1;
	p1.m_a = 10;
	p1.m_b = 10;
	person p2;
	p2.m_a = 10;
	p2.m_b = 10;

	//成员函数重载本质
	person p3 = p1.operator+(p2);
	//person p3 = p1 + p2;

	//全局函数重载本质
	person p3 = operator+(p1, p2);
	//person p3 = p1 + p2;

	//运算符重载，也可以发生函数重载
	person p4 = p1 + 10; //person + int
	cout <<"p3.m_a" << p3.m_a  << endl;
	cout <<"p3.m_b" << p3.m_b << endl;

	cout << "p4.m_a" << p3.m_a << endl;
	cout << "p4.m_b" << p3.m_b << endl;
}

int main() {
	test01();
	system("pause");
	return 0;
}

5.2左移运算符重载

输出自定义数据类型

#include<iostream>
using namespace std;

class person
{
	friend ostream& operator<<(ostream& cout, person p);
	friend void test01();
public:
	// 1 处成员函数重载  左移运算符  p.operator<<(cout)  简化版本 p<<cout
	//不会利用成员函数重载<<运算符，因为无法实现 cout在左侧
	//void operator<<(person& p)
	//{
	//}
private:

	int m_a;
	int m_b;
};
//只能利用全局函数重载左移运算符
ostream & operator<<(ostream& cout, person p)   //本质 operator<<(cout,p) 简化 cout << p
{
	cout << "m_a = " << p.m_a << "m_b = " << p.m_b;
	return cout;
}

void test01()
{
	person p;
	p.m_a = 10;
	p.m_b = 10;
	//链式编程思想
	cout << p<<endl;
}

int main() {
	test01();
	system("pause");
	return 0;
}

5.3递增运算符重载

#include<iostream>
using namespace std;
//重载++运算符
//前置和后置++运算符
class myinterger
{
	friend ostream& operator<<(ostream& cout, myinterger myint);  //好朋友友元
public:
	myinterger()
	{
		m_num = 0;
	}
	//重载前置++运算符  返回引用是为了一直对一个数据进行操作
	myinterger & operator++()
	{
		//先进行++的运算
		m_num++;
		//再将自身返回
		return *this;
	}
	//重载后置++运算符
	myinterger operator++(int)  //int让编译器知道你用的是后置运算符重载。
	//int 代表占位参数，可以用来区分前置和后置的递增
	{
		//先 记录当时的结果
		myinterger temp = *this;
		//后 递增
		m_num++;
		//最后将记录的结果进行返回的操作
		return temp;
	}
private:
	int m_num;
};
//重载左移运算符
ostream& operator<<(ostream& cout, myinterger myint)   //本质 operator<<(cout,p) 简化 cout << p
{
	cout << myint.m_num;
	return cout;
}
void test01()
{
	myinterger myint;
	cout<<myint <<endl;
}

//重载后置++运算符
void test02()
{
	myinterger myint;
	cout << myint++ << endl;
	cout << myint << endl;
}
//前置递增返回引用，后置递增返回值
int main() {
	test02();
	system("pause");
	return 0;
}

5.4赋值运算符重载

#include<iostream>
using namespace std;
//
class person
{
public:
	person(int age)
	{
		m_age = new int(age);
		cout << "取" << endl;
		cout << this->m_age << endl;
	}
	~person()
	{
		if (m_age != NULL)
		{
			delete m_age;
			m_age = NULL;
			cout <<"析构" << endl;
		}
	}

	//重载赋值运算符
	person & operator=(person& p)
	{
		//编译器提供浅拷贝
		//m_age = p.m_age;

		//应该先判断是否有属性在堆区，先释放干净在执行深拷贝
		cout << this->m_age << endl;
		if (m_age != NULL)      //将p2的的堆区数据清空，然后放入p1的数据！！！！！！！！！！！！！！！
		{
			delete m_age;
			m_age = NULL;
			cout << "释放" << endl;
			cout << this->m_age << endl;
		}
		//深拷贝
		m_age = new int(*p.m_age);
		//返回对象本体
		cout << this->m_age << endl;
		return *this;
	}
	
	int* m_age;
};

void test01()
{
	person p1(19);
	person p2(20);
	person p3(30);
	p3 = p2 = p1;
	cout << "p1的年龄为" << *p1.m_age << endl;
	cout << "p2的年龄为" << *p2.m_age << endl;
	cout << "p3的年龄为" << *p3.m_age << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

5.5关系运算符重载

#include<iostream>
using namespace std;
//
class person
{
public:
	person(string name, int age)
	{
		m_name = name;
		m_age = age;
	}

	//重载 == 号
	bool operator==(person& p)
	{
		if (this->m_name == p.m_name && this->m_age == p.m_age)
		{
			return true;
		}
		return false;
	}
	//重载 ！= 号
	bool operator!=(person& p)
	{
		if (this->m_name == p.m_name && this->m_age == p.m_age)
		{
			return false;
		}
		return true;
	}
	string m_name;
	int m_age;
};
void test01()
{
	person p1("tom", 18);
	person p2("jack", 22);
	if (p1 == p2)
	{
		cout << "p1 和p2 是相等的" << endl;
	}
	else
	{
		cout <<"布线等" << endl;
	}
	if (p1 != p2)
	{
		cout << "p1 和p2 是相等的" << endl;
	}
	else
	{
		cout << "布线等" << endl;
	}
}
int main() {
	test01();
	system("pause");
	return 0;
}

5.6函数调用运算符重载

函数调用运算符()也可以重载
由于重载后使用的方式非常像函数的调用，因此称为仿函数
仿函数没有固定写法，非常灵活

#include<iostream>
using namespace std;
//打印输出类
class myprint
{
public:
	//重载函数调用运算符
	void operator()(string test)
	{
		cout << test<< endl;
	}
};

void myprint02(string test) {
	cout <<test  <<endl;
}

void test01()
{
	myprint myprint;
	myprint("hello world"); //由于使用起来非常类似于函数调用，因此称为仿函数
	myprint02("hello world");
}

//仿函数非常灵活，没有固定的写法  test01, test02
//加法类
class Myadd
{
public:
	int operator()(int num1, int num2)
	{
		return num1, num2;
	}
};
void test02()
{
	Myadd myadd;
	int ret = myadd(100, 100);
	cout <<"ret = " << ret<< endl;
	//匿名函数对象   运行玩一次就会被释放掉
	cout << Myadd()(100, 100) << endl;
}
int main() {
	test02();
	system("pause");
	return 0;
}
爱抖腿的小松鼠
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习笔记- 面向对象 .md
11-13
内容是C++面对对象的，目录大致来源于菜鸟文档的C++面向对象，笔记是参考各种文章以及菜鸟文档改编的，内容包含C++类和对象（类定义和对象定义，类成员函数，类访问修饰符，友元函数，内联函数，this指针，静态成员...
C++学习之虚指针与虚表（动态绑定、多态）、this指针（侯捷老师）
YGQ_qq_1435471912
06-15 315
２、静态绑定一定是通过call函数，调用某个特定的地址，而动态绑定，是通过指针来调用；之后，这个指针必须是向上转型，比如是class C的指针，但是该指针实际上包含A的特性，那么就属于向上转型；至于调用哪个函数呢，需要看ｐ指针指向的是什么。这里也可以理解多态，虚机制，动态绑定，实际上他们三个基本上是一码事。1、class A有虚函数，因此会有虚指针，虚指针(virtual pointer)指向一个表即虚表，virtual table，虚表中存放的都是函数指针，指向虚函数（非虚函数不用管）。
【C++】C++中的 `this` 指针：深度探索和应用
crr411422的博客
06-06 4290
本文的目的是深入探讨 this 指针的使用，包括其基本理解、实际应用、使用限制以及在不同编程场景中的作用。我们将从基础概念开始，逐步深入，包括 this 指针在成员函数中的使用、解决变量命名冲突、实现链式调用、在继承和多态中的作用、const 成员函数中的特殊行为、多线程编程中的应用等。通过本文，读者将对 this 指针有更全面的理解，并能够正确而有效地使用它来改进自己的 C++ 代码。
C++周总结：this、指针与成员、const成员函数对象、虚函数 与 多态
foolbirdM的博客
10-26 172
c++周总结 二、空指针访问成员函数 对象空指针可以访问对象的方法，但是得没有用到this的方法。比如对象里面使用了对象的属性age时候，就相当于是this->age 为了保证健壮性，可以这样： 三、const修饰成员函数，对象 常函数： 不能修改成员属性 但是成员加了mutable就可以了 但是 常对象 不能修改对象的值，但是加了mutable就可以了 常对象只能调用常函数 四、友元（可以访问private） 全局函数做友元 类做友元 ...
java this指针与多态
WhyWhatHow-Craze
12-07 194
原因： 由于自己的愚蠢没有看懂 BaseServlet 中的this指针 知识总结： 类中，变量没有多态，子类成员有多态 感谢博主：传送门 代码逻辑： index.html -&gt; ServletDemo03.java -&gt; BaseServlet.java -&gt;ServletDemo03.java(反射調用相應的方法) index.html &lt;!DOCTY...
C++入门指南-v2.4.pdf
06-23
五、C++多态与抽象类 91 5.1 多态概念介绍 91 5.2 虚函数 92 5.3 纯虚函数和抽象类 95 六、C++运算符重载 97 6.1 运算符重载语法介绍 97 6.2 可重载运算符与不可重载运算符 98 6.3 一元运算符重载 99 6.4 二元运算符...
C++实验1-13，包含完整程序、注释、报告
08-07
本资源为C++实验1-13，包含完整程序、注释、报告非常适合初学者学习、研究，具体如下： 实验1-熟悉Visual C++编程环境 ...实验10-运算符重载编程 实验11- 利用模板编程 实验12-利用文件编程 实验13- 面向对象综合编程
C++上机实验报告-实验六.docx
03-09
} 如何将一个运算符重载为类的友元函数？ friend 函数类型 operator 运算符（形参表） { 函数体； } 3.如何实现运行时刻的多态？ 在基类的成员函数前加上virtual，就可以在它的派生类中声明相同名字和类型的成员...
C-Learn-Note
03-31
最近重温了C ++入门复习了C ++加深一些理解这里是一些学习c ++过程的笔记了解Note目录（括号中表示当前程序关联的其他文件位于其他文件文件夹下）： 1.动态内存，智能指针2.泛型算法，Lambda 3.调用win32api 4.元组5...
this指针多态性
alim2012的博客
10-05 513
public class Dervied extends Base { { System.out.println("Dervied Con1 "+ this.name ); } private String name = "dervied"; { System.out.println("Dervied Con2 "+ this.name ); }...
C++之this指针与另一种“多态”
weixin_33695082的博客
08-21 131
C++之this指针与另一种“多态”   2010-7-9 烛秋 一、引入 　　定义一个类的对象，首先系统已经给这个对象分配了空间，然后会调用构造函数（说明：假设存在构造函数--2010.9.5修正）。一个类有多个对象，当程序中调用对象的某个函数时，有可能要访问到这个对象的成员变量。而对于同一个类的每一个对象，都是共享同一份类函数。对象有单独的变量，但是没有单独的函数，所以当调用函数时，...
C++运算符重载、友元、继承、多态、文件操作
LonelyBHBH的博客
10-28 243
一、运算符重载 1.加号运算符 定义operator+（）下面直接用+即可 2.左移运算符 ostream& operator<<(ostream& cout, zuoyi& z) 下面直接用 3.递增运算符 //前置++重载 dizeng& operator++()//返回引用是因为 一直对一个做操作 { NUM++; return *this; } //后置++重载 //后置返回的是值不是引用 因为 返回的是...
C++核心编程(6)-- C++对象模型和this指针
kakaka666的博客
06-06 130
6.1 成员变量和成员函数分开存储 在C++中，类内的成员变量和成员函数分开存储 只有非静态成员变量才属于类的对象上
运算符重载和友元函数
liutao43的博客
05-25 975
运算符重载 所谓运算符重载其实就是运算符的多态,函数的多态就是同个函数名有不同的功能,运算符重载或者运算符多态就是同一个运算符有多个意思,在c语言中,出现过类似运算符重载的例子,比如 int x,y,z; int* p; x = 1; y = 1; z = x * y; p = &x; 以上代码指出,*这个符号不仅可以用来计算数字之间相乘的结果,而且还可以解引用指针所指的空间中的值. 在c++中如果我定义一个类Time,这个类有两个对象time1,time2,我要计算time1,time2的和怎么
C++对象模型和this指针
qq_39368007的博客
02-09 177
C++对象模型和this指针 成员变量和成员函数分开存储 在C++中，类内的成员变量和成员函数分开存储 只有非静态成员变量才属于类的对象上 #include <iostream> using namespace std; class Person { public: Person() { mA = 0; } //非静态成员变量占对象空间 int mA; //静...
c++核心之四、类和对象3、C++对象模型和this指针
SSunshaoye的博客
04-29 82
4.3 C++对象模型和this指针 4.3.1 成员变量和成员函数分开存储 在C++中，类内的成员变量和成员函数分开存储 只有非静态成员变量才属于类的对象上 空对象占用1字节内存空间，不是空对象就占用4字节 class Person { public: Person() { mA = 0; } //非静态成员变量占对象空间 int mA; //静态成员变量不占对象空间 static int mB; //非静态成员函数也不占对象空间，所有函数共享一个函数实例 void func() {
c/c++ 继承与多态 友元与继承
weixin_30753873的博客
01-02 88
问题1：类B是类A的友元类，类C是类B的友元类，那么类C是类A的友元类吗？函数fun是类B的友元函数，那么fun是类A的友元函数吗？ 都不是，友元关系不能传递。 问题2：类B是类A的友元类，类C是类B的子类，那么类C是类A的友元类吗？ 不是，友元关系不能继承。 问题3：类A_Fri是类A的友元类，类B是类A的子类，那么在类A_Fri的成员方法里， （1）可以用类A的对象访问类A的私有成员吗？ （2...
java面向对象-封装、继承和多态头歌
最新发布
11-02
Java作为一种面向对象的编程语言，具有封装、继承和多态这三个重要概念。 首先，封装是指将数据和对数据的操作封装在一个类中，隐藏了实现的细节。通过封装，我们可以将数据的访问权限进行控制，从而保证数据的安全...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值