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

最新推荐文章于 2025-05-25 07:46:20 发布
最新推荐文章于 2025-05-25 07:46:20 发布
阅读量844 收藏 3
点赞数 3
CC 4.0 BY-SA版权
分类专栏： Algorithm # Leetcode C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44653420/article/details/127188100
本文详细介绍了C++中的运算符重载技术，包括加号、减号、左移和右移等常见运算符的重载方法，并探讨了如何重载赋值运算符、关系运算符以及前置和后置加加运算符。此外，还展示了数组下标运算符的重载实例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一文详解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;
}
【C++】操作符重载
YJYS_ZHX的博客
03-05 966
注意：操作符重载可以当做==“自定义类的运算”== 1 为什么需要操作符重载？ 对于基础的变量，int等，不需要重载就知道如何做，但是对于自定义类，就无法进行运算，比如复数类。 2 操作符重载总结 1）操作符重载本质上是一个函数，可以采用 友元函数或者成员函数实现。但是采用这两种函数传递参数、实现代码、应用场合均不同。 全局函数与成员函数的比较： 全局函数中不传递this指针，成员函数默认传递this指针，因此成员函数可以少一个参数； 成员函数可以访问私有变量，全局函数需要转化为友元函数才可以。 2）操
【C++】详解运算符重载，赋值运算符重载，++运算符重载
2301_79796701的博客
04-18 2662
狂敲键盘，只为博君一笑
C++中的操作符重载
jquery教程
09-01 684
一、什么是操作符重载 操作符重载可以分为两部分：“操作符”和“重载”。说到重载想必都不陌生了吧，这是一种编译时多态，重载实际上可以分为函数重载和操作符重载。运算符重载和函数重载的不同之处在于操作符重载重载的一定是操作符。我们不妨先直观的看一下所谓的操作符重载： 1 #include 2 3 using namespace std; 4 5 int main() 6
C++ 重载详解
最新发布
a181001_的博客
05-25 976
C++重载提供了强大的表达能力，允许程序员为自定义类型提供自然的操作接口。合理使用重载可以显著提高代码的可读性和易用性，但应避免滥用导致代码难以理解。
操作符重载（C++）
runyeo的专栏
07-20 4733
[程序设计教程用c++语言编程陈家骏]1.成员函数重载操作符：除“.”，“*”，“::”，“？:”外其他操作符都可重载(1)a.双目操作符声明格式：class { operator #();}b.双目操作符定义格式： ::operator #(){}c.双目操作符使用格式： a; b;a # b或a.operator(b);(2)a.单目操作符重载声明格式：class {  operator #(
C++_操作符重载
会选科技的博客
08-10 225
C++_操作符重载
c++操作符重载
hjxu2016的博客
09-03 4032
转自https://www.cnblogs.com/xudong-bupt/p/3557525.html 1.什么是操作符重载 　　可以使用分词将操作符重载理解为：操作符+重载。 　　C++中的操作符很多，如+，-，*，\等等。 　　C++中的重载也是C++中面向对象多态的体现。 　　简单说操作符重载： 　　　　C++中有：int a=2+3;　　那么a=5 　　　　操作符重载可以实...
一文吃透C++字符串：概念与实操指南
大雨的博客
03-15 1486
在 C++ 中，字符串是由一系列字符组成的序列，用于存储文本信息。C++ 标准库提供了多种方式来处理字符串，其中最常见的是使用std::string类。std::string是一个动态数组，可以自动管理内存，并且提供了丰富的成员函数来操作字符串，这使得它在处理字符串时比传统的 C 风格字符串更加方便和安全 。
【C++】详解STL的容器之一：list
2301_79796701的博客
05-05 1883
本篇的内容有：list简单的介绍，形象化的模型，优缺点，源码思路，模拟实现。希望本篇内容能帮助读者更好的认识list
Ubuntu VS Code C_C++插件高级用法：一文掌握关键特性
[Ubuntu VS Code C_C++插件高级用法：一文掌握关键特性](https://blog.jetbrains.com/wp-content/uploads/2021/03/notify_with.png) # 摘要 本文详细介绍了在Ubuntu系统上使用VS Code作为集成开发环境的基础搭建，...
一文带你理解虚函数、纯虚函数 (以程序实例详解区分)
qq_36698189的博客
03-31 721
文章目录1、多态与虚函数静态联编动态联编**实现动态联编必须满足以下3个条件：**为什么需要虚函数2、虚函数的访问对象名访问基指针访问引用访问3、纯虚函数与抽象类纯虚函数声明和定义抽象类 1、多态与虚函数 多态性：指同一个操作作用于不同的对象就会产生不同的响应。 多态性分为静态多态性和动态多态性，其中函数重载和运算符重载属于静态多态性，虚函数属于动态多态性。 C++是依靠虚函数来实现动态和多态的。 静态联编 以函数重载为例，C++编译器根据传递给函数的参数和函数名决定具体要使用哪一个函数，称为联编。 编译器
C++之操作符重载(+、-、*、/、=、==、!=)
雪狼的博客
07-25 3124
一、操作符重载的意义 　　C++中重载操作符能够扩展操作符的功能，操作符重载是以函数的方式进行的。其实操作符重载的本质为用特殊形式的函数扩展操作符的功能。 二、操作符重载的语法 　　重载操作符时是通过operator关键字来定义特殊的函数，其本质是通过函数重载操作符。其语法规则如下： Type operator Sign(const Type&amp; p1, const Type...
C++操作符重载
shadow_xwl的博客
07-03 5577
简要介绍了各种操作符的重载方式与实现
C++——操作符重载
jeremiah的博客
02-23 236
                类的操作符重载 ：关键字operator再加上需要被重载的操作符，如下代码实现将两个Emploee类的对象进行相加。                  #include &lt;stdio.h&gt; #include &lt;iostream&gt; #include &lt;string&gt; using namespace std; using std...
操作符重载
weixin_34075551的博客
10-01 181
    重载不能改变操作符的优先级   如果一个内建操作符是一元的，那么所有对它的重载仍是一元的。如果是二元的重载后也是二元的    下面看一个有代表性的例子：： 头文件Complex.h： #include &lt;iostream&gt;using namespace std; class Complex {public: 　　Complex();　　 Complex...
C++运算符重载（操作符重载）
qq_41885018的博客
05-11 3350
有时候我们需要让对象之间进行运算， C++ 提供的“运算符重载”机制，赋予运算符新的功能，就能解决用+将两个复数对象相加这样的问题。，因为左移运算符左边是cout，而想要调用类里的成员函数首先要是对象才行，而cout显然不是对象，括号运算符()也可以重载，对象名可以当成函数来使用（函数对象、仿函数）。除了 “ + ”，还有其他的运算符重载，如 “ - ”（减法运算）接着刚才的问题，我们利用运算符重载为运算符增加一些新的功能，，既可以接受const对象，也可以接受非const对象。
c++重载操作符
米碎师兄
01-03 2217
c++支持重载的操作符有算术操作符+、-、*、/、%关系操作符==、!逻辑操作符!、&&、||位操作符赋值操作符下标操作符[]函数调用操作符()成员访问操作符->指针操作符*(解引用)、&(取地址)逗号操作符这些操作符按照操作数个数不同分为单目操作符、双目操作符、多目操作符单目操作符!、~、->、*(解引用)、&(取地址)双目操作符其他多目操作符()为什么要按这个分类？别急，继续看...
C++指针操作详解：数组元素与内存地址
在《通过指针引用数组元素 - C++程序设计谭浩强》一文中，主要讨论了C++中指针的概念及其在数组操作中的应用。C++是基于C语言发展起来的，它强调了结构化编程、灵活性和效率。以下知识点详述： 1. **指针基础**: -...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

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

求打赏，求关注，求点赞

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

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

打赏作者

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

抵扣说明：

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

余额充值