一文详解C++操作符重载

最新推荐文章于 2024-06-21 14:20:12 发布
最新推荐文章于 2024-06-21 14:20:12 发布
阅读量747 收藏 3
点赞数 3
分类专栏： Algorithm # Leetcode C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44653420/article/details/127188100
版权
Leetcode 同时被 3 个专栏收录
488 篇文章 1 订阅
订阅专栏
Algorithm
308 篇文章 0 订阅
订阅专栏
C++
68 篇文章 4 订阅
订阅专栏

一文详解C++操作符重载

一、运算符重载的基本概念

 运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型（运算符重载不能改变原来的寓意。不能改变基础类型寓意）

运算符重载只是一种语法上的方便，也就是它只是另一种函数调用方式

 在C++中可以定义一个处理类的新运算符，这种定义很像一个普通的函数定义，只是函数的名字由关键字operator及其紧跟的运算符组成，差别仅此而已，它像任何其他函数一样也是一个函数，当编译器遇到适当的模式时，就会调用这个函数

语法：定义重载的运算符就像定义函数，只是该函数的名字是operator@这里的@代表了被重载的运算符，函数的参数中参数个数取决于两个因素

二、加号运算符重载

2.1 写成全局函数

重载函数如果写成全局的，那么双目运算符左边的是第一个参数，右边是第二个参数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Maker {

public:
	Maker(int id,int age)
	{
		this->id = id;
		this->age = age;
	}

	int getId()
	{
		return this->id;
	}

	int getAge()
	{
		return this->age;
	}

private:
	int id;
	int age;
};

// 全局重载
Maker operator+(Maker &p1, Maker &p2)
{
	Maker t(p1.getId() + p2.getId(), p1.getAge() + p2.getAge());
	return t;
}

void test01()
{
	Maker m(1,2);
	Maker n(2,3);

	// 编译器看到两个对象相加  那么编译器会去找有没有叫operator+的函数
	Maker m3 = m + n;// 运算符重载

	cout << m3.getId() << m3.getAge() << endl;
}

int main()
{

	test01();
	return EXIT_SUCCESS;
}

2.2 写成成员函数

重载函数如果写成成员函数，那么双目运算符的左边就是this,右边是第一个参数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Maker {

public:
	Maker(int id,int age)
	{
		this->id = id;
		this->age = age;
	}

	int getId()
	{
		return this->id;
	}

	int getAge()
	{
		return this->age;
	}

	// 写成成员函数 那么只需要一个参数  这个参数是加号的右边
	Maker operator+(Maker& m)
	{
		Maker t(this->id + m.id,this->age + m.age);
		return t;
	}

private:
	int id;
	int age;
};

 全局重载
//Maker operator+(Maker &p1, Maker &p2)
//{
//	Maker t(p1.getId() + p2.getId(), p1.getAge() + p2.getAge());
//	return t;
//}

void test01()
{
	Maker m(1,2);
	Maker n(2,3);

	// 编译器看到两个对象相加  那么编译器会去找有没有叫operator+的函数
	Maker m3 = m + n;// 运算符重载

	cout << m3.getId() << m3.getAge() << endl;
}

int main()
{

	test01();
	return EXIT_SUCCESS;
}

2.3 不同类的对象相加

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Maker {

public:
	Maker(int id,int age)
	{
		this->id = id;
		this->age = age;
	}

	int getId()
	{
		return this->id;
	}

	int getAge()
	{
		return this->age;
	}

	// 写成成员函数 那么只需要一个参数  这个参数是加号的右边
	Maker operator+(Maker& m)
	{
		Maker t(this->id + m.id,this->age + m.age);
		return t;
	}

private:
	int id;
	int age;
};


class Student
{
public:
	Student()
	{
		this->mid = 0;
	}

	Student(int id)
	{
		this->mid = id;
	}


	int getID()
	{
		return this->mid;
	}
private:
	int mid;
};

 全局重载
//Maker operator+(Maker &p1, Maker &p2)
//{
//	Maker t(p1.getId() + p2.getId(), p1.getAge() + p2.getAge());
//	return t;
//}

void test01()
{
	Maker m(1,2);
	Maker n(2,3);

	// 编译器看到两个对象相加  那么编译器会去找有没有叫operator+的函数
	Maker m3 = m + n;// 运算符重载

	cout << m3.getId() << m3.getAge() << endl;
}

