C++操作符重载

最新推荐文章于 2024-02-04 08:07:25 发布
最新推荐文章于 2024-02-04 08:07:25 发布
阅读量516 收藏 1
点赞数 1
分类专栏： C++笔记 文章标签： MFC C++基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuyi1207164339/article/details/47082463
版权

Matrix.h

#pragma once
#include "vector"
#include "iostream"
#define rep(i,n) for(int i=1;i<=n;i++) //宏定义for循环，精简代码
using namespace std;
class Matrix
{
public:
	//基本构造函数
	Matrix(int Row=0, int Column=0);
	//拷贝构造函数或者复制构造函数
	Matrix(const Matrix& matrix);
	//赋值操作符重载，必须为成员函数，不然会报错
    Matrix& operator=(const Matrix& matrix);
	//复合赋值操作符重载，建议重载为成员函数
	Matrix& operator+=(const Matrix& matrix);
	Matrix& operator*=(const Matrix& matrix);
	Matrix& operator*=(const float& number);
	Matrix& operator*=(const int& number);
	Matrix& operator-=(const Matrix& matrix);
	Matrix& operator/=(const float& number);
	float& operator[](const size_t& index);
	Matrix& operator++();//前缀式自增
	Matrix& operator--();//前缀式自减
	Matrix operator++(int); //后缀式自增
	Matrix operator--(int); //后缀式自减
	//算术和关系操作符一般为非成员函数，声明为友元
	friend Matrix operator+(const Matrix& matrix1, const Matrix& matrix2);
	friend Matrix operator-(const Matrix& matrix1, const Matrix& matrix2);
	friend Matrix operator*(const Matrix& matrix1, const Matrix& matrix2);
	friend Matrix operator*(const Matrix& matrix1, const float& number);
	friend Matrix operator*(const Matrix& matrix1, const int& number);
	friend bool operator==(const Matrix& matrix1, const Matrix& matrix2);
	friend bool operator!=(const Matrix& matrix1, const Matrix& matrix2);
	//输出操作符<<的重载,必须声明为友元
	friend ostream& operator<<(ostream& os, const Matrix&object);
	//输入操作符>>重载，必须声明为友元
	friend istream& operator >>(istream& in,Matrix&object);
	void Display();
	~Matrix();
public:
	int Row;
	int Column;
	vector<vector<float> > data; //二维vector，用于存放矩阵类数据
};

Matrix.cpp 

