c++ 友元 运算符重载详解

已于 2023-11-30 08:20:14 修改
阅读量1.8k 收藏 2
点赞数 1
文章标签： c++ 单片机
于 2023-08-19 01:15:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72703340/article/details/132374095
版权

友元

c++是面向对象的，目的之一：封装

封装：

优点之一，就是安全。

缺点：在某些特殊的场合，不是很方便。

华为与IBM 40亿的咨询故事

IBM需要对华为各级部门做深度咨询分析，

为了提高咨询效率，由任正非直接授权，直接获取各部门的所有权限。

使用前提：

某个类需要实现某种功能，但是这个类自身，因为各种原因，无法自己实现。

需要借助于“外力”才能实现。

友元函数

使用全局函数作为友元函数

需求：

计算机和计算机的升级

Computer.h

#pragma once
#include <string>
​
class Computer
{
public:
    Computer();
​
    // 使用全局函数作为友元函数 友元函数可以访问类的所有数据成员
    friend void upgrade(Computer* computer);
​
    std::string description();
​
private:
    std::string cpu; //CPU芯片
};

computer.cpp

#include "Computer.h"
#include <sstream>  
​
Computer::Computer()
{
    cpu = "i7";
}
​
std::string Computer::description()
{
    std::stringstream  ret;
    ret << "CPU:" << cpu;
    return ret.str();
}

main.cpp

#include <stdio.h>
#include <iostream>
#include <Windows.h>
​
#include "Computer.h"
​
void upgrade(Computer* computer) {
    computer->cpu = "i9";  //直接访问对象的私有数据成员！！！
}
​
int main(void) {
    Computer shanxing;
    std::cout << shanxing.description() << std::endl;
    
    upgrade(&shanxing);
​
    std::cout << shanxing.description() << std::endl;
​
    system("pause");
    return 0;
}

使用类的成员函数作为友元函数

需求：

计算机和计算机的升级

computer.h

#pragma once
#include <string>
#include <iostream>
#include  <sstream>
#include "Computerservice.h"
using namespace std;
​
class Computer
{
public:
    Computer();
    string description();
    friend void Computerservice::upgrade(Computer* computer);
    //friend void upgrade(Computer* computer);//把外部的全局函数申明为这个类的友元函数
private:
    string cpu;
     
};
​

 

computerservice.h
 

#pragma once
class Computer;
​
class Computerservice
{
public:
    void upgrade(Computer* computer);
};
 

computer.cpp
​
​
 

#include "Computer.h"
​
Computer::Computer()
{
    this->cpu = "i7";
}
​
string Computer::description()
{
    stringstream des;
    des << "CPU" << cpu;
    return des.str();
​
    
}
​
 

 

computerservice.cpp
 

#include "Computerservice.h"
#include "Computer.h"
​
void Computerservice::upgrade(Computer* computer)
{
    this->cpu = "i9";
}
 

​
 

main.cpp
 

#include "Computer.h"
#include <iostream>
#include "Computerservice.h"
​
//void upgrade(Computer * computer) {
//  computer->cpu = "i9";
//}
​
int main(void) {
    Computer computer;
    Computerservice serviece;
    cout << computer.description() << endl;
    serviece.upgrade(&computer);
    cout << computer.description() << endl;
    return 0;
}
 

功能上，这两种形式，都是相同，应用场合不同。
 

一个是，使用普通的全局函数，作为自己的朋友，实现特殊功能。
 

一个是，使用其他类的成员函数，作为自己的朋友，实现特殊功能。
 

友元类
 

友元类的作用
 

如果把A类作为B类的友元类，
 

那么A类的所有成员函数【在A类的成员函数内】，就可以直接访问【使用】B类的私有成员。
 

即，友元类可以直接访问对应类的所有成员！！！
 

Demo
 

Computer.h
 

#pragma once
#include <string>
#include <iostream>
#include  <sstream>
#include "Computerservice.h"
using namespace std;
class ComputerService;

class Computer
{
public:
	friend class Computerservice;
	Computer();
	string description();
	
private:
	string cpu;
	 
};

Computer.cpp

#include "Computer.h"
#include "Computerservice.h"
Computer::Computer()
{
	this->cpu = "i7";
}

string Computer::description()
{
	stringstream des;
	des << "CPU" << cpu;
	return des.str();

	
}
 

ComputerService.h
 

#pragma once
class Computer;



class Computerservice
{
public:
	void upgrade(Computer* computer);
	void clear(Computer* computer);
	void kill(Computer* computer);
};
 

ComputerService.cpp
 

#include "Computerservice.h"
#include "Computer.h"

 

void Computerservice::upgrade(Computer* computer)
{
	computer->cpu = "i9";
}

void Computerservice::clear(Computer* computer)
{
	cout << "正在对电脑执行清理[CPU:" << computer->cpu << "]" < endl;
}

void Computerservice::kill(Computer* computer)
{
	cout << "杀毒" << endl;
}
 

main.cpp
 

#include "Computer.h"
#include <iostream>
#include "Computerservice.h"


int main(void) {
	Computer computer;
	Computerservice serviece;
	cout << computer.description() << endl;
	serviece.upgrade(&computer);
	cout << computer.description() << endl;
	serviece.clear(&computer);
	serviece.kill(&computer);
	return 0;
}
 

使用注意
 

友元类，和友元函数，使用friend关键字进行声明即可，与访问权限无关，
 

所以，可以放在private/pulic/protected任意区域内。
 

万物可运算-运算符重载
 

为什么要使用运算符重载
 

C/C++的运算符，支持的数据类型，仅限于基本数据类型。
 

 

问题：一头牛+一头马 = ？（牛马神兽？）
 

一个圆 +一个圆 = ？ （想要变成一个更大的圆）
 

一头牛 – 一只羊 = ？ (想要变成4只羊，原始的以物易物：1头牛价值5只羊)
 

 

解决方案：使用运算符重载
 

运算符重载基本用法
 

方式1-使用成员函数重载运算符
 

使用成员函数重载运算符
 

需求： // 规则：
 

// 一斤牛肉：2斤猪肉
 

// 一斤羊肉：3斤猪肉
 

Cow.h
 

#pragma once

class Pork;
class Goat;

class Cow
{
public:
	Cow(int weight);

	// 参数此时定义为引用类型，更合适，避免拷贝
	Pork operator+(const Cow& cow);  //同类型进行运算，很频繁

	Pork operator+(const Goat& goat); //不同类型进行运算，比较少见
private:
	int weight = 0;
};



 

Cow.cpp
 

#include "Cow.h"
#include "Pork.h"
#include "Goat.h"

Cow::Cow(int weight)
{
	this->weight = weight;
}


// 规则：
// 一斤牛肉：2斤猪肉
// 一斤羊肉：3斤猪肉
Pork Cow::operator+(const Cow &cow)
{
	int tmp = (this->weight + cow.weight) * 2;
	return Pork(tmp);
}

Pork Cow::operator+(const Goat& goat)
{
	// 不能直接访问goat.weight
	//int tmp = this->weight * 2 + goat.weight * 3;
	int tmp = this->weight * 2 + goat.getWeight() * 3;
	return Pork(tmp);
}



 

