[黑马程序员课程记录]C++核心部分3

最新推荐文章于 2024-08-17 23:59:05 发布
最新推荐文章于 2024-08-17 23:59:05 发布
阅读量378 收藏
点赞数
分类专栏： C++之基础 文章标签： c++ 开发语言 visual studio 改行学it
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53953432/article/details/127269124
版权

4.4 友元

生活中你的家有客厅(Public)，有你的卧室(Private)

客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去

但是呢，你也可以允许你的好闺蜜好基友进去。

在程序里，有些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术

友元的目的就是让一个函数或者类 访问另一个类中私有成员

友元的关键字为 friend

友元的三种实现

  • 全局函数做友元
  • 类做友元
  • 成员函数做友元
4.4.1 全局函数做友元
#include<iostream>
using namespace std;
#include<string>

//全局函数做友元
class building
{
	//goodguy全局函数是building的好朋友，可以访问私有空间
	friend void goodguy(building* building);

public:
	building()
	{
		m_sittingroom = "客厅";
		m_bedroom = "卧室";
	}

public:
	string m_sittingroom;

private:
	string m_bedroom;
};

//全局函数
void goodguy(building *building)
{
	cout << "好基友全局函数正在访问：" << building->m_sittingroom << endl;

	cout << "好基友全局函数正在访问：" << building->m_bedroom << endl;
}

void test1()
{
	building building;
	goodguy(&building);
}


int main()
{
	test1();


	system("pause");
	return 0;
}
4.4.2 类做友元
#include<iostream>
using namespace std;
#include<string>

//类做友元
class building;

class goodguy
{
public:
	goodguy();

	void visit();//参观函数 访问building中的属性

	building* m_building;

};

class building
{
	friend class goodguy;//goodguy是本类的好朋友，可以访问私有成员

public:
	building();

public:
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;//卧室
};

building::building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}

goodguy::goodguy()
{
	//创建一个建筑物对象
	m_building = new building;
}

void goodguy::visit()
{
	cout << "好基友正在访问" << m_building->m_SittingRoom << endl;
	cout << "好基友正在访问" << m_building->m_BedRoom << endl;
}

void test1()
{
	goodguy gg;
	gg.visit();
}
int main()
{
	test1();


	system("pause");
	return 0;
}
4.4.3 成员函数做友元
#include<iostream>
using namespace std;
#include<string>

//成员函数做友元
class building;

class goodguy
{
public:
	goodguy();

	void visit();//参观函数 访问building中的私有成员
	void visit2();//不能访问私有成员

	building* m_building;

};

class building
{
	friend void goodguy::visit();//goodguy类下的visit是本类的好朋友，可以访问私有成员

public:
	building();

public:
	string m_SittingRoom; //客厅

private:
	string m_BedRoom;//卧室
};

building::building()//下面都是练习一下类外实现定义
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}

goodguy::goodguy()
{
	//创建一个建筑物对象
	m_building = new building;//在堆区创建空间，用指针维护
}

void goodguy::visit()
{
	cout << "visit正在访问" << m_building->m_SittingRoom << endl;
	cout << "visit正在访问" << m_building->m_BedRoom << endl;
}

void goodguy::visit2()
{
	cout << "visit2正在访问" << m_building->m_SittingRoom << endl;
	//cout << "visit2正在访问" << m_building->m_BedRoom << endl;  //没有给friend
}

void test1()
{
	goodguy gg;
	gg.visit();
	gg.visit2();
}
int main()
{
	test1();


	system("pause");
	return 0;
}

4.5 运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

4.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& p, int a)
{
	person temp;
	temp.m_a = p.m_a + a;
	temp.m_b = p.m_b + a;
	return temp;
}