#include "stdafx.h"
#include "Matrix.h"
#include "iomanip"
//构造函数
Matrix::Matrix(int Row/* =0 */, int Column/* =0 */){
	this->Row = Row;
	this->Column = Column;
	data.resize(Row + 1); //申请行数为row+1，0号位不用
	rep(i, Row)
		data[i].resize(Column + 1); //申请各行的列数
	rep(i, Row)
		rep(j, Column)
		data[i][j] = 0; //每个元素初始化为0，方便后面计算
}
//打印函数
void Matrix::Display(){
	rep(i, Row)
	{
		rep(j, Column)
			cout << setw(8) << data[i][j] << ' ';
		cout <<endl;
	}
}
//拷贝构造函数
Matrix::Matrix(const Matrix& matrix){
	Row = matrix.Row;
	Column = matrix.Column;
	data.resize(Row+1); //申请行数为row，0号位不用
	rep(i, Row)
		data[i].resize(Column+1); //申请各行的列数
	rep(i, Row)
		rep(j, Column)
		data[i][j] = matrix.data[i][j];
}
//赋值操作符重载
Matrix& Matrix::operator=(const Matrix& matrix){
	if (this==&matrix)
	{
		return *this;
	}
	Row = matrix.Row;
	Column = matrix.Column;
	//分配资源
	data.resize(Row + 1); //申请行数为row+1，0号位不用
	rep(i, Row)
		data[i].resize(Column + 1); //申请各行的列数
	rep(i, Row)
		rep(j, Column)
		data[i][j] = matrix.data[i][j];
	//返回本对象的引用
	return *this;
}
//复合赋值操作符重载
Matrix& Matrix::operator+=(const Matrix& matrix){
	if (Row == matrix.Row&&Column == matrix.Column)
	{
		rep(i, Row)
		{
			rep(j,Column)
			{
				data[i][j] += matrix.data[i][j];
			}
		}
	}
	return *this;
}
Matrix& Matrix::operator-=(const Matrix& matrix){
	if (Row == matrix.Row&&Column == matrix.Column)
	{
		rep(i, Row)
		{
			rep(j, Column)
			{
				data[i][j] -= matrix.data[i][j];
			}
		}
	}
	return *this;
}
Matrix& Matrix::operator*=(const float& number){
	rep(i, Row)
	{
		rep(j, Column)
		{
			data[i][j] = data[i][j] * number;
		}
	}
	return *this;
}
Matrix& Matrix::operator*=(const int& number){
	rep(i, Row)
	{
		rep(j, Column)
		{
			data[i][j] = data[i][j] * number;
		}
	}
	return *this;
}
Matrix& Matrix::operator*=(const Matrix& matrix){
	//先保存矩阵的值
	Matrix temp(Row, Column);
	rep(i, temp.Row)
	{
		rep(j, temp.Column)
		{
			temp.data[i][j] = data[i][j];
		}
	}
	//改变矩阵的大小和值
	Column = matrix.Column;
	data.clear();        //清除数据
	data.resize(Row+1); //申请行数为row+1，0号位不用
	rep(i, Row)
		data[i].resize(Column+1); //申请各行的列数
	//重新给矩阵赋值
	rep(i, temp.Row)
	{
		rep(j, matrix.Column)
		{
			double sum = 0;
			rep(k, temp.Column)
				sum += temp.data[i][k] * matrix.data[k][j];
			data[i][j] = sum; //改变矩阵的值
		}
	}
	return *this;
}
Matrix& Matrix::operator/=(const float& number){
	rep(i, Row)
	{
		rep(j, Column)
		{
			data[i][j] = data[i][j] / number;
		}
	}
	return *this;
}
//前缀式自增
Matrix& Matrix::operator++(){
	//对每个元素都加1
	rep(i, Row)
	{
		rep(j, Column)
		{
			data[i][j] +=1;
		}
	}
	return *this;
}
//前缀式自减
Matrix& Matrix::operator--(){
	//对每个元素都减1
	rep(i, Row)
	{
		rep(j, Column)
		{
			data[i][j] -= 1;
		}
	}
	return *this;
}
//后缀式自增
Matrix Matrix::operator++(int){
	//拷贝构造函数
	Matrix ret(*this);
	//对每个元素都加1
	rep(i, Row)
	{
		rep(j, Column)
		{
			data[i][j] += 1;
		}
	}
	return ret;
}
//后缀式自减
Matrix Matrix::operator--(int){
	//拷贝构造函数
	Matrix ret(*this);
	//对每个元素都减1
	rep(i, Row)
	{
		rep(j, Column)
		{
			data[i][j] -= 1;
		}
	}
	return ret;
}
//析构函数
Matrix::~Matrix()
{
	data.clear();
}
//加法操作符重载
Matrix operator+(const Matrix& matrix1, const Matrix& matrix2){
	Matrix temp(matrix1.Row, matrix1.Column);
	if (matrix1.Row == matrix2.Row&&matrix1.Column == matrix2.Column)
	{
		rep(i, matrix1.Row)
		{
			rep(j, matrix2.Column)
			{
				temp.data[i][j] = matrix1.data[i][j]+matrix2.data[i][j];
			}
		}
	}
	return  temp;
}
//减法操作符重载
Matrix operator-(const Matrix& matrix1, const Matrix& matrix2){
	Matrix temp(matrix1.Row, matrix1.Column);
	if (matrix1.Row == matrix2.Row&&matrix1.Column == matrix2.Column)
	{
		rep(i, matrix1.Row)
		{
			rep(j, matrix2.Column)
			{
				temp.data[i][j] = matrix1.data[i][j] - matrix2.data[i][j];
			}
		}
	}
	return  temp;
}
//乘法操作符重载
Matrix operator*(const Matrix& matrix1, const Matrix& matrix2){
	Matrix temp(matrix1.Row, matrix2.Column);
	rep(i, temp.Row)
	{
		rep(j, temp.Column)
		{
			double sum = 0;
			rep(k, matrix1.Column)
				sum += matrix1.data[i][k] * matrix2.data[k][j];
			temp.data[i][j] = sum;
		}
	}
	return temp;
}
//乘法操作符重载
Matrix operator*(const Matrix& matrix1, const float& number){
	Matrix temp(matrix1.Row, matrix1.Column);
	rep(i, temp.Row)
	{
		rep(j, temp.Column)
		{
			temp.data[i][j] = matrix1.data[i][j]* number;
		}
	}
	return temp;
}
//乘法操作符重载
Matrix operator*(const Matrix& matrix1, const int& number){
	Matrix temp(matrix1.Row, matrix1.Column);
	rep(i, temp.Row)
	{
		rep(j, temp.Column)
		{
			temp.data[i][j] = matrix1.data[i][j] * number;
		}
	}
	return temp;
}
//等于关系操作符重载
bool operator==(const Matrix& matrix1, const Matrix& matrix2){
	//只有维数相等才有可比性
	if (matrix1.Row==matrix2.Row&&matrix1.Column==matrix2.Column)
	{
		rep(i, matrix1.Row)
		{
			rep(j, matrix1.Column)
			{
				if (matrix1.data[i][j]!=matrix2.data[i][j])
				{
					return false;
				}
			}
		}
		return true;
	}
	else
	{
		return false;
	}	
}
//不等于关系操作符重载
bool operator!=(const Matrix& matrix1, const Matrix& matrix2){
	//只有维数相等才有可比性
	if (matrix1.Row == matrix2.Row&&matrix1.Column == matrix2.Column)
	{
		rep(i, matrix1.Row)
		{
			rep(j, matrix1.Column)
			{
				if (matrix1.data[i][j] != matrix2.data[i][j])
				{
					return true;
				}
			}
		}
		return false;
	}
	else
	{
		return false;
	}
}
//输出操作符重载
ostream& operator<<(ostream& os, const Matrix&object){

	rep(i, object.Row)
	{
		rep(j, object.Column)
			os << setw(8) << object.data[i][j] << ' ';
		os <<endl;
	}
	return os;
}
//输入操作符重载
istream& operator >>(istream& in, Matrix&object){
	rep(i, object.Row)
		rep(j, object.Column)
		in >> object.data[i][j];
	return in;
}

