C++-运算符重载

已于 2022-08-29 21:33:19 修改
阅读量411 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2022-08-28 21:49:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/procurar/article/details/126573244
版权

一、为什么要使用运算符重载

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

问题：一头牛+一头马 = ？（牛马神兽？）
一个圆 +一个圆 = ？ （想要变成一个更大的圆）
一头牛 – 一只羊 = ？ (想要变成4只羊，原始的以物易物：1头牛价值5只羊)

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

二、运算符重载的基本用法

1.方式1：使用成员函数重载运算符(以重载+运算符为例)

Cow.h

#pragma once

class Pork;
class Goat;

class Cow
{
public:
	Cow(int weight);

	// 一头牛 + 一头牛 = 多少猪肉？
	// 参数此时定义为引用类型，更合适，避免拷贝，一个参数是因为可以用this本身，只需要一个参数
	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.h

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

Goat.cpp

#include "Goat.h"

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

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

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;
}

重点部分：

// 一头牛 + 一头牛 = 多少猪肉？
	// 参数此时定义为引用类型，更合适，避免拷贝，一个参数是因为可以用this本身，只需要一个参数
	Pork operator+(const Cow& cow);  //同类型进行运算，很频繁
	// 一头牛 + 一只羊 = 多少猪肉？
	Pork operator+(const Goat& goat); //不同类型进行运算，比较少见

// 规则：
// 一斤牛肉：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);
}

2.方式2：使用非成员函数【友元函数】重载运算符

Cow.h

// 友元函数实现运算符重载
	friend Pork operator+(const Cow& cow1, const Cow& cow2);
	friend Pork operator+(const Cow& cow1, const Goat& goat);

main.cpp

#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;
}

3.两种方式的区别

区别：

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

两种方式的选择：
2. 一般情况下，单目运算符重载，使用成员函数进行重载更方便（不用写参数）
3. 一般情况下，双目运算符重载，使用友元函数更直观

方便实现a+b和b+a相同的效果，成员函数方式无法实现。（前者相当于调用a.operator+(b)）
例如： 100 + cow; 只能通过友元函数来实现（因为加号左边不是类）
cow +100; 友元函数和成员函数都可以实现
注意双目运算符+等，加上本身的隐式this参数，最多只能2个参数。

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

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

三、运算符重载的禁区和规则

  1. 为了防止对标准类型进行运算符重载，
    C++规定重载运算符的操作对象至少有一个不是标准类型，而是用户自定义的类型
    比如不能重载 1+2
    但是可以重载 cow + 2 和 2 + cow // cow是自定义的对象

2.不能改变原运算符的语法规则， 比如不能把双目运算符重载为单目运算

  • 不能改变原运算符的优先级

  • 不能创建新的运算符，比如 operator**就是非法的, operator*是可以的

  • 不能对以下这四种运算符，使用友元函数进行重载
    = 赋值运算符，（）函数调用运算符，[ ]下标运算符，->通过指针访问类成员

  • 不能对禁止重载的运算符进行重载

不能被重载的运算符

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

可以被重载的运算符

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

四、实例：重载赋值运算符=

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);
	std::string description(void);
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>

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;
}

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

main.cpp

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

int main(void) {
	Boy boy1("Rock", 38, 58000, 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;
}

注意：
注意赋值运算符重载的返回类型 和参数类型。
返回引用类型，便于连续赋值
参数使用引用类型， 可以省去一次拷贝
参数使用const, 便于保护实参不被破坏。

重点：

Boy& operator=(const Boy& boy);

/ 注意返回类型 和参数类型
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;
}

五、实例：重载关系运算符>、<、==

与上不同的代码；

Boy.h

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

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::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);
	
	if (boy1 > boy2) {
		std::cout << "选择boy1" << std::endl;
	}
	else if (boy1 == boy2) {
		std::cout << "难以选择" << std::endl;
	}
	else {
		std::cout << "选择boy2" << std::endl;
	}

	system("pause");
	return 0;
}

六、实例：重载运算符[ ]

（字符串也能做下标）

与上不同的代码；

Boy.h

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

Boy.cpp

//这里字符串可以定义宏来替换，更具有可读性、健壮性
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;
	}
}

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;
}

利用宏和枚举，让代码更具有可读性、健壮性：

#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;

七、自定义输入输出：重载<<和>>输入输出运算符

为什么要重载<< 和 >>
为了更方便的实现复杂对象的输入和输出。

1.方式1（使用成员函数， 不推荐，该方式没有实际意义）

与上不同的代码；

Boy.h

ostream& operator<<(ostream& os) const; //const保证常对象也能调用，引用类型保证连续输出，不然就用void也可

//os是专门用来输出的流对象，本质上就是cout，只是说cout是一种特殊的常用对象
ostream& Boy::operator<<(ostream& os) const
{
	os << "ID:" << id << "\t姓名:" << name << "\t年龄:" << age << "\t薪资:"
		<< salary << "\t黑马系数:" << darkHorse;
	return os;
}