// 不同类的对象相加  全局重载
Maker operator+(Maker &m, Student &s)
{
	Maker t(m.getId() + s.getID(),20);
	return t;
}

void test02()
{
	Maker m(1, 9);
	Student n(2);
	Maker s = m + n;
	cout << s.getId() << s.getAge() << endl;
}

int main()
{
	test02();
	return EXIT_SUCCESS;
}

 几乎C中所有的运算符都可以重载，但是运算符重载的使用还是相当受限制，特别是不能使用C中当前没有意义的运算符，不能改变运算符优先级，不能改变运算符的参数个数

在这里插入图片描述

三、减号运算符重载

3.1 成员函数的形式

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Maker {

public:
	Maker(int id,int age)
	{
		this->id = id;
		this->age = age;
	}

	int getId()
	{
		return this->id;
	}

	int getAge()
	{
		return this->age;
	}

	// 写成成员函数 那么只需要一个参数  这个参数是加号的右边
	Maker operator-(Maker& m)
	{
		Maker t(this->id - m.id,this->age - m.age);
		return t;
	}

private:
	int id;
	int age;
};


void test01()
{
	Maker m(1,2);
	Maker n(2,3);

	// 编译器看到两个对象相加  那么编译器会去找有没有叫operator+的函数
	Maker m3 = m - n;// 运算符重载

	cout << m3.getId() << m3.getAge() << endl;
}

int main()
{
	test01();
	return EXIT_SUCCESS;
}

全局重载

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Maker {

public:
	Maker(int id,int age)
	{
		this->id = id;
		this->age = age;
	}

	int getId()
	{
		return this->id;
	}

	int getAge()
	{
		return this->age;
	}

	// 写成成员函数 那么只需要一个参数  这个参数是加号的右边
	Maker operator-(Maker& m)
	{
		Maker t(this->id - m.id,this->age - m.age);
		return t;
	}

private:
	int id;
	int age;
};


int operator-(Maker& m, int b)
{
	return m.getId() - b;
}


void test01()
{
	Maker m(1,2);
	Maker n(2,3);

	// 编译器看到两个对象相加  那么编译器会去找有没有叫operator+的函数
	int m3 = m - 5;// 运算符重载

	cout << m3 << endl;
}

int main()
{
	test01();
	return EXIT_SUCCESS;
}

四、左移运算符重载

4.1 全局函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Maker {

public:
	Maker(int id,int age)
	{
		this->id = id;
		this->age = age;
	}

	int getId()
	{
		return this->id;
	}

	int getAge()
	{
		return this->age;
	}

	// 写成成员函数 那么只需要一个参数  这个参数是加号的右边
	Maker operator-(Maker& m)
	{
		Maker t(this->id - m.id,this->age - m.age);
		return t;
	}

private:
	int id;
	int age;
};

// 如果要和endl一起使用 那么必须返回ostream对象
opstream& operator<<(ostream& out, Maker& m)
{
	cout << m.getId() << " " << m.getAge() << endl;
    return out;
}


void test01()
{
	Maker m(1,2);
	cout << m;// 重载左移运算符
}


int main()
{
	test01();
	return EXIT_SUCCESS;
}

注意：

  • cout是对象，<<是左移运算符
  • 重载左移运算符是为了直接打印对象
  • 形参和实参是一个对象
  • 不能改变库类中的代码
  • oatream中把拷贝构造函数私有化
  • 如果要把endl一起使用，那么必须返回ostream的对象

五、右移运算符重载

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Maker {
	friend void operator>>(istream& in, Maker& m);
public:
	Maker(int id,int age)
	{
		this->id = id;
		this->age = age;
	}

	int getId()
	{
		return this->id;
	}

	int getAge()
	{
		return this->age;
	}

	// 写成成员函数 那么只需要一个参数  这个参数是加号的右边
	Maker operator-(Maker& m)
	{
		Maker t(this->id - m.id,this->age - m.age);
		return t;
	}

private:
	int id;
	int age;
};

// 将全局函数声明为友元函数 可以访问私有成员
void operator>>(istream& in, Maker& m)
{
	in >> m.id;
	in >> m.age;
}

