c++学习笔记（7）友元 运算符重载

已于 2023-05-17 16:50:53 修改
阅读量331 收藏
点赞数
文章标签： 学习 笔记
于 2023-05-17 16:50:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42937719/article/details/130707312
版权

目录

友元

1 全局函数做友元

2 类做友元

3 成员函数做友元

运算符重载

1.加号运算符重载

(1)成员函数重载+号

（2）全局函数重载+号

2.左移运算符重载

3.递增运算符重载

4.赋值运算符重载

5.关系运算符重载

6.函数调用运算符重载

友元

让一个函数或者类访问另一个类中私有成员

关键字：friend

三种实现：

1 全局函数做友元

使用全局函数访问类中的私有成员

friend void goodGay(Building* building);

#include <iostream>
using namespace std;
#include<string>
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 * building)
{
	cout << "好朋友全局函数正在访问：" << building->m_SittingRoom << endl;
	cout << "好朋友全局函数正在访问：" << building->m_BedRoom << endl;
}

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

2 类做友元

friend class GoodGay;

代码中包括类中构造函数以及成员函数的类外实现（加：：作用域）

#include <iostream>
using namespace std;
#include<string>
// 类做友元
class Building; //提前声明
class GoodGay {
public:
	GoodGay();
	void visit();//参观函数 访问building中属性
	Building* building;
};
class Building
{
	//友元类，可以访问私有成员
	friend class GoodGay;
public:
	Building();  //构造函数，本次放在类外实现
public:
	string m_SittingRoom; // 客厅
private:
	string m_BedRoom;  // 卧室
};
Building::Building()
{
	m_SittingRoom = "客厅";

	m_BedRoom="卧室";  
}
GoodGay::GoodGay() {
	//创建建筑物对象
	building = new Building;  //在堆区创建一个对象，用building维护
}
void GoodGay::visit() {
	// 类外实现GoodGay类中的函数
	cout << "GoodGay类正在访问：" << building->m_SittingRoom << endl;
	cout << "GoodGay类正在访问：" << building->m_BedRoom << endl;

}
void test01() {
	GoodGay g;
	g.visit();
}
int main() {
	test01();
	system("pause");
	return 0;
}

3 成员函数做友元

在类中加入

friend void GoodGay::visit();

与全局函数做友元的区别是添加作用域

运算符重载

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

1.加号运算符重载

实现两个自定义数据类型相加的运算

(1)成员函数重载+号

成员函数重载本质调用：

Person p3=p1.operator+(p2);

#include<iostream>
using namespace std;
#include<string>
//加号运算符重载
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;
};
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 + p2;
	cout << "p3.m_A" << p3.m_A << endl;
}


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

（2）全局函数重载+号

全局函数重载本质调用：

Person p3=operator+(p1,p2);

#include<iostream>
using namespace std;
#include<string>
//加号运算符重载
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;
}
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 + p2;
	cout << "p3.m_A" << p3.m_A << endl;
}


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

运算符重载也可以发生函数重载

对于内置的数据类型的表达式的运算符是不可更改的

不要滥用运算符重载

2.左移运算符重载

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

不会利用成员函数重载<<运算符，因为无法实现在左侧

只能利用全局函数重载<<

ostream & operator<<(ostream &cout,Person p){}

