C++编程 友元函数、友元类、运算符重载 案例详细解析

已于 2023-10-17 20:58:03 修改
阅读量987 收藏 3
点赞数 1
分类专栏： C++程序设计 文章标签： c++
于 2022-04-24 15:43:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56051805/article/details/124383421
版权

目录

一：友元函数

二：友元类

三：运算符重载

四：= 运算符重载

一：友元函数

优势：友元函数可以访问类中的所有成员（公有，私有，保护），提高程序的运行效率

关键字：friend

缺点：破坏面向对象程序设计类的封装性

示例如下：

CStaff.h：

#ifndef CSTAFF_H
#define CSTAFF_H

class Staff
{
public:
	Staff();
	Staff(int id,char *name,char *pwd,int prole);
	~Staff();
	static int num;//静态数据成员 放在公有的
	static int getNum();

	//友元函数---类外函数
	//破坏封装性 尽量少用
	friend void printStaffInfo(Staff &staff);
private:
	int ID;
	char name[20];
	char pwd[20];
	int role;
protected:
};

#endif

CStaff.cpp：

#include"CStaff.h"
#include<iostream>
using namespace std;
 
//不存在对象当中 是所有对象都能够公共访问的
//独立于对象 存在在类当中的
int Staff::num = 1000;//静态成员的初始化
 
Staff::Staff()
{
	Staff::num++;
}
 
Staff::Staff(int id,char *name,char *pwd,int prole)
{
	this->ID = id;
	strcpy(this->name,name);
	strcpy(this->pwd,pwd);
	this->role = prole;
    Staff::num++;
}
 
Staff::~Staff()
{
 
}

main.cpp：

#include<iostream>
using namespace std;
#include"CStaff.h"

//友元函数访问员工类的数据成员
void printStaffInfo(Staff &staff)
{
	cout<<"id = "<<staff.ID<<endl;
	cout<<"name = "<<staff.name<<endl;
	cout<<"pwd = "<<staff.pwd<<endl;
	cout<<"role = "<<staff.role<<endl;
}

int main()
{
  //在类外部定义一个函数：打印用户信息
	Staff s1(1001,"admin","123456",1);
	printStaffInfo(s1);
	//id = 1001
    //name = admin
    //pwd = 123456
    //role = 1
}

二：友元类

如窗口基类 访问 控件基类 (在控件基类中 写入 窗口基类的友元)

friend class CWinBase;  //类的声明  可以通过友元类（访问类外） 但破坏封装性了
int CWinBase::WinRun()
{
	int i=0,key=0;
	for(i=0;i<this->ctrlCount;i++)
	{
		if(this->ctrlArr[i]->ctrlType==EDIT||this->ctrlArr[i]->ctrlType==BUTTON)
		{
			CTools::gotoxy(this->ctrlArr[i]->startX+2,this->ctrlArr[i]->startY+1);
			break;
		}
	}
}

使用友元类，就可以不用写get方法，但是却会破坏面向对象程序设计的封装性，因此最好还是写get方法提供类外访问的接口

三：运算符重载

以复数为例，示例如下

CComplex.h：

#ifndef CCOMPLEX_H
#define CCOMPLEX_H

class CComplex
{
public:
	CComplex();//构造
	CComplex(int a,int b);//带参
	~CComplex();//析构
	void print();
	CComplex operator+(CComplex &complex);  //隐式传参 this指针 a+b
	CComplex operator++(int);  //int作为区分  后置++  i++
	CComplex& operator++();    //             前置++  ++i
	friend CComplex operator*(CComplex &c1,CComplex &c2);
protected:
private:
	int real;  //实部
	int imag;  //虚部
};

#endif

CComplex.cpp：

#include"CComplex.h"
#include<iostream>
using namespace std;

CComplex::CComplex()//构造
{
	this->real = 10;
	this->imag = 20;
}

CComplex::CComplex(int a,int b)//带参
{
	this->real = a;
	this->imag = b;
}

CComplex::~CComplex()
{

}

CComplex CComplex::operator+(CComplex &complex)//双面运算符+
{
	CComplex tmp;
	//this 指针
	tmp.real = this->real + complex.real;
	tmp.imag = this->imag + complex.imag;
	return tmp;
}

void CComplex::print()
{
	cout<<this->real<<"+"<<this->imag<<"j"<<endl;
	//1+2j + 3+4j  = 4+4j
}

CComplex CComplex::operator++(int)//单目后置++
{
	//先使用值 再自增
	CComplex tmp;
	tmp.real = this->real;
	tmp.imag = this->imag;
	this->real++;
	this->imag++;
	return tmp;
}

CComplex& CComplex::operator++()//单目前置++
{
	this->real++;
	this->imag++;
	return *this;
}