main.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;
}

不推荐的最大原因：不符合编程习惯。

2.方式2：使用友元函数

Boy.h

.......

class Boy
{
public:
	.......
	// 该方式不适合
	//ostream& operator<<(ostream& os) const;

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

	........
};

Boy.cpp 【不变】

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;
}

八、实例：重载类型运算符

1.普通类型 => 类类型

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

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

Boy.h

............

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

	...........

Boy.cpp

Boy::Boy(int salary)
{
	const char *defaultName = "未命名";
	name = new char[strlen(defaultName) + 1];
	strcpy_s(name, strlen(defaultName) + 1, defaultName);

	age = 0;
	this->salary = salary;
	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);

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

main.cpp

int main()
{
	Boy boy1 = 10000;
	Boy boy2 = "Rock";

	cout << boy1 << endl;
	cout << boy2 << endl;

	boy1 = 20000; //boy1 = Boy(20000);
	cout << boy1 << endl;

	return 0;
}

2.类类型 => 普通类型

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

需求：
Boy boy1(“Rock”, 28, 10000, 5);
int power = boy1; // power();
char *name = boy1; // “Rock”

Boy.h

.................................
// 特殊的运算符重载：类型转换函数，不需要写返回类型
	operator int() const;
	operator char* () const;
.......................

Boy.cpp

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

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

main.cpp

int main()
{
	Boy boy1("Rock", 28, 10000, 5);
	Boy boy2("Rock");

	int power = boy1;
	char* name = boy2;

	cout << power << endl;
	cout << name << endl;

	system("pause");
	return 0;
}

3.类类型A => 类类型B

调用对应的只有一个参数【参数的类型就是类类型A】的构造函数
也可以使用类型转换函数，但是使用对应的构造函数更合适。

实例：
把Boy类型，转换为Man类型

Boy.h

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

Boy.cpp【不变】

Man.h

#pragma once
#include <iostream>

using namespace std;

class Boy;

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

ostream& operator<<(ostream &os, const Man& man);

Man.cpp

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

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;
	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  << "【男人】姓名:" << man.name
		<< "\t年龄 : " << man.age
		<< "\t薪资 : " << man.salary;
	return os;
}

main.cpp

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

using namespace std;


int main()
{
	Boy boy("Rock", 28, 10000, 5);
	Man man = boy;
	

	cout << boy << endl;
	cout << man << endl;

	system("pause");
	return 0;
}

这里其实就是不同类的对象之间的赋值，之前的复制拷贝构造函数是同类对象之间的赋值。

总结

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）如果一个类有指针成员，而且使用了动态内存分配，那么一定要定义自己的拷贝构造函数【要使用深拷贝】，避免调用自动生成的拷贝构造函数
因为自动生成的拷贝构造函数，是浅拷贝！

