C++类与对象之运算符重载详解

目录
  • 运算符重载
  • 加号运算符重载
  • 左移运算符重载
  • 递增运算符重载
  • 递减运算符重载
  • 赋值运算符重载
  • 关系运算符重载
  • 函数调用运算符重载
  • 总结

运算符重载

运算符重载概念:对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型

加号运算符重载

作用:实现两个自定义数据类型相加的运算

#include <iostream>
using namespace std;
class Person {
public:
	// 构造函数
	Person(int num1, int num2){
		this->num1 = num1;
		this->num2 = num2;
	}
	// 加法函数
	Person operator+(const Person &p){
		Person temp(0, 0);
		temp.num1 = this->num1 + p.num1;
		temp.num2 = this->num2 + p.num2;
		return temp;
	}
	// 打印输出
	void printMessage() {
		cout << "num1 = " << num1 << " num2 = " << num2 << endl;
	}
private:
	int num1;
	int num2;
};
void func() {
	Person p1(1, 2);
	Person p2(3, 4);
	Person p3 = p1.operator+(p2); // 可以简化为 Person = p1 + p2;
	p3.printMessage(); // num1 = 4 num2 = 6
	Person p4 = p3 + p2;
	p4.printMessage(); // num1 = 7 num2 = 10
}
int main() {
	func();
	system("pause");
	return 0;
}

左移运算符重载

作用:输出自定义数据类型

第一种:成员函数(对象 << cout)

#include <iostream>
using namespace std;
class Person {
public:
	// 构造函数
	Person(int num1, int num2){
		this->num1 = num1;
		this->num2 = num2;
	}
	// 左移运算符 p.operator<<(cout); 简化版本 p << cout
	void operator <<(ostream &cout) {
		cout << "num1 = " << num1 << " num2 = " << num2 << endl;
	}
private:
	int num1;
	int num2;
};
void func() {
	Person p1(1, 2);
	p1.operator<<(cout); // 简化为 p1 << cout
	Person p2(3, 4);
	p2 << cout;
}
int main() {
	func();
	// outputs:num1 = 1 num2 = 2
	//		   num1 = 3 num2 = 4
	system("pause");
	return 0;
}

第二种:全局函数(cout << 对象)

#include <iostream>
using namespace std;
class Person {
	// 友元
	friend ostream& operator <<(ostream &cout, Person &p);
public:
	// 构造函数
	Person(int num1, int num2){
		this->num1 = num1;
		this->num2 = num2;
	}
private:
	int num1;
	int num2;
};
// 左移运算符 p.operator<<(cout); 简化版本 p << cout
ostream& operator <<(ostream &cout, Person &p) {
	cout << "num1 = " << p.num1 << " num2 = " << p.num2;
	return cout;
}
void func() {
	Person p1(1, 2);
	operator<<(cout, p1); // 简化为 cout << p1;
	cout << endl;
	cout << p1 << " 你是猪!" << endl;
}
int main() {
	func();
	// outputs:num1 = 1 num2 = 2
	//		   num1 = 1 num2 = 2 你是猪!
	system("pause");
	return 0;
}

递增运算符重载

通过重载递增运算符,实现自己的整型数据

#include <iostream>
using namespace std;
class MyInteger {
	//friend ostream& operator <<(ostream &cout, MyInteger &p);
	friend ostream& operator <<(ostream &cout, MyInteger p);
public:
	// 构造函数
	MyInteger(){
		this->m_num = 0;
	}
	// 重载前置递增运算符
	MyInteger& operator++() {
		++this->m_num;
		return *this;
	}
	// 重载后置递增运算符
	MyInteger operator++(int) { // int 是占位参数,用于区分前置和后置递增
		MyInteger temp = *this;
		++this->m_num;
		return temp;
	}
private:
	int m_num;
};
// 用于前置递增,左移运算符 p.operator<<(cout); 简化版本 p << cout
//ostream& operator <<(ostream &cout, MyInteger &p) {
//	cout << "m_num = " << p.m_num;
//	return cout;
//}
// 用于后置递增,左移运算符 p.operator<<(cout); 简化版本 p << cout
ostream& operator <<(ostream &cout, MyInteger p) {
	cout << "m_num = " << p.m_num;
	return cout;
}
void func() {
	MyInteger m_int;
	//cout << m_int.operator++() << endl; // m_num = 1
	//cout << ++m_int << endl; // m_num = 2
	cout << m_int++ << endl; // m_num = 0
	cout << m_int << endl; // m_num = 1
}
int main() {
	func();
	system("pause");
	return 0;
}