void test1()
{
	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;
	cout << "p3.m_a= : " << p3.m_a << endl;
	cout << "p3.m_b= : " << p3.m_b << endl;

	//全局函数重载的本质调用
	//person p3 = operator+(p1, p2);
	person p4 = p1 + p2;
	cout << "p4.m_a= : " << p4.m_a << endl;
	cout << "p4.m_b= : " << p4.m_b << endl;
	
	//运算符重载  也可以发生函数重载
	person p5 = p1 + 100;//相当于operator+（p1，100）
	cout << "p5.m_a= : " << p5.m_a << endl;
	cout << "p5.m_b= : " << p5.m_b << endl;
	
}


int main()
{
	test1();

	system("pause");
	return 0;
}

总结1：对于内置的数据类型的表达式的的运算符是不可能改变的

总结2：不要滥用运算符重载

4.5.2 左移运算符重载

作用：可以输出自定义数据类型

#include<iostream>
using namespace std;

//左移运算符重载

class person
{
	friend ostream& operator<<(ostream& cout, person& p);
public:
	person(int a,int b)
	{
		m_a = a;
		m_b = b;
	}

	//利用成员函数重载 左移运算符  p.operator<<(cout) 简化版本p<<cout;
	//不会利用成员函数重载<<运算符，因为无法实现cout 在左侧
	/*void operator<<(cout)
	{

	}*/

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 test1()
{
	person p1(10,10);
	

	cout << p1 << endl;
}


int main()
{
	test1();

	system("pause");
	return 0;
}

总结：重载左移运算符配合友元可以实现输出自定义数据类型

4.5.3 递增运算符重载

作用： 通过重载递增运算符，实现自己的整型数据

//区分前置后置区别
前置operator++（）
后置operator++（int）

#include<iostream>
using namespace std;

//递增符重载

class myinteger
{
	friend ostream& operator<<(ostream &cout, myinteger myint);
		
public:
	myinteger()
	{
		m_num = 0;
		
	}

	//重载前置++运算符  
	//返回引用是为一直对一个数据进行递增操作，不然会把加完数据变成一个新的变量重新加
	myinteger& operator++()
	{
		//先做递增操作
		m_num++;

		//把自身做一个返回
		return *this;
	}

	//重载后置++运算符
	//void operator++(int)  int代表占位参数，可以区分前置和后置递增
	myinteger operator++(int)
	{
		//先记录当时结果
		myinteger temp = *this;
		//递增
		m_num++;
		//将记录结果返回
		return temp;
	}

private:
	int m_num;
};

//重载左移运算符
ostream& operator<<(ostream &cout, myinteger myint)
{
	cout << myint.m_num ;
	return cout;
	
}
void test1()
{
	myinteger myint;
	cout << ++(++myint) << endl;
	cout << myint << endl;

}
void test2()
{
	myinteger myint;
	cout << myint++ << endl;//后置只能加一次，没有引用
	cout << myint << endl;

}

int main()
{
	test1();
	test2();

	system("pause");
	return 0;
}

总结： 前置递增返回引用，后置递增返回值

4.5.3.1递减运算符重载
#include<iostream>
using namespace std;

class mydecrease
{
	friend ostream& operator<<(ostream &cout, mydecrease md);

public:
	mydecrease()
	{
		m_num = 0;
	}

	mydecrease& operator--()
	{
		m_num--;
		return *this;
	}
	mydecrease operator--(int)
	{
		mydecrease temp;
		m_num--;
		return temp;
	}

private:
	int m_num;
};

ostream& operator<<(ostream &cout, mydecrease md)
{
	cout << md.m_num;
	return cout;
}

void test1()
{
	mydecrease md;
	cout << --md << endl;
	cout << md << endl;
}

void test2()
{
	mydecrease md;
	cout << md-- << endl;
	cout << md << endl;
}

int main()
{
	test1();
	test2();

	system("pause");
	return 0;
}
4.5.4 赋值运算符重载

c++编译器至少给一个类添加4个函数