procurar
关注
专栏目录
cpp笔记-运算符重载
Skyler1017的博客
01-18 371
运算符重载 内置类型的运算符无法重载，只能操作自定义类型 不能重载的运算符 . .* ?: :: sizeof 不能有默认参数，否则会改变操作符的数量 普通函数重载 要求其中的数据成员时public的 classA operator + (const classsA & a, const classA & b){ return classA(a._a b....
C++_运算符重载
热门推荐
思考，思考，再思考~
07-23 8万+
什么是运算符的重载?         运算符与类结合，产生新的含义。 为什么要引入运算符重载？         作用：为了实现类的多态性(多态是指一个函数名有多种含义)怎么实现运算符的重载？方式：类的成员函数 或 友元函数（类外的普通函数）规则：不能重载的运算符有 .  和 .*
CPP_运算符重载及友元
weixin_33862041的博客
09-09 174
运算符重载 两种重载方法1）成员函数 a + b =&gt; a.operator+(b); 一个参数 2）友元函数 a + b =&gt; operator+(a, b); 两个参数。 friend 将某个类或函数声明为另一个类的友元，就可以访问另一个类的private成员了。 不能重载运算符：., .*, ::, ?: （共四个） 事例重载操作符operator...
CPP运算符重载
SongyangJi
05-04 2694
文章目录函数的重载运算符重载运算符重载的作用运算符重载的方式典型运算符的重载转换构造函数类型转换函数 函数的重载 1.定义的重载函数必须具有不同的参数个数，或不同的参数类型。编译系统根据不同的参数去调用不同的重载函数，实现不同的功能。 2、仅返回值不同时，不能定义为重载函数。 运算符重载 函数重载是指完成不同功能的函数可以具有相同的函数名。 C++编译器根据函数的实参确定应该调用哪一个函数。 运算...
【c++】cpp运算符重载
hutaotaotao的博客
04-26 1342
c++运算符重载
C++实验报告实验七-运算符重载
03-14
### C++实验报告实验七-运算符重载 #### 实验目的 本次实验的主要目标是通过实际编程加深对C++中运算符重载的理解和应用。具体包括： 1. **编写程序熟悉运算符重载函数的定义和使用**：通过实践操作理解如何...
面向对象程序设计语言C++---第5章-运算符重载.ppt
07-04
C++运算符重载 面向对象程序设计语言C++中的运算符重载是指在用户定义类型上重新定义普通运算符的含义，以达到扩展语言的能力。运算符重载允许用户在不同的上下文中对已存在的预定义运算符进行重新解释。 1.运算符...
C++实验11--运算符重载.html
05-25
C++实验11--运算符重载.html
C++作业实验-运算符重载
06-20
在C++编程语言中，运算符重载是一项关键特性，允许我们为自定义类型赋予特定的运算符行为。本实验“C++作业实验-运算符重载”旨在深入理解这一概念，通过Visual Studio 2010开发环境进行实践。在这个实验中，我们将...
c++特殊运算符重载---流运算符重载（csdn）————程序.pdf
12-01
在C++编程语言中，运算符重载是一种强大的特性，允许程序员为自定义类型赋予特定的行为，以便它们能像内置类型一样使用。本篇将详细探讨流运算符重载，也就是`和`>>`这两个运算符在处理输入输出流时如何被重载。 ...
CPP 学习 - 运算符重载
灰黑的博客
01-13 1304
友元 友元不受访问权限的控制(public / protected / private) 友元函数可以重载，但是友元属性不会被继承 不能访问友元类内部的私有函数 友元是单向的，有缘关系不能传递(A -> B -> C) 推不出 (A -> C) 子类不会继承父类的友元属性 友元的形式 友元函数 友元类 class 类名 { // ... friend 函数原型; friend class 类名; // .... }; 函数 成员函数 非成员函数（
C++ - 运算符重载
莫忘输赢的博客
09-25 492
C++ - 运算符重载
CPP-基础：单目运算符重载
dixiongbi7761的博客
08-28 228
关于++运算符前置和后置重载的实现实例： 1 #include <iostream> 2 using namespace std; 3 //创建时钟类 4 class Clock 5 { 6 public: 7 Clock(int NewH=0,int NewM=0,int NewS=0);//构造函数 8 void...
运算符重载.cpp[运算符重载][C++,类]
qq_44699909的博客
02-08 364
//#define _CRTDEG_MAP_ALLOC //检测动态内存泄漏 #include #include <stdlib.h>//检测动态内存泄漏 #include “Cow.h” #include “Goat.h” #include “pork.h” /* //检测动态内存泄漏 #include <crtdbg.h> //替代new #ifdef _DEBUG ...
cpp运算符重载
bailang322的专栏
06-08 519
Complex Complex::operator+(const Complex &other) {     int r = real_+other.real_;     int i  = img_ +other.img_;     return Complex(r,i); } 等价   C =  A.oprator + B
Cpp实验：运算符重载
最新发布
lengmei1的博客
08-09 1582
运算符重载是C++中的特殊语法，它能够让我们为自定义的类型定义运算符的行为。1. 运算符重载让我们可以为自定义类型定义类似原生数据类型的运算符。比如，我们可以通过重载“+”运算符来实现自定义类型的加法运算。2. 运算符重载遵循一些规则，比如运算符重载函数必须作为类的成员函数或全局函数，不能改变运算符的优先级和结合性，等等。3. 运算符重载可以大大简化代码，提高可读性和可维护性。通过自定义类型的运算符，我们可以直接对自定义类型进行运算操作，不再需要额外的函数调用。
CPP运算符重载（加法）
CrazyRabbitttt
08-26 1023
概念：对已经有的运算符进行重新定义，赋予另一种运算的形式，来适用于不同的数据类型。 使用operator关键字来进行重载 下面展示对于类中的加法重载 #include<iostream> #include<cstring> using namespace std; class Person { public: //成员函数的重载方法 ，对于一个实例化的对象 传一个参数 然后输出这两个的+ /*Person operator+(Person &p) //重..
C++ 重载
ForestRound的博客
10-03 620
重载：函数重载，运算符重载 区别于虚函数的动态绑定（运行时多态），重载属于静态绑定（编译时多态）。 重载：在函数名（包括运算符）相同的情况下，编译器能够根据不同的参数类型确定对应的函数。 1. 函数重载 函数名相同，参数类型不同。（同一个类中） 成员函数也可以重载。 常成员函数和普通成员函数可以以重载的形式共存（这也是之前强调声明和定义必须带const的原因，否则会被当
C++ 运算符重载
qq_41605114的博客
02-13 379
目录 运算符重载（operator） 加法运算符重载 类成员函数做运算符重载 全局函数做运算符重载 前置后置运算符重载 后置运算符 为了和后置运算符做区别，在参数部分有一个占位参数 指针运算符重载（智能指针） 总结 运算符重载（operator） 运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型 在C++中，可以定义一个处理类的新运...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值