Goat.cpp
 

 
 
#include "Goat.h"

Goat::Goat(int weight) {
	this->weight = weight;
}

int Goat::getWeight(void) const
{
	return weight;
}
 
 
 

 

 

Goat.h
 

 
 
#pragma once
class Goat
{
public:
	Goat(int weight);
	int getWeight(void) const;
private:
	int weight = 0;
};



 
 
 

 

Pork.h
 

#pragma once
#include <iostream>

class Pork
{
public:
	Pork(int weight);
	std::string  description(void);

private:
	int weight = 0;
};
 

 

 

Pork.cpp
 

#include "Pork.h"
#include <sstream>

Pork::Pork(int weight)
{
	this->weight = weight;
}

std::string Pork::description(void)
{
	std::stringstream ret;
	ret << weight << "斤猪肉";
	return ret.str();
}
 

 

main.cpp
 

 
 
#include <iostream>
#include "Pork.h"
#include "Cow.h"
#include "Goat.h"

int main(void) {
	Cow c1(100);
	Cow c2(200);

	// 调用c1.operator+(c2);
	//相当于：Pork p = c1.operator+(c2);
	Pork p = c1 + c2;
	std::cout << p.description() << std::endl;

	Goat g1(100);
	p = c1 + g1;
	std::cout << p.description() << std::endl;
	
	system("pause");
	return 0;
}
 
 
 

 

方式二 - 使用非成员函数【友元函数】重载运算符
 

Cow.h
 

#pragma once

class Pork;
class Goat;

class Cow
{
public:
	Cow(int weight);

	// 有友元函数实现运算符重载
	friend Pork operator+(const Cow& cow1, const Cow& cow2);
	friend Pork operator+(const Cow& cow1, const Goat& goat);
private:
	int weight = 0;
};
 

main.cpp
 

 

其他文件不变
 

两种方式的区别
 

区别：
 

  1.  
    使用成员函数来实现运算符重载时，少写一个参数，因为第一个参数就是this指针。
     
 

 

两种方式的选择：
 

  1.  
    一般情况下，单目运算符重载，使用成员函数进行重载更方便（不用写参数）
     
  2.  
    一般情况下，双目运算符重载，使用友元函数
     
    #include <iostream>
#include "Pork.h"
#include "Cow.h"
#include "Goat.h"

Pork operator+(const Cow &cow1, const Cow &cow2)
{
	int tmp = (cow1.weight + cow2.weight) * 2;
	return Pork(tmp);
}

Pork operator+(const Cow& cow1, const Goat& goat)
{
	int tmp = cow1.weight * 2 + goat.getWeight() * 3;
	return Pork(tmp);
}

int main(void) {
	Cow c1(100);
	Cow c2(200);
	Goat g1(100);

	Pork p = c1 + c2;
	std::cout << p.description() << std::endl;

	p = c1 + g1;  // 思考：如何实现：p = g1 + c1;
	std::cout << p.description() << std::endl;

	system("pause");
	return 0;
}
     
    更直观
     
 

方便实现a+b和b+a相同的效果，成员函数方式无法实现。
 

例如： 100 + cow; 只能通过友元函数来实现
 

cow +100; 友元函数和成员函数都可以实现
 

 
 
特殊情况：
 
 
（1） = （） [ ] -> 不能重载为类的友元函数！！！（否则可能和C++的其他规则矛盾），只能使用成员函数形式进行重载。
 
 
（2）如果运算符的第一个操作数要求使用隐式类型转换，则必须为友元函数（成员函数方式的第一个参数是this指针）
 
 
 

 

注意：
 

同一个运算符重载， 不能同时使用两种方式来重载，会导致编译器不知道选择哪一个（二义性）
 

运算符重载的禁区和规则
 

 
 
  1.  
    为了防止对标准类型进行运算符重载，
     
    C++规定重载运算符的操作对象至少有一个不是标准类型，而是用户自定义的类型
     
    比如不能重载 1+2
     
    但是可以重载 cow + 2 和 2 + cow // cow是自定义的对象
     
    2.不能改变原运算符的语法规则， 比如不能把双目运算符重载为单目运
     
  2.  
    不能改变原运算符的优先级
     
    4.不能创建新的运算符，比如 operator*就是非法的, operator是可以的
     
  3.  
    不能对以下这四种运算符，使用友元函数进行重载
     
    = 赋值运算符，（）函数调用运算符，[ ]下标运算符，->通过指针访问类成员
     
  4.  
    不能对禁止重载的运算符进行重载
     
 

 

不能被重载的运算符
 

成员访问.
域运算：：
内存长度运算sizeof
三目运算? : :
预处理#
 

可以被重载的运算符
 

双目运算符+ - * / %
关系运算符== != < <= > >=
逻辑运算符&& || !
单目运算符+(正号) -（负号） *（指针） &（取地址） ++ --
位运算& | ~ ^ <<（左移） >>（右移）
赋值运算符= += -= *= /= %= &= |= ^= <<= >>=
内存分配new delete new[ ] delete[ ]
其他( ) 函数调用-> 成员访问 [ ] 下标， 逗号
 

重载运算符实例
 

重载赋值运算符=
 

Boy.h
 

#pragma once
#include <string>
using namespace std;
class Boy
{
public:
	Boy(const char* name = NULL, int age = 0,int salary = 0,int darkHorse = 0);
	~Boy();
	string description();
	Boy& operator= (const Boy & boy);
private:
	char* name;
	int age;
	int salary;
	int darkHorse;//潜力系数
	unsigned int id;//编号
	static int LAST_ID;
	
};
 

 

Boy.cpp
 

#include "Boy.h"
#include <string.h>
#include <sstream>
using namespace std;
int Boy::LAST_ID = 0;

Boy::Boy(const char* name, int age, int salary, int darkHorse)
{
	if (!name) {
		;name = "未命名";
	}
	
	this->name = new char[strlen(name) + 1];
	strcpy_s(this->name, strlen(name) +1, name);
	this->age = age;
	this->salary = salary;
	this->darkHorse = darkHorse;
	this->id = ++LAST_ID;

}

Boy::~Boy()
{
	if (name) {
		delete name;
	}
}

string Boy::description()
{
	stringstream des;
	des << "ID:" << id << "\t姓名:" << name << "\t年龄" << age << "\t薪资" << salary << "/t黑马系数" << darkHorse;
	return des.str();
}

Boy& Boy::operator=(const Boy& boy)
{
	// TODO: 在此处插入 return 语句
	if (name) {
		delete name;
	}
	this->name = new char[strlen(boy.name) + 1];
	strcpy_s(this->name, strlen(boy.name) + 1,boy.name);
	this->age = boy.age;
	this->darkHorse = boy.darkHorse;
	this->salary = boy.salary;
	//this->id
	return *this;//返回这个对象
	
}
 

 

 

Main.cpp
 

#include <iostream>
#include "boy.h"