#include<iostream>
using namespace std;
#include<string>
//左移运算符重载
class Person {
public:
	
	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 <<endl;
	return cout;  //为了实现链式编程，cout后追加多个输出
}
void test01(){
	Person p;
	p.m_A = 10;
	p.m_B = 10;
	cout << p<<endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

3.递增运算符重载

作用：实现自己的整型数据

重载前置++运算符
    返回引用  是为了一直对一个数据进行操作

重载后置++运算符
    传入的int代表占位参数，可以用于区分前置后置递增
    此处要返回值，不能返回引用，因为返回的是局部对象
 

#include<iostream>
using namespace std;
#include<string>
//重载递增运算符
//自定义整型
class MyInt
{
	friend ostream& operator<<(ostream& cout, MyInt myint);
public:
	MyInt() {
		m_num = 0;
	}
	//重载前置++运算符
	//返回引用是为了一直对一个数据进行操作
	MyInt& operator++() {
		m_num++;
		return *this;
	}

	//重载后置++运算符
	//传入的int代表占位参数，可以用于区分前置后置递增
	//此处要返回值，不能返回引用，因为返回的是局部对象
	MyInt operator++(int) {
		//先 记录结果
		MyInt temp = *this;
		//后 递增
		m_num++;

		//最后返回记录的结果

		return temp;
	}
private:
	int m_num;
};
//重载左移运算符
ostream& operator<<(ostream& cout, MyInt myint) {
	cout << myint.m_num;
	return cout;
}
void test01() {
	MyInt myint;
	cout << ++myint << endl;
}
void test02() {
	MyInt myint;
	cout << myint++ << endl;
	cout << myint << endl;
}
int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

4.赋值运算符重载

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

1）默认构造函数（无参，函数体为空）

2）默认析构函数（无参，函数体为空）

3）默认拷贝函数，对属性进行值拷贝

4）赋值运算符operator=对属性进行值拷贝

#include<iostream>
using namespace std;
#include <string>
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) {
		//返回类型要用&，否则返回的是拷贝构造函数拷贝的值，而不是它本身
		//应该先判断是否有属性在堆区，如果有，先进行释放
		if (m_Age != NULL) {
			delete m_Age;
			m_Age = NULL;

		}
		//进行深拷贝
		m_Age = new int(*p.m_Age);
		//返回自身
		return *this;
	}
	int* m_Age;
};
void test01() {
	Person p1(18);
	Person p2(20);
	Person p3(30);
	//p2=p1;  //默认等号是浅拷贝，会出现重复释放空间，所以重载，编程深拷贝
	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.关系运算符重载

==   != > <

返回bool

#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_Age == p.m_Age && this->m_Name == p.m_Name)
			return true;
		else {
			return false;
		}
	}
	bool operator!=(Person& p) {
		if (this->m_Age != p.m_Age && this->m_Name != p.m_Name)
			return false;
		else {
			return true;
		}
	}
	string m_Name;
	int m_Age;
};
void test01() {
	Person p1("tom", 18);
	Person p2("amy", 18);
	if (p1 == p2) {
		cout << "p1和p2相等" << endl;
	}
	else {
		cout << "p1和p2不相等" << endl;
	}
	if (p1 != p2) {
		cout << "p1和p2不相等" << endl;
	}
	else {
		cout << "p1和p2相等" << endl;
	}

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

6.函数调用运算符重载

()小括号重载

由于重载后使用的方式非常像函数的调用，因此被称为仿函数

仿函数没有固定的写法，非常灵活

myprint("hello world");  // ()重载实现，使用非常像函数，所以又称仿函数
MyPrint02("hello world!!!"); //函数实现

匿名函数对象  类（）
cout << MyAdd()(200, 300) << endl;

#include<iostream>
using namespace std;
#include <string>
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!!!"); //函数实现
}
//仿函数非常灵活，无固定写法，如：
class MyAdd {
public:
	int operator()(int a,int b) {
		return a + b;
	}
};
void test02() {
	MyAdd myadd;
	int result = myadd(100, 200);
	cout << result << endl;

	//匿名函数对象  类（）
	cout << MyAdd()(200, 300) << endl;
}
int main() {
	test01();
	test02();
	system("pause");
	return 0;
}