main.cpp：

a. 类成员函数实现双目运算符+的重载

#include<iostream>
using namespace std;
#include"CComplex.h"

int main()
{
	CComplex c1,c3;
	CComplex c2(1,2);
	//类成员函数实现 双目运算符+的重载
	c3 = c1 + c2;
	c3.print();//11+22j	
}

b. 类成员函数实现单目运算符重载  i++ 单目后置++

#include<iostream>
using namespace std;
#include"CComplex.h"

int main()
{
	CComplex c1,c3;
	CComplex c2(1,2);
	//类成员函数实现单目运算符重载  i++ 
    //先打印 在自增
    (c1++).print();  //10+20j
    c1.print();      //11+21j
}

c. 类成员函数实现单目运算符重载  ++i 单目前置++

#include<iostream>
using namespace std;
#include"CComplex.h"

int main()
{
	CComplex c1,c3;
	CComplex c2(1,2);
	//类成员函数实现单目运算符重载  ++i 前置++ 
    //先自增  再打印
    (++c1).print();  //11+21j
    c1.print();      //11+21j
}

d. 单目后置++ 显式调用

#include<iostream>
using namespace std;
#include"CComplex.h"

int main()
{
//	CComplex c1;
	CComplex c2(1,2);
   	(c2.operator ++(0)).print();  //1+2j
	c2.print();                   //2+3j
}

e. 单目前置++ 显式调用

#include<iostream>
using namespace std;
#include"CComplex.h"

int main()
{
	CComplex c1;
//	CComplex c2(1,2);
    (c1.operator++()).print(); //11+21j
    c1.print();                //11+21j
}

f. 类的友元函数实现运算符*重载  【实部*实部 虚部*虚部】

#include<iostream>
using namespace std;
#include"CComplex.h"

//类的友元函数实现运算符*重载  实部*实部 虚部*虚部
CComplex operator*(CComplex &c1,CComplex &c2)
{
	CComplex tmp;
	tmp.real = c1.real * c2.real;
	tmp.imag = c1.imag * c2.imag;
	return tmp;
}

int main()
{
	CComplex c1,c3;
	CComplex c2(1,2);
	//类成员函数实现 双目运算符*的重载
	c3 = c1 * c2;
    c3.print();  //10+40j
}

四：= 运算符重载

调用拷贝构造函数的情况：
1. 通过一个已经存在的对象去创造一个新的对象 此时会调用这个新对象的拷贝构造函数
2. 当一个对象作为函数实参传入时 此时会调用形参的拷贝构造函数
3. 当函数的返回值是一个对象时 此时接收这个函数返回值的对象会调用拷贝构造函数


从上面的情况 可以总结出：
当一个已经构造好了的对象去赋值给一个还未构造的对象，此时就会调用这个还未构造的对象的拷贝构造函数    产生的结果就是会有新的对象产生

CComplex c4 = c1;

= 运算符重载 示例如下

CComplex.h：

#ifndef CCOMPLEX_H
#define CCOMPLEX_H

class CComplex
{
public:
	CComplex();
	CComplex(int a,int b,char* word);
	void print();
	~CComplex();
	CComplex operator+(CComplex &complex);  //双面+
	CComplex operator++(int);               //单目后置++
	CComplex& operator++();                 //单目前置++
	friend CComplex operator*(CComplex &c1,CComplex &c2);//类的友元函数实现运算符*重载
	CComplex& operator = (CComplex &c1);    //=运算符重载
protected:
private:
	int real;  //实部
	int imag;  //虚部
	char *p;   //字符串
};

#endif

CComplex.cpp：

#include"CComplex.h"
#include<iostream>
using namespace std;
#include<stdlib.h>

CComplex::CComplex()
{
	this->real = 10;
	this->imag = 20;
	this->p = new char[20];//开空间
	memset(p,0,20);//初始化
}

CComplex::CComplex(int a,int b,char* word)
{
	this->real = a;
	this->imag = b;
	this->p = new char[20];//开空间
	memset(p,0,20);//初始化
	strcpy(p,word);//赋值
}

CComplex CComplex::operator+(CComplex &complex)//双面+
{
	CComplex tmp;
	//this 指针
	tmp.real = this->real + complex.real;
	tmp.imag = this->imag + complex.imag;
	return tmp;
}

void CComplex::print()
{
	cout<<this->real<<"+"<<this->imag<<"j"<<endl;
	//1+2j + 3+4j  = 4+4j
	cout<<this->p<<endl;
}

CComplex CComplex::operator++(int)//单目后置++
{
	//先使用值 再自增
	CComplex tmp;
	tmp.real = this->real;
	tmp.imag = this->imag;
	this->real++;
	this->imag++;
	return tmp;
}