main.c 

#include "iostream"
#include "Matrix.h"
using namespace std;
int main(){
	int row1, row2, col1, col2;
	cout << "请输入第一个矩阵的行和列:\n";
	cin >> row1 >> col1;
	Matrix m1(row1, col1);
	cout << "请输入" << row1 << '*' << col1 << "个数:\n";
	cin >> m1;
	cout << "输出矩阵的值:\n";
	cout << m1;
	cout << "请输入第二个矩阵的行和列:\n";
	cin >> row2 >> col2;
	Matrix m2(row2, col2);
	cout << "请输入" << row2 << '*' << col2 << "个数:\n ";
	cin >> m2;
	cout << "输出矩阵的值:\n";
	cout << m2;
	if (col1 != row2)
		cout << "这两个矩阵无法相乘\n";
	else
	{
		cout << "判断矩阵m1与m2是否相等：\n";
		if (m1==m2)
		{
			cout << "m1和m2相等：\n";
		}
		else
		{
			cout << "m1和m2不相等：\n";
		}

		cout << "m1拷贝构造m3矩阵结果输出：\n";
		Matrix m3(m1);
		cout << m3;

		cout << "m1赋值重载m4矩阵结果输出：\n";
		Matrix m4(m1.Row,m1.Column);
		m4 = m1;
		cout << m4;

		cout << "m1*m2矩阵相乘输出m5：\n";
		Matrix m5(m1.Row, m2.Column);
		m5 = m1*m2;
		cout << m5;

		cout << "矩阵m1*2输出m6：\n";
		Matrix m6(m1.Row, m1.Column);
		m6 = m1*2;
		cout << m6;

		cout << "矩阵m1*0.5输出m7：\n";
		Matrix m7(m1.Row, m1.Column);
		m7 = m1 * 0.5;
		cout << m7;

		cout << "m1*m2矩阵相乘输出m1：\n";
		m1 *= m2;
		cout << m1;

		cout << "m1矩阵前自增输出\n";
		cout << ++m1;

		cout << "m1矩阵后自增输出\n";
		cout << m1++;

		cout << "m1矩阵输出\n";
		cout << m1;

		cout << "m1矩阵前自减输出\n";
		cout << --m1;

		cout << "m1矩阵后自减输出\n";
		cout << m1--;

		cout << "m1矩阵输出\n";
		cout << m1;
	}
	return 0;
}
输出结果：