递减运算符重载

通过重载递减运算符,实现自己的整型数据

#include <iostream>
using namespace std;
class MyInteger {
	friend ostream& operator <<(ostream &cout, MyInteger &p);
	//friend ostream& operator <<(ostream &cout, MyInteger p);
public:
	// 构造函数
	MyInteger(){
		this->m_num = 0;
	}
	// 重载前置递减运算符
	MyInteger& operator--() {
		--this->m_num;
		return *this;
	}
	// 重载后置递减运算符
	MyInteger operator--(int) { // int 是占位参数,用于区分前置和后置递增
		MyInteger temp = *this;
		--this->m_num;
		return temp;
	}
private:
	int m_num;
};
// 用于前置递减,左移运算符 p.operator<<(cout); 简化版本 p << cout
ostream& operator <<(ostream &cout, MyInteger &p) {
	cout << "m_num = " << p.m_num;
	return cout;
}
// 用于后置递减,左移运算符 p.operator<<(cout); 简化版本 p << cout
//ostream& operator <<(ostream &cout, MyInteger p) {
//	cout << "m_num = " << p.m_num;
//	return cout;
//}
void func() {
	MyInteger m_int;
	cout << m_int.operator--() << endl; // m_num = -1
	cout << --m_int << endl; // m_num = -2
	//cout << m_int-- << endl; // m_num = 0
	//cout << m_int << endl; // m_num = -1
}
int main() {
	func();
	system("pause");
	return 0;
}

赋值运算符重载

C++ 编译器至少给一个类添加 4 个函数(此处不举例,具体可见核心篇 5)

#include <iostream>
using namespace std;
class Student {
public:
	// 构造函数
	Student(int id) {
		m_id = new int(id); // 从堆区开辟内存用来存储 id
	}
	// 拷贝构造函数
	Student(const Student &s) {
		this->m_id = new int(*s.m_id);
	}
	// 析构函数
	~Student() {
		if (m_id != NULL) {
			delete m_id;
			m_id = NULL;
		}
	}
	// 重载赋值运算符
	Student& operator=(Student &s) {
		if (m_id != NULL) {
			delete m_id;
			m_id = NULL;
		}
		m_id = new int(*s.m_id);
		return *this;
	}
	// 取出 id
	int getId() {
		return *m_id;
	}
private:
	int *m_id;
};
void func() {
	Student s1(1);
	cout << s1.getId() << endl; // 1
	// 用拷贝构造函数来作深拷贝
	Student s2(s1);
	cout << s2.getId() << endl; // 1
	// 用赋值重载运算符来作赋值
	Student s3(2); // id 为 2
	s1 = s3; // 复杂版本:s1.operator=(s3)
	cout << s1.getId() << endl; // 2
	// 多段赋值运算符,例如 a = b = c
	Student s4(3);
	s1 = s2 = s3 = s4; // id 均为 3
	cout << s1.getId() << s2.getId() << s3.getId() << s4.getId() << endl; // 3333
}
int main() {
	func();
	system("pause");
	return 0;
}

关系运算符重载

重载关系运算符,可以让两个自定义数据类型对象进行对比操作

#include <iostream>
using namespace std;
class Student {
public:
	// 构造函数
	Student(int id) {
		m_id = new int(id); // 从堆区开辟内存用来存储 id
	}
	// 拷贝构造函数
	Student(const Student &s) {
		this->m_id = new int(*s.m_id);
	}
	// 析构函数
	~Student() {
		if (m_id != NULL) {
			delete m_id;
			m_id = NULL;
		}
	}
	// 重载 == 运算符
	bool operator==(Student &s) {
		if (this->getId() == s.getId()) {
			return true;
		}
		else {
			return false;
		}
	}
	// 取出 id
	int getId() {
		return *m_id;
	}
private:
	int *m_id;
};
void func() {
	Student s1(1);
	Student s2(1);
	Student s3(2);
	if (s1 == s2) {
		cout << "s1 和 s2 相等" << endl;
	}
	if (s1 == s3) {
		cout << "s1 和 s3 相等" << endl;
	}
	else {
		cout << "s1 和 s3 不相等" << endl;
	}
}
int main() {
	func();
	// outputs:s1 和 s2 相等
	//		   s1 和 s3 不相等
	system("pause");
	return 0;
}