void test01()
{
	Maker m(1,2);
	cin >> m;
	cout << m.getAge() << " " << m.getId() << endl;
}



int main()
{
	test01();
	return EXIT_SUCCESS;
}

六、赋值运算符重载

6.1 默认的赋值运算符重载函数进行了简单的赋值操作

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Maker {

public:
	Maker()
	{
		this->id = 0;
		this->age = 0;

	}
	Maker(int id,int age)
	{
		this->id = id;
		this->age = age;
	}

	int getId()
	{
		return this->id;
	}

	int getAge()
	{
		return this->age;
	}


private:
	int id;
	int age;
};


void test01()
{
	Maker m(1,2);
	Maker m1;

	m1 = m;// 默认的赋值运算符重载函数进行了简单的赋值操作
	cout << m1.getId() << m1.getAge() << endl;
}

int main()
{
	test01();
	return EXIT_SUCCESS;
}

6.2 当类有成员指针时，然后在构造函数中申请堆区空间，在析构函数中释放堆区空间

当类有成员指针时，然后在构造函数中申请堆区空间，在析构函数中释放堆区空间，会出现同一块空间释放两次，然后内存泄漏，所以要重写赋值运算符重载函数。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Student {


public:
	Student(const char* name)
	{
		pName = new char[strlen(name) + 1];// 申请堆区空间
		strcpy(pName,name);// 复制内容
	}

	// 重写赋值运算符重载函数
	Student& operator=(const Student& stu)
	{
		// 不确定this->pName 指向的空间是否能装下stu中的数据  所以先释放this->pNmae所指向的空间
		if (this->pName != NULL)
		{
			delete this->pName;
			this->pName = NULL;
		}

		// 申请空间 大小由stu进行决定
		this->pName = new char[strlen(stu.pName) + 1];
		strcpy(this->pName,stu.pName);

		// 返回对象本身
		return *this;
	}

	~Student()
	{
		if (pName != NULL)
		{
			delete[] pName;
			pName = NULL;
		}
	}

	void printName()
	{
		cout << pName << endl;
	}


private:
	char* pName;
};

void test01()
{
	Student s1("孙悟空");
	Student s2("hhhh");

	s1.printName();
	s2.printName();

	s1 = s2;// 需要重载赋值运算符  否则发生内存泄露

	s1.printName();
	s2.printName();


}

int main()
{
	test01();
	return EXIT_SUCCESS;
}

七、关系运算符


#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Maker {

public:
	Maker()
	{
		this->id = 0;
		this->age = 0;

	}
	Maker(int id,int age)
	{
		this->id = id;
		this->age = age;
	}

	// 关系运算符进行重载
	bool operator==(Maker& m)
	{
		if (this->id == m.getId() && this->age == m.getAge())
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	int getId()
	{
		return this->id;
	}

	int getAge()
	{
		return this->age;
	}


private:
	int id;
	int age;
};


void test01()
{
	Maker m(1,2);
	Maker m1(2,3);

	if (m1 == m)
	{
		cout << "相同" << endl;
	}
	else
	{
		cout << "不相同" << endl;
	}
}



int main()
{
	test01();
	return EXIT_SUCCESS;
}

八、前置加加运算符与后置加加运算符

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Maker {

	friend ostream& operator<<(ostream& out, Maker& m);

public:

	// 默认的构造函数
	Maker()
	{
		this->a = 0;
	}

	Maker(int a)
	{
		this->a = a;
	}

	// 重载前置加加
	Maker& operator++()
	{
		// 需要返回引用  不然返回的是一个新的Maker 对象
		++this->a;
		return *this;
	}

	// 重载后置加加
	Maker operator++(int)
	{	
		// 后置加加  先返回 后加加
		Maker tmp(*this);// *this 里面的值a等于2  调用拷贝构造函数 
		++this->a;// 后加加
		return tmp;
	}

	int getA()
	{
		return this->a;
	}

private:
	int a;

};

ostream& operator<<(ostream& out, Maker& m)
{
	//cout << m.getA() << endl；
	cout << m.a<< endl;// 声明为友元函数 才可以访问私有成员变量

	return out;
}