CComplex& CComplex::operator++()  //单目前置++
{
	this->real++;
	this->imag++;
	return *this;
}

CComplex::~CComplex()
{
}

CComplex& CComplex::operator = (CComplex &c1)//= 运算符重载
{
	this->real = c1.real;
	this->imag = c1.imag;
	this->p = new char[20];//开空间
	memset(p,0,20);//初始化
	strcpy(p,c1.p);//赋值
	return *this;  //引用返回值
}

main.cpp：

#include<iostream>
using namespace std;
#include"CComplex.h"

int main()
{
//实现  =运算符 的重载
	CComplex c1;
	CComplex c2(1,2,"hello");
//两个对象都是已经创建好了的
	c1 = c2;
    c1.print();//1+2j   hello
}

对于拷贝构造函数 和 = 运算符重载 ，做好区分： 

= 运算符重载：两个对象都是已经创建好了的

拷贝构造函数:  一个已经构造好了的对象去赋值给一个还未构造的对象

chenruhan_QAQ_
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++ demo，重载运算符，友元函数的实现
01-24
c++ demo，重载运算符，友元函数的实现
C++类：运算符重载，友元函数，状态成员、类的转换
CYFS3的博客
06-05 413
C++类：运算符重载，友元函数，状态成员、类的转换
c++入门学习⑥——友元和运算符重载
最新发布
2301_79328557的博客
02-19 786
类做友元 注意先声明building然后再定义朋友类，再定义建筑物类，再利用构造函数初始化朋友类，创建类对象，然后构造函数赋初值给类属性，重要的是，要先定义朋友类，再定义建筑类，不然程序会出错的。 对于内置的数据类型，编译器知道如何运算。而c++中有自定义数据类型，程序往往不知道如何去计算自定义数据类型因此需要自己进行运算符重载，使用关键字operate先新建一个自定义数据类型——类，然后对于类对象的直接相加计算机不知道如何计算——》需要进行加号运算符重载 全局函数重载+运算符，这里是把两个类对
解析C++中不能重载为友元函数的四个运算符
12-26
C++规定有四个运算符 =, ->, [], ()不可以是全局域中的重载（即不能重载为友员函数），这是为什么呢？现在先说说赋值运算符“=”的重载C++规定赋值运算符“=”只能重载为类的非静态成员函数，而不可以重载为类的友元函数。不能重载为类的静态成员应该比较容易理解，因为静态成员函数是属于整个类的，不是属于某个对象的，它只能去操作类静态数据成员。而赋值运算符“=”是基于对象操作的。那么为什么赋值运算符不可以重载为类的友元函数？像同样都是双目运算符的+为什么它就可以呢？ 在讨论这问题之前，先看一测试的程序： 代码如下:#include using namespace std;
C++运算符重载以及友元
请叫我AXin
12-08 1098
今天继续复习了C++，之前都没认真看过《C++ primer plus》，非常详细的一本书，而且适合查阅与学习。 1.重载 在C++中有很多运算符可以被应用到类与类之间、类与基本类型之间等，我们把这种方法叫做运算符重载，比如有两个类X的实例A和B，将加号（+）在该类中重载以后就能直接使用A+B这样的式子。 下面用《C++ primer plus》中一个重载的例子来说明. 这个例子是一个
C++之友元函数
热门推荐
m0_59052131的博客
10-29 2万+
友元函数：友元函数的定义、分类、三种友元函数举例，代码注意点，判断谁是谁的友元函数或类
C++友元函数
weixin_59179454的博客
10-29 4976
1、 友元函数不是类的成员函数，在函数体中访问对象的成员，必须用对象名加运算符"."加对象成员名。但友元函数可以访问类中的所有成员，一般函数只能访问类中的公有成员。2、友元函数不受类中的访问权限关键字限制，可以把它放在类的公有、私有、保护部分，但结果都一样。3、某类的友元函数的作用域并非该类作用域。如果该友元函数是另一类的成员函数，则其作用域为另一类的作用域，否则与一般函数相同。
【C++】友元函数 ( 友元函数简介 | 友元函数声明 | 友元函数语法 | 友元函数声明不受访问控制限制 | 友元函数参数要求 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
09-27 4732
一、友元函数简介 二、友元函数声明 1、友元函数语法 2、友元函数声明不受访问控制限制 3、友元函数参数要求 4、友元函数示例 三、完整代码示例 - 友元函数
C++ 详解友元函数
yn_zi的博客
06-24 3179
友元类（Friend Class）是C++中的另一个重要概念，它允许一个类将另一个类声明为自己的友元，从而使得被声明为友元的类可以访问该类的私有成员。比如在只声明B是A友元的情况下，B可以访问A的私有成员，但是A却不可以访问B的私有成员，即A不是B的友元。友元函数提供了一种在需要时访问类的私有成员的机制，但应该慎重使用，因为过多的友元函数可能破坏类的封装性。(1)友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。:如果B是A的友元，C是B的友元，则不能说明C是A的友元。
【C++入门】友元函数详解（定义、实现、优缺点）
weixin_42031299的博客
11-05 9780
(1)在类中用friend关键字去声明函数/类，则这个函数/类就会变成友元函数/友元类；(2)友元函数/友元类的声明位置没有要求，可以在private、protected、public权限区，效果都是一样的；(3)友元函数/友元类是单向的，A在B类中被声明为友元函数/友元类，表示A是B的友元函数/友元类，但B不是A的友元类函数/友元类；(4)友元函数/友元类具有和类成员一样的权限，可以访问protected和private权限的成员，但不是类的成员；
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++学习记录————友元与重载
dshycorz的博客
06-10 444
类实现了数据的隐藏与封装，类的数据成员一般定义为私有成员，仅能通过类的成员函数才能读写。如果数据成员定义为公共的，则又破坏了封装性。但是某些情况下，需要频繁读写类的数据成员，特别是在对某些成员函数多次调用时，由于参数传递、类型检查和安全性检查等都需要时间开销，而影响程序的运行效率。友元主要是用于运算符重载。
c++运算符重载和友元函数
liuwei271551048的专栏
04-20 2244
1.运算符重载：例如+本来是用于两个整数或者两个浮点数进行相加的，如果我将+重载之后，可将+用于时间对象的相加，比如一个时间对象为1小时50分，一个时间对象为2小时30分，则这样两个时间对象通过重载的+可以直接进行运算得到4小时20分。 2.重载+使得+能直接计算时间和的方法： 只需要在operator后加上运算符号作为函数名即可： class Time { private:
（B站黑马C++）友元 + 运算符重载
IT OR 考公？
05-31 783
C++语法糖，黑马C++，1.5倍速跟着敲
c++第十二天（友元和运算符重载）
open_python的博客
11-06 868
友元和函数重载
关于C++中的友元函数的总结
weixin_33830216的博客
11-22 1430
1.友元函数的简单介绍 1.1为什么要使用友元函数 在实现类之间数据共享时，减少系统开销，提高效率。如果类A中的函数要访问类B中的成员（例如：智能指针类的实现），那么类A中该函数要是类B的友元函数。具体来说：为了 使其他类的成员函数直接访问该类的私有变量。即：允许外面的类或函数去访问类的私有变量和保护变量，从而使两个类共享同一函数。 实际上具体大概有下面两种情况需要使用友元函数：（1）...
C++——友元（友元函数、友元类和友元成员函数详解）
qq_57737603的博客
08-18 2732
友元函数是在一个类中声明的一个非成员函数，但在类的内部声明该函数为友元。这意味着该函数可以访问该类的私有成员，包括私有变量和私有函数。友元函数的声明通常位于类的声明中，但其实现则位于类外部。1、友元函数：通过friend+普通函数友元函数是在一个类中声明的非成员函数，但在类的内部声明该函数为友元。这使得该函数可以访问该类的私有成员。private:public:// 声明友元函数// Getter函数// 友元函数实现
C++ —— 友元函数
柚咖小窝
03-27 8626
C++ 控制对类对象私有部分的访问。通常，公有类方法提供唯一的访问途径，但是有时候这种限制太严格，以致于不适合特定的编程问题。在这种情况下，C++ 提供了另外一种形式的访问权限：友元。友元有三种形式 —— 友元函数、友元成员函数、友元类。这里只介绍友元函数。 当函数被声明为类的友元函数，可以赋予该函数与类的成员函数相同的访问权限。 为什么需要友元函数 在为类重载二元运算符时常常需要用到友元函数。 例如，为一个时间类 Time 重载乘法运算符，使其可以乘以一个实数，部分代码如下所示： class Time {
为什么使用友元函数运算符重载
12-23
使用友元函数运算符重载的原因是为了能够访问类的私有成员。运算符函数需要访问类对象中的成员，如果运算符函数不是类的友元函数，它就没有权限访问类的私有成员。因此，将运算符函数定义为友元函数可以解决这个问题。 另外，友元函数的使用确实会破坏类的封装性，因为它可以直接访问类的私有成员。为了保持类的封装性，一般将单目运算符重载为成员函数，将双目运算符重载为友元函数。这样可以在一定程度上限制对类的私有成员的访问。 总结起来，使用友元函数运算符重载的主要原因是为了能够访问类的私有成员，但同时也需要注意保持类的封装性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

chenruhan_QAQ_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值