函数调用运算符重载

特点:函数调用运算符 () 也可以重载;重载后调用的方式很像函数,被称为仿函数;没有固定写法,非常灵活

#include <iostream>
using namespace std;
#include <string>
class Print {
public:
	void operator()(string text) {
		cout << "利用函数调用重载运算符打印输出:" << text << endl;
	}
};
void func() {
	Print p1;
	p1("你是一个小猪猪!"); // 利用函数调用重载运算符打印输出:你是一个小猪猪!
}
int main() {
	func();
	// outputs:s1 和 s2 相等
	//		   s1 和 s3 不相等
	system("pause");
	return 0;
}

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • C++双目运算符+=的重载详解

    目录 1.+=重载 2.friend重载+= 3.运算符 3.1 单目运算符 3.2 双目运算符 3.3 三目运算符 4.重载++和重载- - 总结 1.+=重载 class Complex { public: Complex(int a, int b) : _a(a) , _b(b) {} Complex& operator+= (Complex& other) { this->_a += other._a; this->_b += other._b; return *thi

  • C++11运算符重载和向量类重载实例详解(<<,>>,+,-,*等)

    目录 1. C++运算符重载介绍 1.1 单目运算符与双目运算符 1.2 友元运算符 2. 实例讲解 2.1 头文件定义 2.2 实现运算符重载 总结 1. C++运算符重载介绍 C ++ 中预定义的运算符的操作对象只能是基本数据类型.但实际上,对于许多用户自定义类型(例如类),也需要类似的运算操作.这时就必须在C ++ 中重新定义这些运算符,赋予已有运算符新的功能,使它能够用于特定类型执行特定的操作.运算符重载的实质是函数重载,它提供了C ++ 的可扩展性,也是C ++ 最吸引人的特性之一.

  • C++运算符重载图文详解

    目录 1. 运算符重载 1.1 运算符重载为普通函数 1.2 运算符重载为成员函数 2. 赋值运算符=的重载 2.1浅复制与深复制 2.2返回值的讨论 3. 动态可变长度数组 总结 1. 运算符重载 C++的运算符只能用于基本的数据类型 表达形式 返回值类型 operator 运算符 (形参表) { ... } 1.1 运算符重载为普通函数 1.2 运算符重载为成员函数 2. 赋值运算符=的重载 当赋值运算符两边的类型不匹配,比如int类型赋值给Complex类型,在这种情况下,就需要重载赋值运

  • C++中运算符重载详解及其作用介绍

    目录 概述 函数重载 运算符重载 C++ 的运算符 重载运算符的规则 成员函数实现 Complex 加法 运算符重载的方法 多种实现方法 实现 operator+= 三种运算符重载函数 成员函数实现 友元函数实现 输出结果 重载单元运算符 例子 重载二元运算符 例子 重载 I/O 插入运算符 << 提取运算符 >> 总结 概述 运算符重载 (Operator Overloading) 函数重载 重载: 将同一名字重新赋予新的含义. 函数重载: 对一个函数赋予新的含义, 使之实现新功

  • 一篇文章带你了解c++运算符重载

    目录 友元函数 重载:复合赋值 Operator pairings 自增自减运算符的重载 c++20,spaceship operator 总结 友元函数 一种全局函数,可以在类里声明,其他地方定义.或者在类里定义生命. 但是这个友元函数,不是类的成员.用的时候直接用,但是可以接触类的所有权限的变量. 对于,重载操作符来说,可以把一些重载体函数定义为友元函数. 具体来说,如果进行运算的这两个类,是对等的,没有修改任一个的值,那么,建议用友元. 如果,类似=,是赋值,对左边的变量做修改了.那么这时

  • C++类与对象之运算符重载详解

    目录 运算符重载 加号运算符重载 左移运算符重载 递增运算符重载 递减运算符重载 赋值运算符重载 关系运算符重载 函数调用运算符重载 总结 运算符重载 运算符重载概念:对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型 加号运算符重载 作用:实现两个自定义数据类型相加的运算 #include <iostream> using namespace std; class Person { public: // 构造函数 Person(int num1, int num2){ thi

  • Python的运算符重载详解

    一.前言 运算符重载:为运算符定义方法 所谓重载,就是赋予新的含义同一个运算符可以有不同的功能 二.重载作用 让自定义的实例像内建对象一样进行运算符操作让程序简介易读对自定义对象将运算符赋予新的规则 运算符和特殊方法 运算符重载 # @function:运算符重载 # @Description: 一只萤火虫 class MyInteger: """ 创建一个自定义的整数类型 """ def __init__(self, data=0): # 1.

  • C++中的运算符重载详解

    目录 1.引例 2.类中自动建立的函数 3.重载赋值运算符解析 总结 1.引例 class Complex { private: double Real,Image; public: Complex():Real(0),Image(0) {} Complex(double r, double i) : Real(r),Image(i) {} ~Complex() {} }; int main() { Complex c1(1.2,2.3); Complex c2(45,56); Complex

  • Python入门教程之运算符重载详解

    目录 如何重载Python中的运算符 在 Python中重载比较运算符 重载相等和小于运算符 用于运算符重载的 Python 魔术方法或特殊函数 二元运算符 比较运算符 赋值运算符 一元运算符 运算符重载意味着赋予超出其预定义的操作含义的扩展含义.例如运算符 + 用于添加两个整数以及连接两个字符串和合并两个列表.这是可以实现的,因为 '+' 运算符被 int 类和 str 类重载.您可能已经注意到,相同的内置运算符或函数对不同类的对象显示不同的行为,这称为运算符重载. # Python 程序显示

  • Python运算符重载详解及实例代码

    Python运算符重载 Python语言提供了运算符重载功能,增强了语言的灵活性,这一点与C++有点类似又有些不同.鉴于它的特殊性,今天就来讨论一下Python运算符重载. Python语言本身提供了很多魔法方法,它的运算符重载就是通过重写这些Python内置魔法方法实现的.这些魔法方法都是以双下划线开头和结尾的,类似于__X__的形式,python通过这种特殊的命名方式来拦截操作符,以实现重载.当Python的内置操作运用于类对象时,Python会去搜索并调用对象中指定的方法完成操作. 类可以

  • C++中的四个默认成员函数与运算符重载详解

    本文主要给大家介绍了关于C++默认成员函数与运算符重载的相关内容,分享出来公的敬爱啊参考学习,话不多说,来一起看看详细的介绍: 一:类和对象的基础知识:类的定义,访问限定符,面向对象封装性,对象的大小计算等等.(编译环境为VS2015) 面向对象程序设计: 概念:(Object Oriented Programming,缩写:OOP)是一种程序设计范型,同时也是一种程序开发的方法.对象指的是类的实例,将对象作为程序的基本单元,将程序和数据封装其中,以提高软件的重用性.灵活性和扩展性. 类:类的基

  • Javascript实现运算符重载详解

    最近要做数据处理,自定义了一些数据结构,比如Mat,Vector,Point之类的,对于加减乘除之类的四则运算还要重复定义,代码显得不是很直观,javascript没有运算符重载这个像C++.C#之类的功能的确令人不爽,于是想"曲线救国",自动将翻译代码实现运算符重载,实现思路其实很简单,就是编写一个解释器,将代码编译.例如: S = A + B (B - C.fun())/2 + D 翻译成 `S = replace(replace(A, '+', replace(replace(B

  • Python编程基础之运算符重载详解

    目录 学习目标 一.运算符重载 (一)概述 (二)加法运算重载符 1.概述 2.案例演示 总结 学习目标 1.掌握运算符重载 2.会定制对象字符串的形式 一.运算符重载 (一)概述 运算符重载是通过实现特定的方法使类的实例对象支持Python的各种内置操作 .例如:+运算符是类里提供的__add__这个函数,当调用+实现加法运算的时候,实际上是调用了__add__方法. 方法 说明 何时调用方法 __add__ 加法运算 对象加法:x+y,x+=y __sub__ 减法运算 对象减法:x-y,x

  • C++基础知识之运算符重载详解

    目录 运算符重载 方式一,使用成员函数重载运算符需求:把牛肉换猪肉,羊肉换猪肉 方式二,使用非成员函数[友元函数]重载运算符 两种方式的区别 两种方式的选择: 总结 运算符重载 为什么要使用运算符重载 -C/C++的运算符,支持的数据类型,仅限于基本数据类型. 问题:一头牛+一头马 = ?(牛马神兽?) 一个圆 +一个圆 = ? (想要变成一个更大的圆)一头牛 – 一只羊 = ? (想要变成4只羊,原始的以物易物:1头牛价值5只羊) 解决方案: 使用运算符重载 方式一, 使用成员函数重载运算符

随机推荐