void test01()
{
	Maker m1(1);
	cout << m1 << endl;
	cout << ++m1 << endl;

	cout << m1++ << endl;// 返回的是temp对象  局部对象
	cout << m1 << endl;
}



int main()
{
	test01();
	return EXIT_SUCCESS;
}

九、数组下标重载

main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include<string>
#include"MyArray.h";

void printMyArray(MyArray& arr)
{
	for (int i = 0; i < arr.Size(); i++)
	{
		cout << arr.Get(i) << " ";
	}
	cout << endl;
}

void test01()
{
	MyArray arr;

	for (int i = 0; i < 20; i++)
	{

		arr[i] = i + 10;
	}

	MyArray arr2;
	arr2 = arr;

	for (int i = 0; i < 20; i++)
	{

		cout<<arr2[i] << endl;
	} 
}


int main()
{

	test01();

	return EXIT_SUCCESS;
}

MyArray.h

#pragma once
class MyArray
{
public:
	MyArray();// 无参构造函数声明
	MyArray(const MyArray& arr);// 拷贝构造声明
	MyArray(int capacity, int val = 0);// 有参构造函数

	// 重写赋值运算符重载函数
	MyArray& operator=(const MyArray& m);

	// 重载数组 下标
	int& operator[](int index);


	~MyArray();// 析构函数

	//头插
	void PushFront(int val);

	//尾插
	void PushBack(int val);

	// 头部删除
	void PopFront();

	// 尾部删除
	void PopBack();

	// 获取数组元素个数
	int Size();

	// 获取数组容量
	int Capacity();

	// 指定位置插入元素
	void Insert(int pos, int val);

	// 获取指定位置的值
	int& Get(int pos);

	// 在指定位置修改值
	void Set(int pos, int val);

private:
	int* pArray;// 指向堆区空间，存储数据 = new int[this->mCapacity]; 创建堆区数组
	int mSize;// 元素个数
	int mCapacity;// 容量
};

MyArray.cpp


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

MyArray::MyArray()
{
	this->mCapacity = 20;
	this->mSize = 0;

	// 创建堆区数组
	this->pArray = new int[this->mCapacity];

	// 数组元素全部初始化为0
	for (int i = 0; i < this->mCapacity; i++)
	{
		this->pArray[i] = 0;
	}
}

MyArray::~MyArray()
{
	if (this->pArray == NULL)
	{
		delete[] this->pArray;// 释放数组空间
		this->pArray = NULL;
	}
}

// 重写赋值运算符重载
MyArray& MyArray::operator=(const MyArray& m)
{
	// 首先释放原来的空间
	if (this->pArray != NULL)
	{
		delete[] this->pArray;
		this->pArray = NULL;
	}

	this->mCapacity = m.mCapacity;
	this->mSize = m.mSize;

	// 申请空间  
	this->pArray = new int[m.mCapacity];

	// 拷贝数据
	for (int i = 0; i < this->mCapacity; i++)
	{
		this->pArray[i] = m.pArray[i];
	}

	return *this;
}


// 重载数组 下标
int& MyArray::operator[](int index)
{
	// 赋值时 加加
	this->mSize++;
	return this->pArray[index];
}



// 拷贝构造函数的实现
MyArray::MyArray(const MyArray& arr)
{
	this->mCapacity = arr.mCapacity;
	this->mSize = arr.mSize;

	// 申请空间
	this->pArray = new int[arr.mCapacity];

	// 拷贝数据
	for (int i = 0; i < this->mSize; i++)
	{
		this->pArray[i] = arr.pArray[i];
	}
}

// 实现不能有默认参数
MyArray::MyArray(int capacity, int val)
{
	this->mCapacity = capacity;
	this->mSize = capacity;
	this->pArray = new int[capacity];
	for (int i = 0; i < this->mSize; i++)
	{
		this->pArray[i] = val;
	}
}

//头插
void MyArray::PushFront(int val)
{
	if (this->mSize == this->mCapacity)
	{
		return;// 数组满了
	}

	// 如果没有满 从数组最后一个元素开始向后移动元素
	for (int i = this->mSize - 1; i >= 0; i--)
	{
		this->pArray[i + 1] = this->pArray[i];
	}

	// 空出第一个位置
	this->pArray[0] = val;

	// 数组长度加一
	this->mSize++;
}