liuyi1207164339
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 操作符重载
Chroniccandy的博客
10-03 1634
输出操作符"<<" 和输入操作运算符">>" 在C++中，左移运算符<<可以和cout一起输出,因此也常被称为"流插入运算符",或"输出运算符"。 但实际上！<<本来没有这样的功能,之所以能和cout一起使用来输出数据，是因为此<<操作符被重载了 输出操作符"<<" cout是ostream类的对象,ostream类和cout都是在头文件 <iostream> 中声明的,ostream类将<<重载为其成员函数,
(C++)运算符重载
weixin_53812805的博客
05-29 318
一、运算符重载的概念 所谓运算符重载，就是给运算符赋予新的功能，同一个运算符具有不同的功能 运算符重载的本质：函数的重载 1、实现“+”号运算符的重载 重载功能：使实列对象可以直接相互加减，从而使类中的成员变量相互加减 #include <iostream> using namespace std; class Complex { //friend Complex operator+(const Complex &c1,const Complex &c2);
C++对象运算符重载，容器迭代器
weixin_40533189的博客
02-02 1530
+，++， += 、其他的运算符重载函数差不多,以及输出out,输入 in #include <iostream> using namespace std; /* C++ 运算符重载:使对象的运算表现得和编译器内置类型一样 template<typename T> T sum(T a, T b) { return a+ b; //a.+(b) } 1.编译器做对象运算的时候，会调用对象的运算符重载函数（优先调用成员方法）；如果没有成员方法 就在全局作用域找.
C++循环：简化重复的代码
最新发布
PingdiGuo_guo的博客
02-04 1439
C++循环超超超详细解析，内附各大重要知识点，包括练习呦！关注主播不迷路啊！
oj 贵州大学 第四次作业（c++）（运算符重载）第一题
m0_63058493的博客
05-20 2626
记录学习日常
c++操作符重载
hjxu2016的博客
09-03 3898
转自https://www.cnblogs.com/xudong-bupt/p/3557525.html 1.什么是操作符重载 　　可以使用分词将操作符重载理解为：操作符+重载。 　　C++中的操作符很多，如+，-，*，\等等。 　　C++中的重载也是C++中面向对象多态的体现。 　　简单说操作符重载： 　　　　C++中有：int a=2+3;　　那么a=5 　　　　操作符重载可以实...
c++重载操作符
米碎师兄
01-03 1060
c++支持重载的操作符有算术操作符+、-、*、/、%关系操作符==、!逻辑操作符!、&&、||位操作符赋值操作符下标操作符[]函数调用操作符()成员访问操作符->指针操作符*(解引用)、&(取地址)逗号操作符这些操作符按照操作数个数不同分为单目操作符、双目操作符、多目操作符单目操作符!、~、->、*(解引用)、&(取地址)双目操作符其他多目操作符()为什么要按这个分类？别急，继续看...
Hello C++（八）——操作符重载
天山老妖
02-22 1611
一、操作符重载基础 1、操作符重载的语法 通过operator关键字可以定义特殊的函数，operator本质是通过函数重载操作符。 Typeoperatoroperatorname(constTypep1,constTypep2) { Typeret; returnret; } 2、友元函数重载操作符 可以将操作符重载函数声明为友元函数。 #include<iostream> usingnamespacestd; classCompl...
C++-操作符重载
Joyer_cc 的博客
04-06 1724
Salesitem.h /* * This file contains code from "C++ Primer, Fifth Edition", by Stanley B. * Lippman, Josee Lajoie, and Barbara E. Moo, and is covered under the * copyright and warranty notices given in that book: * * "Copyright (c) 2013 by Objectwrite, In
39114_20170620200252_C++操作符重载_
10-02
在C++编程语言中，操作符重载是一种特殊的功能，允许我们为自定义类型赋予与内置类型（如整型或浮点型）相同的操作符含义。通过操作符重载，我们可以使用户定义的类更加直观和易用，因为它能够遵循程序员熟悉的运算...
C++操作符重载ppt
09-03
cpp入门教程-操作符重载： 主要内容为友元和操作符重载主要内容为友元和操作符重载主要内容为友元和操作符。
一道超级坑爹的题目
EasyLiu
08-23 1680
int a=4; int f(int n) { int t=0; static int a=5; if(n%2) { int a=6; t+=a++; } else { int a=7; t+=a++; } return t+a++; } void main() { int s=a,i=0;
C++中一个计算程序运行时间的工具类
EasyLiu
04-15 1396
此工具类为单例模式，通过调用其方法能够计算程序的运行时间。 timeHelper.h #include #include class timeHelper { private: clock_t tick_start; clock_t tick_stop; timeHelper(){} //构造函数私有化 static timeHelper *m_pInstance; class
自定义String类：构造函数、复制构造函数、赋值函数的实现
EasyLiu
04-21 1203
类String的头文件： #pragma once #include class String { public: //普通构造函数 String(const char*str = NULL);//C++ 可以有默认参数 //复制构造函数 String(const String& other); //赋值函数 String& operator=(const String& othe
关于const引用、常量指针、指针常量的一些知识
EasyLiu
07-21 714
应该将不需要修改的引用形参定义为const引用。普通的非const引用形参在使用时不太灵活。这样的形参既不能用const对象初始化，也不能用字面值或者产生右值的表达式实参初始化，如下所示： int incr(int &val) { return ++val; } int main() { short v1=0; const int v2=42; int v3=incr(v1); //v1不是一个
c++操作符重载万有引力
11-08
C++中的操作符重载是指对C++中的运算符进行重新定义，使其能够适用于用户自定义的数据类型。万有引力是物理学中的一个概念，它描述了物体之间的相互作用力。在C++中，我们可以通过操作符重载来实现万有引力的计算。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值