int main(void) {
	Boy boy1("lucifer", 16, 10000, 10);
	Boy boy2, boy3;

	std::cout << boy1.description() << std::endl;
	std::cout << boy2.description() << std::endl;
	std::cout << boy3.description() << std::endl;

	boy3 = boy2 = boy1;
	std::cout << boy2.description() << std::endl;
	std::cout << boy3.description() << std::endl;

	system("pause");
	return 0;
}
 

重载运算符> < ==
 

Boy.h 的方法加入
 

public:		
	bool operator>(const Boy& boy);
	bool operator<(const Boy& boy);
	bool operator==(const Boy& boy);
private:
	int power() const; //综合能力值
 

Boy.cpp
 

bool Boy::operator>(const Boy& boy)
{
	// 设置比较规则：
	// 薪资 * 黑马系数 + (100-年龄）*100
	if (power() > boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator<(const Boy& boy)
{
	if (power() < boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator==(const Boy& boy)
{
	if (power() == boy.power()) {
		return true;
	}
	else {
		return false;
	}
}
 

下标运算符重载[ ]
 

Boy.h
 

#pragma once
#include <string>

class Boy
{
public:
	Boy(const char* name=NULL, int age=0, int salary=0, int darkHorse=0);
	~Boy();

	Boy& operator=(const Boy& boy);

	bool operator>(const Boy& boy);
	bool operator<(const Boy& boy);
	bool operator==(const Boy& boy);

	int operator[](std::string index);
	int operator[](int index);
	
	std::string description(void);
private:
	char* name;
	int age;
	int salary;
	int darkHorse; //黑马值，潜力系数
	unsigned int id; // 编号
	static int LAST_ID;

	int power() const; //综合能力值
};
 

Boy.cpp
 

#include "boy.h"
#include <string.h>
#include <sstream>

int Boy::LAST_ID = 0;  //初始值是0

Boy::Boy(const char* name, int age, int salary, int darkHorse)
{
	if (!name) {
		name = "未命名";
	}

	this->name = new char[strlen(name) + 1];
	strcpy_s(this->name, strlen(name)+1, name);

	this->age = age;
	this->salary = salary;
	this->darkHorse = darkHorse;
	this->id = ++LAST_ID;
}

Boy::~Boy()
{
	if (name) {
		delete name;
	}
}

Boy& Boy::operator=(const Boy& boy)
{
	if (name) {
		delete name;  //释放原来的内存
	}
	name = new char[strlen(boy.name) + 1]; //分配新的内存
	strcpy_s(name, strlen(boy.name)+1, boy.name);

	this->age = boy.age;
	this->salary = boy.salary;
	this->darkHorse = boy.darkHorse;
	//this->id = boy.id;  //根据需求来确定是否要拷贝id
	return *this;
}

bool Boy::operator>(const Boy& boy)
{
	// 设置比较规则：
	// 薪资 * 黑马系数 + (100-年龄）*100
	if (power() > boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator<(const Boy& boy)
{
	if (power() < boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator==(const Boy& boy)
{
	if (power() == boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

int Boy::operator[](std::string index)
{
	if (index == "age") {
		return age;
	}
	else if (index == "salary") {
		return salary;
	}
	else if (index == "darkHorse") {
		return darkHorse;
	}
	else if (index == "power") {
		return power();
	}
	else {
		return -1;
	}
}

int Boy::operator[](int index)
{
	if (index == 0) {
		return age;
	}
	else if (index == 1) {
		return salary;
	}
	else if (index == 2) {
		return darkHorse;
	}
	else if (index == 3) {
		return power();
	}
	else {
		return -1;
	}
}

std::string Boy::description(void)
{
	std::stringstream ret;
	ret << "ID:" << id << "\t姓名:" << name << "\t年龄:" << age << "\t薪资:"
		<< salary << "\t黑马系数:" << darkHorse;
	return ret.str();
}

int Boy::power() const
{
	// 薪资* 黑马系数 + (100 - 年龄） * 1000
	int value = salary * darkHorse + (100 - age) * 100;
	return value;
}
 

main.cpp
 

#include <iostream>
#include "boy.h"

int main(void) {
	Boy boy1("Rock", 38, 58000, 5);
	Boy boy2("Jack", 25, 50000, 10);
	
	std::cout << "age:" << boy1["age"] << std::endl;
	std::cout << "salary:" << boy1["salary"] << std::endl;
	std::cout << "darkHorse:" << boy1["darkHorse"] << std::endl;
	std::cout << "power:" << boy1["power"] << std::endl;

	std::cout << "[0]:" << boy1[0] << std::endl;
	std::cout << "[1]:" << boy1[1] << std::endl;
	std::cout << "[2]:" << boy1[2] << std::endl;
	std::cout << "[3]:" << boy1[3] << std::endl;

	system("pause");
	return 0;
}
 

输入输出的重载<< >>
 

为了更方便的实现复杂对象的输入和输出。
 

方式1（使用成员函数）
 

不推荐，该方式没有实际意义
 

Boy.h
 

#pragma once
#include <string>
#include <iostream>

using namespace std;

class Boy
{
public:
	Boy(const char* name = NULL, int age = 0, int salary = 0, int darkHorse = 0);
	~Boy();

	Boy& operator=(const Boy& boy);

	bool operator>(const Boy& boy);
	bool operator<(const Boy& boy);
	bool operator==(const Boy& boy);

	int operator[](std::string index);
	int operator[](int index);

	ostream& operator<<(ostream& os) const;

	std::string description(void);

private:
	char* name;
	int age;
	int salary;
	int darkHorse; //黑马值，潜力系数
	unsigned int id; // 编号
	static int LAST_ID;

	int power() const; //综合能力值
};
 

boy.cpp
 

#include "boy.h"
#include <string.h>
#include <sstream>

int Boy::LAST_ID = 0;  //初始值是0

Boy::Boy(const char* name, int age, int salary, int darkHorse)
{
	if (!name) {
		name = "未命名";
	}

	this->name = new char[strlen(name) + 1];
	strcpy_s(this->name, strlen(name) + 1, name);

	this->age = age;
	this->salary = salary;
	this->darkHorse = darkHorse;
	this->id = ++LAST_ID;
}

Boy::~Boy()
{
	if (name) {
		delete name;
	}
}

Boy& Boy::operator=(const Boy& boy)
{
	if (name) {
		delete name;  //释放原来的内存
	}
	name = new char[strlen(boy.name) + 1]; //分配新的内存
	strcpy_s(name, strlen(boy.name) + 1, boy.name);

	this->age = boy.age;
	this->salary = boy.salary;
	this->darkHorse = boy.darkHorse;
	//this->id = boy.id;  //根据需求来确定是否要拷贝id
	return *this;
}

bool Boy::operator>(const Boy& boy)
{
	// 设置比较规则：
	// 薪资 * 黑马系数 + (100-年龄）*100
	if (power() > boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator<(const Boy& boy)
{
	if (power() < boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator==(const Boy& boy)
{
	if (power() == boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

int Boy::operator[](std::string index)
{
	if (index == "age") {
		return age;
	}
	else if (index == "salary") {
		return salary;
	}
	else if (index == "darkHorse") {
		return darkHorse;
	}
	else if (index == "power") {
		return power();
	}
	else {
		return -1;
	}
}

int Boy::operator[](int index)
{
	if (index == 0) {
		return age;
	}
	else if (index == 1) {
		return salary;
	}
	else if (index == 2) {
		return darkHorse;
	}
	else if (index == 3) {
		return power();
	}
	else {
		return -1;
	}
}

ostream& Boy::operator<<(ostream& os) const
{
	os << "ID:" << id << "\t姓名:" << name << "\t年龄:" << age << "\t薪资:"
		<< salary << "\t黑马系数:" << darkHorse;
	return os;
}

std::string Boy::description(void)
{
	std::stringstream ret;
	ret << "ID:" << id << "\t姓名:" << name << "\t年龄:" << age << "\t薪资:"
		<< salary << "\t黑马系数:" << darkHorse;
	return ret.str();
}

int Boy::power() const
{
	// 薪资* 黑马系数 + (100 - 年龄） * 1000
	int value = salary * darkHorse + (100 - age) * 100;
	return value;
}
 

mian.cpp
 

#include <iostream>
#include "boy.h"

int main(void) {
	Boy boy1("Rock", 38, 58000, 5);
	Boy boy2("Jack", 25, 50000, 10);
	
	// 调用： boy1.operator<<(cout);
	boy1 << cout;

	// 先调用 boy1.operator<<(cout)
	// 再调用 boy2.operator<<(cout)
	boy2 << (boy1 << cout);


	system("pause");
	return 0;
}
 

使用取来不方便
 

方式二（使用友元函数）
 

 

Boy.h
 

#pragma once
#include <string>
#include <iostream>

#define AGE_KEY			"age"
#define SALARY_KEY		"salary"
#define DARK_HORSE_KEY  "darkHorse"
#define POWER_KEY		"power"

typedef enum {
	AGE,
	SALARY,
	DARK_HORSE,
	POWER
}BOY_KEY_TYPE;

using namespace std;

class Boy
{
public:
	Boy(const char* name = NULL, int age = 0, int salary = 0, int darkHorse = 0);
	~Boy();

	Boy& operator=(const Boy& boy);

	bool operator>(const Boy& boy);
	bool operator<(const Boy& boy);
	bool operator==(const Boy& boy);

	// 下标运算符的重载
	int operator[](std::string index);
	int operator[](int index);

	// 该方式不适合
	//ostream& operator<<(ostream& os) const;

	friend ostream& operator<<(ostream& os, const Boy& boy);
	friend istream& operator>>(istream& is, Boy& boy);

	std::string description(void);
private:
	char* name;
	int age;
	int salary;
	int darkHorse; //黑马值，潜力系数
	unsigned int id; // 编号
	static int LAST_ID;

	int power() const; //综合能力值
};
 

 

 

Boy.cpp
 

#include "boy.h"
#include <string.h>
#include <sstream>

int Boy::LAST_ID = 0;  //初始值是0

Boy::Boy(const char* name, int age, int salary, int darkHorse)
{
	if (!name) {
		name = "未命名";
	}

	this->name = new char[strlen(name) + 1];
	strcpy_s(this->name, strlen(name) + 1, name);

	this->age = age;
	this->salary = salary;
	this->darkHorse = darkHorse;
	this->id = ++LAST_ID;
}

Boy::~Boy()
{
	if (name) {
		delete name;
	}
}

Boy& Boy::operator=(const Boy& boy)
{
	if (name) {
		delete name;  //释放原来的内存
	}
	name = new char[strlen(boy.name) + 1]; //分配新的内存
	strcpy_s(name, strlen(boy.name) + 1, boy.name);

	this->age = boy.age;
	this->salary = boy.salary;
	this->darkHorse = boy.darkHorse;
	//this->id = boy.id;  //根据需求来确定是否要拷贝id
	return *this;
}

bool Boy::operator>(const Boy& boy)
{
	// 设置比较规则：
	// 薪资 * 黑马系数 + (100-年龄）*100
	if (power() > boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator<(const Boy& boy)
{
	if (power() < boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator==(const Boy& boy)
{
	if (power() == boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

int Boy::operator[](std::string index)
{
	if (index == AGE_KEY) {
		return age;
	}
	else if (index == SALARY_KEY) {
		return salary;
	}
	else if (index == DARK_HORSE_KEY) {
		return darkHorse;
	}
	else if (index == POWER_KEY) {
		return power();
	}
	else {
		return -1;
	}
}

int Boy::operator[](int index)
{
	if (index == 0) {
		return age;
	}
	else if (index == 1) {
		return salary;
	}
	else if (index == 2) {
		return darkHorse;
	}
	else if (index == 3) {
		return power();
	}
	else {
		return -1;
	}
}

//ostream& Boy::operator<<(ostream& os) const
//{
//	os << "ID:" << id << "\t姓名:" << name << "\t年龄:" << age << "\t薪资:"
//		<< salary << "\t黑马系数:" << darkHorse;
//	return os;
//}

std::string Boy::description(void)
{
	std::stringstream ret;
	ret << "ID:" << id << "\t姓名:" << name << "\t年龄:" << age << "\t薪资:"
		<< salary << "\t黑马系数:" << darkHorse;
	return ret.str();
}

int Boy::power() const
{
	// 薪资* 黑马系数 + (100 - 年龄） * 1000
	int value = salary * darkHorse + (100 - age) * 100;
	return value;
}
 

 

Main.cpp
 

#include <iostream>
#include "Boy.h"

using namespace std;

ostream& operator<<(ostream& os, const Boy& boy) {
	os << "ID:" << boy.id << "\t姓名:" << boy.name << "\t年龄:" << boy.age << "\t薪资:"
		<< boy.salary << "\t黑马系数:" << boy.darkHorse;
	return os;
}

istream& operator>>(istream& is, Boy& boy)
{
	string name2;
	is >> name2 >> boy.age >> boy.salary >> boy.darkHorse;
	boy.name = (char*)malloc((name2.length()+1) * sizeof(char));
	strcpy_s(boy.name, name2.length() + 1, name2.c_str());
	return is;
}

int main(void) {
	Boy boy1("Rock", 38, 58000, 5);
	Boy boy2("Jack", 25, 50000, 10);

	cout << boy1 << endl;
	cin >> boy1;
	cout << boy1;
	
	system("pause");
	return 0;
}
 

 

 

重载-普通类型 =>类类型
 

 
 
调用对应的只有一个参数【参数的类型就是这个普通类型】的构造函数
 

 

 
 
需求： Boy boy1 = 10000; // 薪资 构造函数Boy(int);
 
 
Boy boy2 = "Rock" // 姓名 构造函数Boy(char *)
 

 

Boy.h
 

Boy(int salary);
	Boy(const char*);
 

Boy.cpp
 

Boy::Boy(int salary)
{
	const char* defaultName = "Unknow";

	this->name = new char[strlen(defaultName) + 1];
	strcpy_s(this->name, strlen(defaultName) + 1, defaultName);

	this->age =0;
	this->salary = salary;
	this->darkHorse = 0;
	this->id = ++LAST_ID;
}

Boy::Boy(const char* name)
{
	 
	this->name = new char[strlen(name) + 1];
	strcpy_s(this->name, strlen(name) + 1, name);

	this->age = 0;
	this->salary = 0;
	this->darkHorse = 0;
	this->id = ++LAST_ID;
}
 
 

重载类类型=> 普通类型
 

 
 
调用特殊的运算符重载函数，类型转换函数，不需要写返回类型
 
 
类型转换函数：operator 普通类型 ( )
 

 

 

需求：
 

 
 
Boy boy1(“Rock”, 28, 10000, 5);

int power = boy1; // power();

char *name = boy1; // “Rock”
 
 
 

 

Boy.h
 

#pragma once
#include <string>
#include <iostream>

#define AGE_KEY			"age"
#define SALARY_KEY		"salary"
#define DARK_HORSE_KEY  "darkHorse"
#define POWER_KEY		"power"

typedef enum {
	AGE,
	SALARY,
	DARK_HORSE,
	POWER
}BOY_KEY_TYPE;

using namespace std;

class Boy
{
public:
	Boy(const char* name , int age, int  , int darkHorse);
	Boy(int salary);
	Boy(const char*);
	~Boy();

	Boy& operator=(const Boy& boy);

	bool operator>(const Boy& boy);
	bool operator<(const Boy& boy);
	bool operator==(const Boy& boy);

	// 下标运算符的重载
	int operator[](std::string index);
	int operator[](int index);
	//类型运算符重载 不需要返回类型
	operator char* ()const;
	operator int()const;

	// 该方式不适合
	//ostream& operator<<(ostream& os) const;

	friend ostream& operator<<(ostream& os, const Boy& boy);
	friend istream& operator>>(istream& is, Boy& boy);

	std::string description(void);
private:
	char* name;
	int age;
	int salary;
	int darkHorse; //黑马值，潜力系数
	unsigned int id; // 编号
	static int LAST_ID;

	int power() const; //综合能力值
};
 

 

Boy.cpp
 

#include "boy.h"
#include <string.h>
#include <sstream>

int Boy::LAST_ID = 0;  //初始值是0

Boy::Boy(const char* name, int age, int salary, int darkHorse)
{
	if (!name) {
		name = "未命名";
	}

	this->name = new char[strlen(name) + 1];
	strcpy_s(this->name, strlen(name) + 1, name);

	this->age = age;
	this->salary = salary;
	this->darkHorse = darkHorse;
	this->id = ++LAST_ID;
}

Boy::Boy(int salary)
{
	const char* defaultName = "Unknow";

	this->name = new char[strlen(defaultName) + 1];
	strcpy_s(this->name, strlen(defaultName) + 1, defaultName);

	this->age =0;
	this->salary = salary;
	this->darkHorse = 0;
	this->id = ++LAST_ID;
}

Boy::Boy(const char* name)
{
	 
	this->name = new char[strlen(name) + 1];
	strcpy_s(this->name, strlen(name) + 1, name);

	this->age = 0;
	this->salary = 0;
	this->darkHorse = 0;
	this->id = ++LAST_ID;
}
 
 

Boy::~Boy()
{
	if (name) {
		delete name;
	}
}

Boy& Boy::operator=(const Boy& boy)
{
	if (name) {
		delete name;  //释放原来的内存
	}
	name = new char[strlen(boy.name) + 1]; //分配新的内存
	strcpy_s(name, strlen(boy.name) + 1, boy.name);

	this->age = boy.age;
	this->salary = boy.salary;
	this->darkHorse = boy.darkHorse;
	//this->id = boy.id;  //根据需求来确定是否要拷贝id
	return *this;
}

bool Boy::operator>(const Boy& boy)
{
	// 设置比较规则：
	// 薪资 * 黑马系数 + (100-年龄）*100
	if (power() > boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator<(const Boy& boy)
{
	if (power() < boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator==(const Boy& boy)
{
	if (power() == boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

int Boy::operator[](std::string index)
{
	if (index == AGE_KEY) {
		return age;
	}
	else if (index == SALARY_KEY) {
		return salary;
	}
	else if (index == DARK_HORSE_KEY) {
		return darkHorse;
	}
	else if (index == POWER_KEY) {
		return power();
	}
	else {
		return -1;
	}
}

int Boy::operator[](int index)
{
	if (index == 0) {
		return age;
	}
	else if (index == 1) {
		return salary;
	}
	else if (index == 2) {
		return darkHorse;
	}
	else if (index == 3) {
		return power();
	}
	else {
		return -1;
	}
}

Boy::operator char* () const
{
	return name;
}

Boy::operator int() const
{
	return power();
}

//ostream& Boy::operator<<(ostream& os) const
//{
//	os << "ID:" << id << "\t姓名:" << name << "\t年龄:" << age << "\t薪资:"
//		<< salary << "\t黑马系数:" << darkHorse;
//	return os;
//}

std::string Boy::description(void)
{
	std::stringstream ret;
	ret << "ID:" << id << "\t姓名:" << name << "\t年龄:" << age << "\t薪资:"
		<< salary << "\t黑马系数:" << darkHorse;
	return ret.str();
}

int Boy::power() const
{
	// 薪资* 黑马系数 + (100 - 年龄） * 1000
	int value = salary * darkHorse + (100 - age) * 100;
	return value;
}
 

 

main.cpp
 

#include <iostream>
#include "Boy.h"

using namespace std;

ostream& operator<<(ostream& os, const Boy& boy) {
	os << "ID:" << boy.id << "\t姓名:" << boy.name << "\t年龄:" << boy.age << "\t薪资:"
		<< boy.salary << "\t黑马系数:" << boy.darkHorse;
	return os;
}

istream& operator>>(istream& is, Boy& boy)
{
	string name2;
	is >> name2 >> boy.age >> boy.salary >> boy.darkHorse;
	boy.name = (char*)malloc((name2.length() + 1) * sizeof(char));
	strcpy_s(boy.name, name2.length() + 1, name2.c_str());
	return is;
}

int main(void) {
	Boy boy1("Rock", 38, 58000, 5);
	int power = boy1;
	char* name = boy1;
	

	system("pause");
	return 0;
}
 

 

类类型之间的转换 类类型A=> 类类型B
 

调用对应的只有一个参数【参数的类型就是类类型A】的构造函数
 

也可以使用类型转换函数，但是使用对应的构造函数更合适
 

实例：
 

把Boy类型，转换为Man类型
 

Boy.h
 

#pragma once
#include <string>
#include <iostream>
#include <ostream>
#include <istream>
#include <fstream>
#define AGE_KEY			"age"
#define SALARY_KEY		"salary"
#define DARK_HORSE_KEY  "darkHorse"
#define POWER_KEY		"power"

typedef enum {
	AGE,
	SALARY,
	DARK_HORSE,
	POWER
}BOY_KEY_TYPE;

using namespace std;
class Man;
class Boy
{
public:
	Boy(const char* name , int age, int  , int darkHorse);
	Boy(int salary);
	Boy(const char*);
	~Boy();
	 char* getname()const;

	Boy& operator=(const Boy& boy);

	bool operator>(const Boy& boy);
	bool operator<(const Boy& boy);
	bool operator==(const Boy& boy);

	// 下标运算符的重载
	int operator[](std::string index)const;
	int operator[](int index)const;
	//类型运算符重载 不需要返回类型
	operator char* ()const;
	operator int()const;

	// 该方式不适合
	//ostream& operator<<(ostream& os) const;

	friend ostream& operator<<(ostream& os, const Boy& boy);
	friend istream& operator>>(istream& is, Boy& boy);

	std::string description(void);
private:
	char* name;
	int age;
	int salary;
	int darkHorse; //黑马值，潜力系数
	unsigned int id; // 编号
	static int LAST_ID;

	int power() const; //综合能力值
};

//istream& operator>>(istream& is, Boy& boy);
//ostream& operator<<(ostream& os, const Boy& boy);
 

Boy.cpp
 

#include "Boy.h"
#include <string.h>
#include <sstream>

int Boy::LAST_ID = 0;  //初始值是0
ostream& operator<<(ostream& os, const Boy& boy) {
	os << "ID:" << boy.id << "\t姓名:" << boy.name << "\t年龄:" << boy.age << "\t薪资:"
		<< boy.salary << "\t黑马系数:" << boy.darkHorse;
	return os;
}

istream& operator>>(istream& is, Boy& boy)
{
	string name2;
	is >> name2 >> boy.age >> boy.salary >> boy.darkHorse;
	boy.name = (char*)malloc((name2.length() + 1) * sizeof(char));
	strcpy_s(boy.name, name2.length() + 1, name2.c_str());
	return is;
}
 


Boy::Boy(const char* name, int age, int salary, int darkHorse)
{
	if (!name) {
		name = "未命名";
	}

	this->name = new char[strlen(name) + 1];
	strcpy_s(this->name, strlen(name) + 1, name);

	this->age = age;
	this->salary = salary;
	this->darkHorse = darkHorse;
	this->id = ++LAST_ID;
}

Boy::Boy(int salary)
{
	const char* defaultName = "Unknow";

	this->name = new char[strlen(defaultName) + 1];
	strcpy_s(this->name, strlen(defaultName) + 1, defaultName);

	this->age =0;
	this->salary = salary;
	this->darkHorse = 0;
	this->id = ++LAST_ID;
}

Boy::Boy(const char* name)
{
	 
	this->name = new char[strlen(name) + 1];
	strcpy_s(this->name, strlen(name) + 1, name);

	this->age = 0;
	this->salary = 0;
	this->darkHorse = 0;
	this->id = ++LAST_ID;
}
 
 

Boy::~Boy()
{
	if (name) {
		delete name;
	}
}

  char* Boy::getname() const
{
	return name;
}

Boy& Boy::operator=(const Boy& boy) 
{
	if (name) {
		delete name;  //释放原来的内存
	}
	name = new char[strlen(boy.name) + 1]; //分配新的内存
	strcpy_s(name, strlen(boy.name) + 1, boy.name);

	this->age = boy.age;
	this->salary = boy.salary;
	this->darkHorse = boy.darkHorse;
	//this->id = boy.id;  //根据需求来确定是否要拷贝id
	return *this;
}

bool Boy::operator>(const Boy& boy)
{
	// 设置比较规则：
	// 薪资 * 黑马系数 + (100-年龄）*100
	if (power() > boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator<(const Boy& boy)
{
	if (power() < boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator==(const Boy& boy)
{
	if (power() == boy.power()) {
		return true;
	}
	else {
		return false;
	}
}

int Boy::operator[](std::string index)const
{
	if (index == AGE_KEY) {
		return age;
	}
	else if (index == SALARY_KEY) {
		return salary;
	}
	else if (index == DARK_HORSE_KEY) {
		return darkHorse;
	}
	else if (index == POWER_KEY) {
		return power();
	}
	else {
		return -1;
	}
}

int Boy::operator[](int index)const
{
	if (index == 0) {
		return age;
	}
	else if (index == 1) {
		return salary;
	}
	else if (index == 2) {
		return darkHorse;
	}
	else if (index == 3) {
		return power();
	}
	else {
		return -1;
	}
}

Boy::operator char* () const
{
	return name;
}

Boy::operator int() const
{
	return power();
}

//ostream& Boy::operator<<(ostream& os) const
//{
//	os << "ID:" << id << "\t姓名:" << name << "\t年龄:" << age << "\t薪资:"
//		<< salary << "\t黑马系数:" << darkHorse;
//	return os;
//}

std::string Boy::description(void)
{
	std::stringstream ret;
	ret << "ID:" << id << "\t姓名:" << name << "\t年龄:" << age << "\t薪资:"
		<< salary << "\t黑马系数:" << darkHorse;
	return ret.str();
}

int Boy::power() const
{
	// 薪资* 黑马系数 + (100 - 年龄） * 1000
	int value = salary * darkHorse + (100 - age) * 100;
	return value;
}
 

Man.h
 

#pragma once
#include <iostream>
#include <ostream>
#include <istream>
#include <fstream>
class Boy;

using namespace std;

class Man
{
public:
	
	Man(const char* name, int age, int salary);
	Man(const Boy& boy);
	~Man();
	friend ostream&operator<<(ostream& os, const Man& man);

	friend istream&operator>>(istream& is, Man& man);
	
private:
	int age;
	int salary;
	char* name;
};
//ostream& operator<<(ostream& os, const Man& man);
//istream& operator<<(istream& is, const Man& man);
 

 

Man.cpp
 

#include <iostream>
#include <fstream>
#include <ostream>
#include <istream>
#include "Boy.h"
#include "Man.h"
using namespace std;
 
Man::Man(const char* name, int age, int salary)
{
	if (!name) {
		name = "未命名";
	}
	this->name = new char[strlen(name)+1];
	strcpy_s(this->name, strlen(name) + 1, name);
	this->age = age;
	this->salary = salary;
}

Man::Man(const Boy& boy)
{
	int len = strlen((char*)boy) + 1;
	this->name = new char[len];
	strcpy_s(name, len, (char*)boy);

	age = boy[AGE];
	salary = boy[SALARY];


}

Man::~Man()
{
	delete name;
}

ostream& operator<<(ostream& os, const Man& man)
{
	os <<"[男人]"<<"\t姓名:"<< man.name <<"\t年龄:" << man.age << "\t薪资:"
		<< man.salary;

	return os;
}

istream& operator>>(istream& is, Man& man)
{
	// TODO: 在此处插入 return 语句
	string name2;
	is >> name2 >> man.salary;
	man.name = (char*)malloc((name2.length() + 1) * sizeof(char));
	strcpy_s(man.name, name2.length() + 1, name2.c_str());
	return is;
}	

//istream& operator>>(istream& is,const Man& man)
//{
//	string name2;
//	//is >> name2 >>man.salary ;
//	is >> name2 >> man.salary;
//	man.name = (char*)malloc((name2.length() + 1) * sizeof(char));
//	strcpy_s(man.name, name2.length() + 1, name2.c_str());
//	return is;
//}

 

 

Main.cpp
 

#include <iostream>
#include "Boy.h"
#include "Man.h"

using namespace std;



int main(void) {
	Boy boy("Rock", 38, 58000, 5);
	Man man = boy;
	cout << boy << endl;
	cout << man << endl;

	system("pause");
	return 0;
}
 

注意类型转换中的const const只能调用const方法 （operator函数）
 

常见错误总结-
 

const异常导致的BUG
 

 
 
小结：
 
 
const对象，只能调用对应的const方法
 
 
所以：
 
 
类的成员函数，如果已经确定不会修改任何数据成员，
 
 
那么，最好把这个成员函数，定义为const函数（在函数体的前面，参数列表的后面添加const）
 

 

main.cpp
 

#include <iostream>
#include "Human.h"
using namespace std;
int main()
{
	const Human lucifer("lucifer", 16, 10000);
	cout << lucifer[0] << endl;

	return 0;
}

Human.cpp

#include "Human.h"
#include <string.h>

Human::Human(const char* name, int age, int salary) {
	int len = strlen(name) + 1;
	this->name = new char[len];
	strcpy_s(this->name, len, name);
	this->age = age;
	this->salary = salary;


}

Human::~Human()
{
	if (name) {
		delete name;
	}
}

int Human::operator[](std::string index)const
{
	/*if (index == NAME) {

	 }*/
	if (index == AGE_KEY) {
		return age;
	}
	else if (index == SALARY_KEY) {
		return salary;
	}
	 
 
	else {
		return -1;
	}

	return 0;
}



int Human::operator[](int index)
{
	if (index == AGE) {
		return age;
	}
	else if(index == SALARY)
	{
		return salary;
	}
	else {
		return -1;
	}
 
}
 

Human.h
 

#pragma once
#include <string>


#define AGE_KEY			"age"
#define SALARY_KEY		"salary"
#define DARK_HORSE_KEY  "darkHorse"
#define POWER_KEY		"power"

typedef enum {
	AGE,
	SALARY,
	POWER
}BOY_KEY_TYPE;

class Human
{
public:
	Human(const char* name, int age,int salary);
	~Human();
	int operator[](std::string index)const;
	int operator[](int index);
private:
	char* name;
	int age;
	int salary;
};

 

如果此时调用main函数，那么此时的执行结果是
 

 

 

报错原因 const对象只能调用cosnt方法
 

operator= 的参数问题
 

 
 
赋值运算符的重载，应该使用这种方式：
 
 
Boy& operator=(const Boy &boy);
 
 
就是：参数要使用引用！
 
 
 

 

 
 
如果定义成：
 
 
Boy& operator=(const Boy *boy);
 
 
将会没有效果，编译器不会识别为赋值运算符的重载，
 
 
也就是：boy2 = boy1时不会调用这个函数
 

 

 

 
 
如果定义：
 
 
Boy& operator=(const Boy boy);
 
 
有效果，但是在调用时，会执行参数的传递：
 
 
比如：boy2 = boy1;
 
 
就会执行： boy2.operator=(boy1);
 
 
就会执行: const Boy boy = boy1;
 
 
就会执行： Boy类的赋值构造函数
 

 

 
 
有两个影响：
 
 
1） 浪费性能
 
 
2） 如果没有自定义的拷贝构造函数，而且这个类又有指针成员时，就会调用自动生成的拷贝构造函数，导致浅拷贝
 
 
如果析构函数中，对这个指针指向的内存做了释放，那就导致数据损坏或崩溃！
 

 

 

 
 
小结：
 
 
1）赋值·运算符的重载，一定要使用引用参数
 
 
2）如果一个类有指针成员，而且使用了动态内存分配，那么一定要定义自己的拷贝构造函数【要使用深拷贝】，避免调用自动生成的拷贝构造函数
 
 
因为自动生成的拷贝构造函数，是浅拷贝！
 


                

        

        

    

  


            

                    
            

    

      

        

            

              
                
                  luciferau
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
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);...

			
		

	



                

            
              



	

		

			

				
					
运算重载和友元函数

				
			

			

				

					Sunblogy的博客
				

				

					11-01
					
					4521
					
				

			

		

		

			
				
第1关：复数运算
任务描述
相关知识
运算符重载
运算符重载之外部函数
运算符重载之成员函数
编程要求
测试说明
任务描述
本关任务：设计一个复数类并实现复数的三种运算。
相关知识
所谓重载，就是赋予新的含义。函数重载可以让一个函数名有多种功能，在不同情况下进行不同的操作。运算符重载也是一个道理，同一个运算符可以有不同的功能。本关我们就一起来学习运算符重载的使用。
运算符重载
运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。也就是说，运算符重载

			
		

	



              


  
              

                


	

		

			

				
					
c++的友元，运算符重载

				
			

			

				

					sakura0908的博客
				

				

					04-09
					
					1433
					
				

			

		

		

			
				
重载运算符限制在C++语言中已有的运算符范围内，并且允许重载的运算符之中，不能创建新的运算符。运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数 及语法结构。运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象 一起使用，或者用于用户自定义类型的对象和内部类型的对象混合使用时。

			
		

	





	

		

			

				
					
友元运算符重载函数

					
最新发布

				
			

			

				

					今天也要加油呀ʕ ᵔᴥᵔ ʔ
				

				

					09-28
					
					562
					
				

			

		

		

			
				
运算符重载

			
		

	



		

			
		



	

		

			

				
					
运算符重载之友元运算符重载

					
热门推荐

				
			

			

				

					aaqian1的博客
				

				

					01-05
					
					1万+
					
				

			

		

		

			
				
友元可以参考：https://blog.csdn.net/aaqian1/article/details/84427884
友元运算符重载函数： 把运算符重载函数定义为某个类的友元函数。
1、定义友元运算符重载函数的语法形式
（1）在类的内部，定义友元运算符重载函数的格式如下：
friend 函数类型 operator 运算符(形参表)
{
	函数体
}

（2）友元运算符重载函数也可以在类中声明...

			
		

	





	

		

			

				
					
友元、运算符的重载

				
			

			

				

					m0_47584501的博客
				

				

					03-25
					
					2215
					
				

			

		

		

			
				
一、友元函数和友元类
1、友元函数
	在C++中我们我们通常可以将全局函数或者类的成员函数声明为类的友元函数，这样友元函数便可以访问类对象
中的私有成员。我们可以用friend关键字将其声明为友元函数。

1、将全局函数声明为类的友元函数
	以friend关键字声明的全局函数称为类的友元函数，友元函数可以通过类对象访问它的私有成员。可以在类内
对全局的友元函数进行声明，在类外对其进行定义。（也可以在类内对全局的友元函数进行定义，此时它仍然为全局
函数）。

2、将一个类的成员函数声明为另一个类的友元函数 


			
		

	





	

		

			

				
					
C++封装思想之二：友元机制和运算符重载（1W字详解）

				
			

			

				

					qq_25218501的博客
				

				

					08-04
					
					1389
					
				

			

		

		

			
				
友元的作用：类的非成员函数可以直接访问类的非公有成员变量，省去函数的调用和访回过程。从而提高了程序的运行效率（即减少了类型和安全性检查及调用的时间开销）
运算符重载的作用
可以提高程序的可读性
体现了C++的可扩充性
运算符重载仅仅只是语法上的方便，它是另一种函数调用的方式
运算符重载，本质上是函数重载

			
		

	





	

		

			

				
					
C++运算符重载规则详解

				
			

			

				

					09-03
				

			

		

		

			
				
C++运算符重载是语言特性之一，允许程序员为已存在的运算符赋予新的含义，以适应自定义数据类型的运算需求。然而，运算符重载并不是无限制的，它遵循一些特定的规则，以确保代码的清晰性和正确性。  首先，C++中大...

			
		

	





	

		

			

				
					
c++运算符重载基础知识详解

				
			

			

				

					09-04
				

			

		

		

			
				
C++运算符重载是编程中一个重要的概念，它允许我们为已有的运算符赋予新的含义，使得在处理自定义数据类型时，代码更加直观和简洁。在C++中，运算符重载并不是创建新的运算符，而是为已有的运算符提供不同的实现方式...

			
		

	





	

		

			

				
					
C++重载运算符的规则详解

				
			

			

				

					09-04
				

			

		

		

			
				
C++中的运算符重载是一项重要的特性，它允许程序员为自定义类型定义特定的运算行为。以下是关于C++运算符重载的一些详细规则和注意事项：  1. **仅限已有的运算符**：C++并不支持用户自创新的运算符，而是只能对已有...

			
		

	





	

		

			

				
					
友元函数和重载

				
			

			

				

					qianyayun19921028的博客
				

				

					07-11
					
					2887
					
				

			

		

		

			
				
友元函数：类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 friend重载函数步骤：...

			
		

	





	

		

			

				
					
C++学习（6）——友元和运算符重载

				
			

			

				

					似末的博客
				

				

					03-08
					
					1274
					
				

			

		

		

			
				
friend（友元）、友元函数、友元类、+号重载（-号类似）、++重载（--类似）、=号重载。

			
		

	





	

		

			

				
					
c++入门学习⑥——友元和运算符重载

				
			

			

				

					2301_79328557的博客
				

				

					02-19
					
					1176
					
				

			

		

		

			
				
类做友元




注意先声明building然后再定义朋友类，再定义建筑物类，再利用构造函数初始化朋友类，创建类对象，然后构造函数赋初值给类属性，重要的是，要先定义朋友类，再定义建筑类，不然程序会出错的。


对于内置的数据类型，编译器知道如何运算。而c++中有自定义数据类型，程序往往不知道如何去计算自定义数据类型因此需要自己进行运算符重载，使用关键字operate先新建一个自定义数据类型——类，然后对于类对象的直接相加计算机不知道如何计算——》需要进行加号运算符重载 全局函数重载+运算符，这里是把两个类对

			
		

	





	

		

			

				
					
C++学习笔记——友元及重载运算符

				
			

			

				

					华数云图小分队的博客
				

				

					01-07
					
					1333
					
				

			

		

		

			
				
C++学习笔记——友元及重载运算符public:在Account类的构造函数中，我们使用传入的参数来初始化私有成员变量name和balance。deposit方法用于存款操作。它接受一个 double 类型的参数amount，代表要存入的金额。方法内部，我们将传入的金额加到余额上，并输出新的余额。} else {withdraw方法用于取款操作。它接受一个 double 类型的参数amount，代表要取出的金额。方法内部，我们首先检查账户余额是否足够，如果足够就从余额中减去取款金额，并输出新的余额。

			
		

	





	

		

			

				
					
C++ 面向对象 - 运算符重载与友元函数

				
			

			

				

					HkSwaggyD的博客
				

				

					08-23
					
					975
					
				

			

		

		

			
				
运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。只要在需要类的类型值的地方，给定构造函数的形参类型的值，就将由编译器执行这种类型的转换。转换构造函数是构造函数的一个特例，当一个构造函数的参数只有一个，而且是一个其他类型的 const 引用时，它就是一个转换构造函数。若类 B 是类 A 的友元，类 C 是 B 的友元，类 C 不一定是类 A 的友元。成为成员函数的运算符重载函数的参数需要少写一个最左边的参数，而少的这个参数就由当前的对象代替。

			
		

	





	

		

			

				
					
C++友元和运算符重载

				
			

			

				

					nnan77的博客
				

				

					03-11
					
					1770
					
				

			

		

		

			
				
C++友元和运算符重载

			
		

	





	

		

			

				
					
运算符重载（友元函数、运算符重载的形式、特殊运算符的重载、类型转换）

				
			

			

				

					yanglw98的博客
				

				

					06-13
					
					2192
					
				

			

		

		

			
				
友元函数
什么是友元函数
私有成员只能在类的成员函数内部访问，如果想在别处访问对象的私有成员，只能通过类提供的接口（成员函数）间接地进行。这固然能够带来数据隐藏的好处，利于将来程序的扩充，但也会增加程序书写的麻烦。
在面向对象编程中，友元函数（friend function）是一个指定类（class）的“朋友”，该函数被允许访问该类中private、protected、public的数据成员。普通的函数并不能访问这些数据，然而宣告一个函数成为一个类的友元函数则被允许访问这些数据。
友元函数的宣告可以放在类声

			
		

	





	

		

			

				
					
友元函数的运算符重载

				
			

			

				

					m0_68738982的博客
				

				

					05-21
					
					701
					
				

			

		

		

			
				
友元函数用于运算符重载时，可以访问类的私有和保护成员。这在一些情况下非常有用，特别是当需要访问多个类的私有成员时。例如，实现两个类对象之间的加法运算，或者实现全局运算符函数。

			
		

	





	

		

			

				
					
c++友元 重载运算符

				
			

			

				

					dgeujsbdeu的博客
				

				

					04-04
					
					1962
					
				

			

		

		

			
				
​
友元：


1、全局函数做友元：3、

只需要将全局函数前加一个friend关键字，并放到类中声明便可以访问类中私有成员了。

2、类做为友元

将类1的声明放到另一个类2中，并加上friend，类1就可以访问类2的private成员了。

3、成员函数做友元

将类1的成员函数前加个类成员函数的声明( : : )，并加上friend放到类2中，就可以访问类2的private成员了。



运算符重载：给付好一些新定义，以实现自定义运算


加号运算符：


Person operator+(Perso

			
		

	





	

		

			

				
					
C++友元运算符函数详解：重载规则与常见运算符

				
			

			

				

					
				

			

		

		

			
				
友元运算符函数是C++中一种特殊的技术，它允许我们扩展内置的运算符行为，以便在类的外部或内部使用自定义的方式进行操作。友元运算符函数并非类的成员函数，因此它们不依赖于`this`指针，这使得它们可以在不同的上...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
luciferau

			
你的鼓励是我最大的动力

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

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

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值