//尾插
void MyArray::PushBack(int val)
{
	if (this->mSize == this->mCapacity)
	{
		return;// 数组元素满
	}

	this->pArray[this->mSize] = val;
	this->mSize++;// 数组长度加一
}

// 头部删除
void MyArray::PopFront()
{
	if (this->mSize == 0)
	{
		return;// 数组元素为0
	}

	// 后面的数往前面移动来覆盖第一个元素
	for (int i = 0; i < this->mSize; i++)
	{
		this->pArray[i] = this->pArray[i + 1];
	}

	this->mSize--;
}

// 尾部删除
void MyArray::PopBack()
{
	// 这个只能在逻辑上进行删除
	if (this->mSize == 0)
	{
		return;
	}
	this->mSize--;
}

// 获取数组元素个数
int MyArray::Size()
{
	return this->mSize;
}

// 获取数组容量
int MyArray::Capacity()
{
	return this->mCapacity;
}


// 指定位置插入元素
void MyArray::Insert(int pos, int val)
{
	// 先判断容量是否已经满了
	if (this->mSize == this->mCapacity)
	{
		return;
	}

	// 如果位置不对  就插入尾部
	if (pos < 0 || pos > this->mSize - 1)
	{
		pos = this->mSize;
	}

	for (int i = this->mSize - 1; i >= pos; i--)
	{
		this->pArray[i + 1] = this->pArray[i];
	}

	this->pArray[pos] = val;
	this->mSize++;
}

// 获取指定位置的值
int& MyArray::Get(int pos)
{
	return this->pArray[pos];
}