碎碎碎发发
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++运算符重载 成员函数与友元函数详解
12-31
代码如下:#include<iostream>using namespace std;class A{ int x,y; public: A(int xx,int yy):x(xx),y(yy){} A(){x=0;y=0;} A operator+(const A&b) //不加const限定，也可以 { return A(x+b.x,y+b.y);...
c++使用友元重载运算符
sdhdsf132452的博客
10-17 569
c++友元运算符重载
C++基础篇 第三天 友元和运算符重载
southernbrid的博客
05-05 308
友元函数是一种特殊类型的函数，它能够访问类的私有成员和保护成员。这意味着，即使这些成员被声明为私有或保护的，友元函数也可以在类外部直接访问它们。友元函数的作用主要有以下几个方面：提高程序的效率：如果某个函数需要频繁地访问类的私有成员或保护成员，将其声明为友元函数可以避免通过类的公共接口来访问这些成员，从而提高程序的效率。增加代码的灵活性：友元函数可以访问类的私有成员和保护成员，这使得在某些情况下可以更方便地实现某些功能。
万物可运算： 运算符重载，
m0_46376834的博客
05-23 278
万物可运算为什么要使用运算符重载重载加减运算符=重载关系运算符>、<、==常见错误总结 为什么要使用运算符重载 C/C++的运算符，支持的数据类型，仅限于基本数据类型。 问题：一头牛+一头马 = ？（牛马神兽？） 一个圆 +一个圆 = ？ （想要变成一个更大的圆） 一头牛 – 一只羊 = ？ (想要变成4只羊，原始的以物易物：1头牛价值5只羊) 解决方案： 使用运算符重载 运算符重载的基本用法 方式1：使用成员函数重载运算符 需求： // 规则： // 一斤牛肉：2斤猪肉 // 一斤羊肉：3斤猪
西安石油大学C++上机实验 上机二：友元和运算符重载程序设计（2学时）
shaozheng0503的博客
04-14 467
了解友元函数的概念。掌握友元函数的定义和使用方法。了解运算符重载的概念和使用方法。掌握几种常用的运算符重载的方法。编写一个时间类，实现时间的加、减运算并输出。1．练习友元函数的定义和运算符重载的方法；2．测试章节例题，设计运算符重载的复数类，实现常用复数运算操作，分别重载为类的成员函数和重载为类的友元函数，并编写一个测试程序进行测试。（4）编辑头文件。在弹出的 Complex.h 头文件中添加 Complex 类的代码，完成如下。
c++的友元，运算符重载
sakura0908的博客
04-09 1271
重载运算符限制在C++语言中已有的运算符范围内，并且允许重载的运算符之中，不能创建新的运算符。运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数 及语法结构。运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象 一起使用，或者用于用户自定义类型的对象和内部类型的对象混合使用时。
C++封装思想之二：友元机制和运算符重载（1W字详解）
qq_25218501的博客
08-04 739
友元的作用：类的非成员函数可以直接访问类的非公有成员变量，省去函数的调用和访回过程。从而提高了程序的运行效率（即减少了类型和安全性检查及调用的时间开销） 运算符重载的作用 可以提高程序的可读性 体现了C++的可扩充性 运算符重载仅仅只是语法上的方便，它是另一种函数调用的方式 运算符重载，本质上是函数重载
【C++】第4章 运算符重载
Akiiiira的博客
06-29 221
如果不做特殊处理，C++的 “+” 、 “-” 、 “*” 、 “/” 等运算符还能用于对基本类型的常量或者变量进行运算，不能用于对象之间的运算。有时候希望对象之间也能用这些运算符进行运算，以达到使程序更简洁、易懂的目的。例如分数、复数的计算。利用C++提供的“运算符重载”机制，赋予运算符新的功能，就能解决例如用“+”将两个复数对象相加这样的问题。运算符重载，就是对已有的运算符赋予多重含义，使同一运算符作用于不同类型的数据时产生不同的行为。运算符重载的目的是使得C++中的运算符也能够用来操作对象。
c++运算符重载，友元
我的博客
10-01 841
c++运算符重载的规则，重载输入，输出，前++，后++，单目运算符，双目运算符……
c++的友元函数、友元类、重载运算符、函数返回值为引用
qq_51476492的博客
11-24 1054
类实例化的对象不能直接访问对象中的私有成员，但可以通过设置友元函数和友元类的方式开放访问权限令其可以直接访问。 1.友元函数：在类中声明全局函数或者其他类的函数为友元函数，这样函数的参数或者局部变量中的对象可以直接访问私有成员。 格式： friend 返回值类型 函数名(参数表); 例： 2.友元类：声明其他类为友元类 3.重载运算符 ...
c++ demo，重载运算符，友元函数的实现
01-24
c++ demo，重载运算符，友元函数的实现
C++运算符重载友元函数实例
08-17
一个实例，实现运算符重载（成员函数和非成员函数两种方式），友元函数的使用，注意事项等，自己学习时编写的，
类域 友元 运算符 重载
01-05
类域 友元 运算符 重载类域 友元 运算符 重载类域 友元 运算符 重载
C++运算符重载和友元函数用法
Invoker's Tower
04-04 9469
1.运算符重载定义： C++中预定义的运算符的操作对象只能是基本数据类型。但实际上，对于许多用户自定义类型（例如类），也需要类似的运算操作。这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引人的特性之一。 运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运
（B站黑马C++）友元 + 运算符重载
IT OR 考公？
05-31 816
C++语法糖，黑马C++，1.5倍速跟着敲
C++友元与运算符重载
makabaka12138的博客
01-03 720
C++友元与运算符重载
C++学习（6）——友元和运算符重载
似末的博客
03-08 1116
friend（友元）、友元函数、友元类、+号重载（-号类似）、++重载（--类似）、=号重载。
c 语言友元函数重载,C++友元函数重载"++"和"--"运算符
weixin_42581846的博客
05-20 1261
代码：#include #include using namespace std;class one{public:one(int i);void print();friend one operator++(one&);friend one operator++(one&,int);private:int i;};one::one(int I){i = I;}void one::p...
FME学习之旅---day27
最新发布
summer_corner的博客
05-17 201
我们付出一些成本，时间的或者其他，最终总能收获一些什么。
c++矩阵类及双目友元运算符重载
10-17
好的，针对您的问题，我可以给出以下代码示例： ```c++ #include #include using namespace std; class Matrix { ... Matrix(int r, int c) : row(r),...其中，双目运算符重载使用了友元函数，以便访问私有成员变量。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值