  1. 默认构造函数(无参，函数体为空)
  2. 默认析构函数(无参，函数体为空)
  3. 默认拷贝构造函数，对属性进行值拷贝
  4. 赋值运算符 operator=, 对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

示例：

#include<iostream>
using namespace std;

class person
{
public:
	 
	person(int age)
	{
		m_age = new int(age);//堆区开辟内存
	}
		

	~person()
	{
		if (m_age != NULL)
		{
			delete m_age;
			m_age = NULL;
		}
	}

	//赋值运算符重载
	person& operator=(person& p)
	{
		//编译器的浅拷贝
		//m_age=p.m_age;
		
		//应先判断是否有属性在堆区，如果有先释放干净，然后在进行深拷贝
		if (m_age != NULL)
		{
			delete m_age;
			m_age = NULL;
		}
		
		//深拷贝
		m_age = new int(*p.m_age);

		return *this;

	}

	int* m_age;
};

void test1()
{
	person p1(18);

	person p2(20);

	person p3(20);

	p3=p2 = p1;//赋值操作

	cout << "p1的年龄: " << *p1.m_age << endl;
	cout << "p2的年龄: " << *p2.m_age << endl;
	cout << "p3的年龄: " << *p3.m_age << endl;

}


int main()
{
	test1();
	
	system("pause");
	return 0;
}
4.5.5 关系运算符重载

作用： 重载关系运算符，可以让两个自定义类型对象进行对比操作

示例：

#include<iostream>
using namespace std;
#include<string>

//关系运算符重载

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;
		}
		else
		{
			return false;
		}
	}

	bool operator!=(person& p)
	{
		if (this->m_name != p.m_name || this->m_age != p.m_age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	string m_name;
	int m_age;
};

void test1()
{
	person p1("汤姆",19);
	person p2("汤姆",29);

	if (p1==p2)
	{
		cout << "相同" << endl;
	}
	else
	{
		cout << "不同" << endl;
	}

	if (p1 != p2)
	{
		cout << "不同" << endl;
	}
	else
	{
		cout << "相同" << endl;
	}
}


int main()
{
	test1();
	
	system("pause");
	return 0;
}
4.5.6 函数调用运算符重载
  • 函数调用运算符 () 也可以重载
  • 由于重载后使用的方式非常像函数的调用，因此称为仿函数
  • 仿函数没有固定写法，非常灵活

示例：

#include<iostream>
using namespace std;
#include<string>

//函数调用运算符重载

//打印输出类
class myprint
{
public:

	//重载函数调用运算符
	void operator()(string test)
	{
		cout << test << endl;
	}
};

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

void test1()
{
	myprint mp;
	
	mp("hello world");//由于使用起来非常像一个函数，所以叫仿函数

	myprint2("hhhhhh");
}

//仿函数非常灵活，没有固定写法
//加法类
class myadd
{
public:

	int operator()(int num1, int num2)
	{
		return num1 + num2;
	}
};
void test2()
{
	myadd ma;
	
	int ret=ma(100, 100);
	cout << ret << endl;

	//匿名对象
	cout << myadd()(100, 100) << endl;//相当于myadd（）=ma；看到带（）就要反应是匿名对象，然后看它是否使用重载值
}

int main()
{
	test1();
	test2();

	system("pause");
	return 0;
}
华氏451度。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员C++学习笔记
weixin_46015291的博客
05-31 4881
C++基础入门 1 C++初识 1.1 第一个C++程序 编写一个C++程序总共分为4个步骤 创建项目 创建文件 编写代码 运行程序 1.1.1 创建项目 ​ Visual Studio是我们用来编写C++程序的主要工具，我们先将它打开 1.1.2 创建文件 右键源文件，选择添加->新建项 给C++文件起个名称，然后点击添加即可。 1.1.3 编写代码 #include<iostream> using namespace std; int main() { cout &
C++学习(第2天)（黑马程序员学习笔记）
纯粹的博客
05-16 343
1.程序流程结构 if 语句 语法 if(条件) { 条件满足执行的语句 } 第1个程序：输入一个分数，如果分数大于600分，视为考上一本大学，并在屏幕上打印，我考上了一本大学 #include<iostream> #include<string> using namespace std; int main() { int score = 0; cout << "请输入一个分数：" << endl; cin >> score; i
[黑马程序员课程记录]C++核心部分1
m0_53953432的博客
10-07 131
内存分配模型+引用+函数提高
[黑马程序员课程记录]C++核心部分5
m0_53953432的博客
10-13 558
c++面向对象三大特性之一—多态
黑马程序员，C++核心编程
04-17
黑马程序员，C++核心编程
第二阶段 黑马程序员C++核心编程
06-07
第二阶段 黑马程序员C++核心编程.md
C++黑马程序员学习资料
08-05
C++黑马程序员学习资料，附赠《InterviewGuide第四版By阿秀》、《LeetCode刷题手册》、《背包问题九讲》、《算法图解》pdf版本，三个基础课程文档手册及三个实验项目，由简到繁分别为《通讯录管理系统》、《职工管理...
传智播客旗下黑马程序员c++视频课程内部讲义
04-16
《传智播客旗下黑马程序员C++视频课程内部讲义》是一份专为学习C++编程语言设计的教育资料，由知名教育机构传智播客旗下的黑马程序员团队精心编撰。这份讲义作为课堂教学的重要辅助工具，旨在帮助学生深入理解和掌握...
C语言 | Leetcode C语言题解之第337题打家劫舍III
m0_59237910的博客
08-15 275
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++(11)类语法分析(2)
最新发布
Once_day的回忆
08-17 724
Author：Once Day Date：2024年8月17日漫漫长路，才刚刚开始…全系列文章请查看专栏: 源码分析_Once-Day的博客-CSDN博客参考文档:基础类的介绍请参考文章：C++(10)类语法分析(1)-CSDN博客运算符重载是C++的一个强大特性，它允许为用户定义的类型自定义运算符的行为。通过运算符重载，我们可以使自定义类型的对象支持各种运算符，如算术运算符、比较运算符、输入输出运算符等，从而提高代码的可读性和表现力。运算符重载的语法，运算符重载的实现方式是定义一个特殊的成员函数或全局函数
c++编程（22）——STL（6）set
2301_77239666的博客
08-16 879
欢迎来到博主的专栏——c++编程博主ID：代码小豪。
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 293
C++ | Leetcode C++题解之第337题打家劫舍III
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 997
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
C++_基本语法笔记_模板
qq_45629864的博客
08-14 415
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
typdef 与 struct
ligreenjian的博客
08-14 115
int age;int num;//每使用一次就要多一个struct。使用typdef就简洁些。
整型二分,浮点二分法 C++
xcc134679的博客
08-16 273
需要注意的是，由于浮点数的精度问题，如果要查找的目标值非常接近区间的边界，可能无法准确地找到目标值，而是得到一个非常接近但不完全相等的浮点数。另外，在实际应用中，可能还需要设置一个终止条件来避免无限循环，例如在已知的精度范围内无法再继续缩小区间。浮点二分法的基本思想是通过将区间不断地二分，来逐步缩小查找范围，直到找到目标值或确定目标值不存在。- 如果M等于目标值，那么找到了目标值，返回M。- 如果M小于目标值，那么将L设为M，继续二分。- 如果M大于目标值，那么将R设为M，继续二分。
C++_基本语法笔记_继承和多态
qq_45629864的博客
08-13 568
思想与Java差不多。
黑马程序员讲义-C++核心编程pdf
09-07
黑马程序员讲义-C核心编程的PDF是程序员讲义的第三阶段的讲义，它包含了关于C语言的内容。你可以通过引用来获取这个PDF的具体内容。<span class="em">1</span><span class="em">2</span><span class="em">3</span>...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值