// 在指定位置修改值
void MyArray::Set(int pos, int val) {

	if (pos < 0 || pos > this->mCapacity - 1)
	{
		return;
	}

	this->pArray[pos] = val;
}
少写代码少看论文多多睡觉
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
【C++】操作符重载
YJYS_ZHX的博客
03-05 873
注意：操作符重载可以当做==“自定义类的运算”== 1 为什么需要操作符重载？ 对于基础的变量，int等，不需要重载就知道如何做，但是对于自定义类，就无法进行运算，比如复数类。 2 操作符重载总结 1）操作符重载本质上是一个函数，可以采用 友元函数或者成员函数实现。但是采用这两种函数传递参数、实现代码、应用场合均不同。 全局函数与成员函数的比较： 全局函数中不传递this指针，成员函数默认传递this指针，因此成员函数可以少一个参数； 成员函数可以访问私有变量，全局函数需要转化为友元函数才可以。 2）操
一文详解C++字符编码的转换-综合文档
05-22
一文详解C++字符编码的转换
C++中的操作符重载
jquery教程
09-01 632
一、什么是操作符重载 操作符重载可以分为两部分：“操作符”和“重载”。说到重载想必都不陌生了吧，这是一种编译时多态，重载实际上可以分为函数重载和操作符重载。运算符重载和函数重载的不同之处在于操作符重载重载的一定是操作符。我们不妨先直观的看一下所谓的操作符重载： 1 #include 2 3 using namespace std; 4 5 int main() 6
【C++ | 重载运算符】一文弄懂C++运算符重载，怎样声明、定义运算符，重载为友元函数
最新发布
wkd_007的博客
06-21 2596
👉本文主要介绍了为什么需要重载运算符，重载运算符有哪些限制，怎样声明、定义运算符函数，怎样将运算符重载为友元函数。
操作符重载（C++）
runyeo的专栏
07-20 4664
[程序设计教程用c++语言编程陈家骏]1.成员函数重载操作符：除“.”，“*”，“::”，“？:”外其他操作符都可重载(1)a.双目操作符声明格式：class { operator #();}b.双目操作符定义格式： ::operator #(){}c.双目操作符使用格式： a; b;a # b或a.operator(b);(2)a.单目操作符重载声明格式：class {  operator #(
C++_操作符重载
weixin_50183638的博客
08-10 154
C++_操作符重载
c++操作符重载
hjxu2016的博客
09-03 3923
转自https://www.cnblogs.com/xudong-bupt/p/3557525.html 1.什么是操作符重载 　　可以使用分词将操作符重载理解为：操作符+重载。 　　C++中的操作符很多，如+，-，*，\等等。 　　C++中的重载也是C++中面向对象多态的体现。 　　简单说操作符重载： 　　　　C++中有：int a=2+3;　　那么a=5 　　　　操作符重载可以实...
一文详解CMOS模拟开关
01-20
CMOS（本意是指互补金属氧化物半导体——一种大规模应用于集成电路芯片制造的原料）是微机主板上的一块可读写的RAM芯片，用来保存当前系统的硬件配置和用户对某些参数的设定。CMOS可由主板的电池供电，即使系统掉电...
一文详解Spark基本架构原理
02-24
本文来自于简书，ApacheSpark是专为大规模数据处理而设计的快速通用的计算引擎。文章主要通过八个方面全面介绍了spark的架构原理，更多内容请看全文。ApacheSpark是一个围绕速度、易用性和复杂分析构建的大数据处理...
一文详解你不知道的3GPP
01-19
智能手机已经成为了我们日常生活中必不可少的一部分，根据消费者行为分析公司comScore的分析显示，普通消费者每天花费近3个小时通过智能手机使用流媒体、共享、通信和搜索等业务。下面就随网络通信小编一起来了解...
C++之操作符重载(+、-、*、/、=、==、!=)
雪狼的博客
07-25 2896
一、操作符重载的意义 　　C++中重载操作符能够扩展操作符的功能，操作符重载是以函数的方式进行的。其实操作符重载的本质为用特殊形式的函数扩展操作符的功能。 二、操作符重载的语法 　　重载操作符时是通过operator关键字来定义特殊的函数，其本质是通过函数重载操作符。其语法规则如下： Type operator Sign(const Type&amp; p1, const Type...
C++操作符重载
shadow_xwl的博客
07-03 5358
简要介绍了各种操作符的重载方式与实现
C++——操作符重载
jeremiah的博客
02-23 158
                类的操作符重载 ：关键字operator再加上需要被重载的操作符，如下代码实现将两个Emploee类的对象进行相加。                  #include &lt;stdio.h&gt; #include &lt;iostream&gt; #include &lt;string&gt; using namespace std; using std...
操作符重载
weixin_34075551的博客
10-01 133
    重载不能改变操作符的优先级   如果一个内建操作符是一元的，那么所有对它的重载仍是一元的。如果是二元的重载后也是二元的    下面看一个有代表性的例子：： 头文件Complex.h： #include &lt;iostream&gt;using namespace std; class Complex {public: 　　Complex();　　 Complex...
c++重载操作符
米碎师兄
01-03 1411
c++支持重载的操作符有算术操作符+、-、*、/、%关系操作符==、!逻辑操作符!、&&、||位操作符赋值操作符下标操作符[]函数调用操作符()成员访问操作符->指针操作符*(解引用)、&(取地址)逗号操作符这些操作符按照操作数个数不同分为单目操作符、双目操作符、多目操作符单目操作符!、~、->、*(解引用)、&(取地址)双目操作符其他多目操作符()为什么要按这个分类？别急，继续看...
C++运算符重载（操作符重载）
qq_41885018的博客
05-11 791
有时候我们需要让对象之间进行运算， C++ 提供的“运算符重载”机制，赋予运算符新的功能，就能解决用+将两个复数对象相加这样的问题。，因为左移运算符左边是cout，而想要调用类里的成员函数首先要是对象才行，而cout显然不是对象，括号运算符()也可以重载，对象名可以当成函数来使用（函数对象、仿函数）。除了 “ + ”，还有其他的运算符重载，如 “ - ”（减法运算）接着刚才的问题，我们利用运算符重载为运算符增加一些新的功能，，既可以接受const对象，也可以接受非const对象。
c++中的操作符重载
echo_bright_的博客
08-06 374
来讲讲c++强大特性之一，操作符重载。   中学时的数学课程学习的复数，其形式如a + bi(a、b均为实数)，其中a称为实部，b称为虚部，i称为虚数单位。复数和实数一样，可以进行加减乘除等运算。那么，我们可以构建一个复数类，如下。class ComplexNumber { public: int a; //实部 int b; //虚部 };  根据复数运算规则
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

少写代码少看论文多多睡觉

求打赏，求关注，求点赞

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

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

打赏作者

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

抵扣说明：

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

余额充值