1. 首页
  2. 文章中心
  3. 图像处理

【实验七 运算符重载】前言一、实验目的二、实验内容三、代码实现四、总结

48 阅读 0 评论
我是靠谱客的博主 孝顺饼干，最近开发中收集的这篇文章主要介绍【实验七 运算符重载】前言一、实验目的二、实验内容三、代码实现四、总结，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

文章目录

  • 前言
  • 一、实验目的
  • 二、实验内容
    • 1.内容
    • 2.代码示例
  • 三、代码实现
  • 四、总结

前言

一、实验目的

掌握运算符重载
实现对Matrix类的运算符重载

二、实验内容

1.内容

在之前的实验中，我们实现了矩阵类Matrix及其子类Image。本次实验我们给Matrix类添加一些重载的运算符，包括赋值运算符“=”，两个Matrix对象的“+”、“-”、“”、“/”（都是矩阵对应元素间的运算，而不是矩阵的乘除），自加自减，矩阵（或图像）对象和一个数（标量）的“=”、“+”、“-”、“”、“/”操作，判断两个矩阵（或图像）是否相等的“==”。

给Image类添加一个单目运算符“-”，作用是图像的像素值取反，即黑的变成白的，白的变成黑的。再给Image类添加一个成员函数gray2bw，该函数以给定的阈值参数把灰度图像转化为二值图像。假设图像的像素值范围在[0,1]之间的实数，给定阈值double t∈[0,1]。该函数对图像中的所有像素做如下处理：如果该像素的像素值小于t，则输出图像对应像素值赋值为0，如果该像素的像素值大于等于t，则输出图像对应像素赋值为1。此函数的输出图像对象仅含有0和1两种像素值，因此该操作在图像处理里称为“二值化”操作或“阈值分割”。
注意：这两种函数假设操作对象的数据是在[0,1]之间的实数。但是实际对象的元素数值可能不在这个范围内。因此，在这两个函数内部，需要先把所有元素的范围normalize到[0,1]区间，然后再做相应的操作。同样，在把结果保存为BMP图像的时候，要把范围再缩放到[0,255]的整数区间，注意相关的操作。

之前给大家的图片中有两幅场景图scene2_bg.bmp和scene2_fg.bmp，要求通过图像相减，再做阈值分割，分离出前景物体。

1 在Matrix类中重载运算符，添加一些运算符重载函数（有的是成员函数，有的是友元函数，思考哪些适合使用成员函数，哪些适合使用友元函数？）：

  1. 重载两个Matrix对象的赋值运算符“=”，完成类似a=b的操作。要求进行数据的深拷贝。并再次重载赋值运算符，使右操作数可以是一个double类型的数，完成矩阵所有元素赋值为该数，如a=128。
  2. 重载判断两个Matrix对象是否相等的“==”运算符，两个矩阵相等的条件是行列大小相同，所有元素的值也相等。
  3. 重载“+”运算符，针对两幅尺寸相同的矩阵，完成对应元素值相加。
  4. 重载“+”运算符，实现一个矩阵所有元素加上同一数值。
  5. 重载“-”运算符，针对两个尺寸相同的矩阵，实现对元素值相减。
  6. 重载“-”运算符，实现一个矩阵所有元素减去同一数值。
  7. 重载“*”运算符，针对两个尺寸相同的矩阵，实现对元素值相乘。
  8. 重载“*”运算符，实现一个矩阵所有元素乘以同一数值。
  9. 重载“/”运算符，针对两个尺寸相同的矩阵，实现对元素值相除；自己设计除数为0时的处理办法。
  10. 重载“/”运算符，实现一个矩阵所有元素除以同一数值；自己设计除数为0时的处理办法。

2 在Image类里，实现如下运算符和函数：

  1. 重载“-”单目运算符，实现一个Image对象的所有元素“取反”。
  2. 实现函数gray2bw，以给定的阈值对图像进行二值化，函数返回结果Image对象。
  3. 重载“++”运算符，实现一个矩阵所有元素自加1（分别实现前置版本和后置版本）。注意，使用该运算符的对象的像素值范围应该是[0,255]，如果是[0,1]之间的，应该首先扩展到[0,255]，再进行加1操作，然后再normalize回[0,1]。
  4. 重载“–”运算符，实现一个矩阵所有元素自减1（分别实现前置版本和后置版本）。注意，使用该运算符的对象的像素值范围应该是[0,255]，如果是[0,1]之间的，应该首先扩展到[0,255]，再进行加1操作，然后再normalize回[0,1]。

3 在main函数中对所有实现的函数进行测试，比如前面提到的分离前景物体。
创建Image对象img1和img2，分别读入两幅图像scene2_fg和scene2_bg。新建Image对象sub，使用“-”运算符，实现img1和img2相减，并保存。对sub调用gray2bw函数进行阈值分割，保存结果。

2.代码示例

代码如下（示例）：
Matrix.h

#ifndef MATRIX_H
#define MATRIX_H

class Matrix
{
public:
    // 构造函数等其它成员略
     
//运算符重载函数；
Matrix& operator=(const Matrix &m);  //重载赋值运算符，完成对象间的深拷贝；
bool operator==(const Matrix &m);  //判断两个Matrix对象是否相等
    
    Matrix& operator++();  //前置自加；
    Matrix& operator--();  //前置自减；
    Matrix operator++(int);  //后置自加；
Matrix operator--(int);  //后置自减；

//两个尺寸相同的矩阵，对应元素的数值相加；
friend Matrix operator+(const Matrix &m1, const Matrix &m2);
//所有元素加上同一数值;
friend Matrix operator+(Matrix &m, double num);
//两个尺寸相同的矩阵，对应元素的数值相减；
friend Matrix operator-(const Matrix &m1, const Matrix &m2);  
//所有元素减去同一数值;
friend Matrix operator-(Matrix &m, double num);
//两幅尺寸相同的矩阵，对应元素的数值相乘；
friend Matrix operator*(const Matrix &m1, const Matrix &m2);
//所有元素乘上同一数值;
friend Matrix operator*(Matrix &m, double num);
//两幅尺寸相同的矩阵，对应元素的数值相除；
friend Matrix operator/( const Matrix &m1, const Matrix &m2);
//所有元素除以同一数值;
friend Matrix operator/(Matrix &m, double num);

//以上友元函数实现了Matrix对象和一个数的加减乘除，如果交换这两个操作数，即一个数和一个Matrix对象的加减乘除，应该如何做？请自行写出相关代码。

//其它成员略

};

#endif

在Image类中实现Image特有的运算符和成员函数

Image operator-();  //对图像取反，把所有像素的值都规整到[0,1]之间，然后每个像素都被1.0减
Image gray2bw(double t); //以给定阈值t对图像进行二值化，返回结果图像对象；
//自加、自减的前置版本和后置版本

以上均为老师给的实验内容，实现如下。

三、代码实现

Main.cpp

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

int main(int argc, char* argv[])
{
	Image img1("scene2_bg.bmp");
	Image img2("scene2_fg.bmp");
	//以下注释为自行测试
	//Image img3("scene2_bg.bmp");
	//Image img4("shuiguo.bmp");
	//Image img5("Fruits.bmp");
	//img1 == img3;//判断相等
	//img1++;//前置自加；
	//img1.WriteBMP("img1++.bmp");
	//(++img1);//后置自加
	//img1.WriteBMP("++img1.bmp");
	//img1.operator-();//图像取反
	//img1.WriteBMP1("img1operator-.bmp");
	//Image subb(img4);
	//subb = 1 - img5;
	//subb.WriteBMP("6-img5.bmp");
	//subb=img4 + img5;
	//subb.WriteBMP("img4 + img5.bmp");
	//subb=img5-img4;
	//subb.WriteBMP("img5-img4.bmp");
	//两图片相减
	Image sub(img1);
	sub = img2 - img1;
	sub.WriteBMP("img2-img1.bmp");
	//图片进行阈值分割
	sub.gray2bw(0.5);
	sub.WriteBMP1("subgray2bw.bmp");
	/*sub.operator-();
	sub.WriteBMP1("suboperator.bmp");*/
	return 0;
}

Image.h

#ifndef Image_H
#define Image_H

#include "Matrix.h"

class Image : public Matrix
{
public:
    Image(); //构造函数，创建行列都为零的Image对象
    Image(int h, int w); //构造函数重载，创建h行，w列的Image对象
    Image(int h, int w, unsigned char val); //构造函数重载，创建的图像像素值都为val;
    Image(const char* ImageName); //构造函数重载，利用文件名从硬盘加载图像文件成为Image对象;
    Image(unsigned char m[][100], int n); //构造函数重载，从静态数组创建Image对象;
    Image(unsigned char** m, int h, int w); //构造函数重载，从动态数组创建Image对象;
    Image(const Matrix& m); //构造函数重载，由Matrix类对象构造Image类对象
    Image(const Image& im); //拷贝构造函数;
    ~Image(); //析构函数;

    void ReadBMP(const char* ImageName); //从硬盘文件中读入图像数据;
    void WriteBMP(const char* filename); //将图像数据保存为图像文件;
    void WriteBMP1(const char* filename); //将图像数据保存为图像文件;

    void normalize();//将像素值缩小至0，1区间；
    void renormalize();//将像素值缩放至0，255区间；
    Image operator-();  //对图像取反，把所有像素的值都规整到[0,1]之间，然后每个像素都被1.0减
    Image gray2bw(double t); //以给定阈值t对图像进行二值化，返回结果图像对象；
    //自加、自减的前置版本和后置版本
    Image& operator++();  //前置自加；
    Image& operator--();  //前置自减；
    Image operator++(int);  //后置自加；
    Image operator--(int);  //后置自减；
private:
    double dmin;
    double dmax;
    //用于判断renormalize计算
};
#endif

Image.cpp

#define _CRT_SECURE_NO_WARNINGS
#include "Image.h"
#include <Windows.h>
#include<cstdlib>
#include<cstdio>
#include <iostream>


using namespace std;

Image::Image()
{
    //write your code here
    height = 0;
    width = 0;
    dmin = 0;
    dmax = 0;
    data = nullptr;
}
Image::Image(int h, int w)//构造函数重载，创建h行，w列的Image对象
{
    all(h, w);
}

Image::Image(const char* ImageName)//构造函数重载，利用文件名从硬盘加载图像文件成为Image对象;
{
    ReadBMP(ImageName);
    // cout << "被调用！" << endl;
}
Image::Image(unsigned char m[][100], int n)//构造函数重载，从静态数组创建Image对象;
{
    height = n;
    width = 100;
    all(n, 100);
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < 100; j++)
        {
            data[i][j] = static_cast<unsigned char>(m[i][j]);
        }
    }
}
Image::Image(unsigned char** m, int h, int w) //构造函数重载，从动态数组创建Image对象;
{
    height = h;
    width = w;
    data = new double* [h];
    for (int i = 0; i < h; i++)
    {
        data[i] = new double[w];
        for (int j = 0; j < w; j++)
        {
            data[i][j] = static_cast<unsigned char>(m[i][j]);
        }
    }
}
Image::Image(const Matrix& m) :Matrix(m) //构造函数重载，由Matrix类对象构造Image类对象
{

}
Image::Image(const Image& m)
{
    //write your code here
    width = m.width;
    height = m.height;
    data = new double* [height];
    for (int i = 0; i < height; i++)
    {
        data[i] = new double[width];
        for (int j = 0; j < width; j++)
        {
            data[i][j] = static_cast<unsigned char> (m.data[i][j]);
        }
    }
    //cout << "拷贝并创建新图像成功！" << endl;
}
Image:: ~Image()//析构函数;
{
    for (int i = 0; i < height; i++)
    {
        delete[]data[i];
    }
    delete[]data;
}
void Image::ReadBMP(const char* ImageName) //从硬盘文件中读入图像数据;
{
    FILE* fp = fopen(ImageName, "rb");
    if (fp == NULL)
    {
        cout << "文件打开失败！" << endl;
        exit(0);
    }
    BITMAPFILEHEADER fh;
    BITMAPINFOHEADER ih;
    fread(&fh, sizeof(BITMAPFILEHEADER), 1, fp);
    fread(&ih, sizeof(BITMAPINFOHEADER), 1, fp);
    width = ih.biWidth;
    height = ih.biHeight;
    if (height % 4 != 0)
    {
        height = (height * (ih.biBitCount) / 8 + 3) / 4 * 4;
        height = height / 3;
    }
    if (width % 4 != 0)
    {
        width = (width * (ih.biWidth) / 8 + 3) / 4 * 4;
        width = width / 3;
    }
    data = new double* [height];
    for (int i = 0; i < height; i++)
    {
        data[i] = new double[width];
    }
    // fseek(fp, 14+40,0);
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            unsigned char r, g, b;
            fread(&r, sizeof(unsigned char), 1, fp);
            fread(&g, sizeof(unsigned char), 1, fp);
            fread(&b, sizeof(unsigned char), 1, fp);
            data[i][j] = static_cast<double>(r / 3 + g / 3 + b / 3);
        }
    }
    fclose(fp);
    // cout << "文件读取成功！" << endl;
}

void Image::WriteBMP(const char* filename) //将未被缩放的图像数据保存为图像文件;
{
    FILE* fp = fopen(filename, "wb");
    if (fp == NULL)
    {
        cout << "文件打开失败！" << endl;
        exit(0);
    }
    BITMAPFILEHEADER fh;
    BITMAPINFOHEADER ih;
    //  ih.biSizeImage = 737280;
    fh.bfOffBits = 54;
    fh.bfReserved1 = 0;
    fh.bfReserved2 = 0;
    fh.bfSize = height * width * 3 + 54;
    fh.bfType = 19778;
    ih.biBitCount = 24;
    ih.biCompression = 0;
    ih.biXPelsPerMeter = 0;
    ih.biYPelsPerMeter = 0;
    ih.biClrImportant = 0;
    ih.biSize = 40;
    ih.biPlanes = 1;
    ih.biClrUsed = 0;
    ih.biWidth = width;
    ih.biHeight = height;
    ih.biSizeImage = ih.biWidth * ih.biHeight * 3;
    fwrite(&fh, sizeof(BITMAPFILEHEADER), 1, fp);
    fwrite(&ih, sizeof(BITMAPINFOHEADER), 1, fp);
    unsigned char t = 0;
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            t = static_cast<unsigned char>(data[i][j]);
            for (int k = 0; k < 3; k++)
            {
                fwrite(&t, sizeof(unsigned char), 1, fp);
            }
        }
    }
    fclose(fp);
    cout << "文件存入成功！请查看！" << endl;
}
void Image::WriteBMP1(const char* filename) //将被缩放的图像数据保存为图像文件;
{
    renormalize();
    FILE* fp = fopen(filename, "wb");
    if (fp == NULL)
    {
        cout << "文件打开失败！" << endl;
        exit(0);
    }
    BITMAPFILEHEADER fh;
    BITMAPINFOHEADER ih;
    //  ih.biSizeImage = 737280;
    fh.bfOffBits = 54;
    fh.bfReserved1 = 0;
    fh.bfReserved2 = 0;
    fh.bfSize = height * width * 3 + 54;
    fh.bfType = 19778;
    ih.biBitCount = 24;
    ih.biCompression = 0;
    ih.biXPelsPerMeter = 0;
    ih.biYPelsPerMeter = 0;
    ih.biClrImportant = 0;
    ih.biSize = 40;
    ih.biPlanes = 1;
    ih.biClrUsed = 0;
    ih.biWidth = width;
    ih.biHeight = height;
    ih.biSizeImage = ih.biWidth * ih.biHeight * 3;
    fwrite(&fh, sizeof(BITMAPFILEHEADER), 1, fp);
    fwrite(&ih, sizeof(BITMAPINFOHEADER), 1, fp);
    unsigned char t = 0;
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            t = static_cast<unsigned char>(data[i][j]);
            for (int k = 0; k < 3; k++)
            {
                fwrite(&t, sizeof(unsigned char), 1, fp);
            }
        }
    }
    fclose(fp);
    cout << "文件存入成功！请查看！" << endl;
}
void Image::normalize()//将像素值缩小至[0,1]区间；
{
    double max = 0, min = data[0][0];
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            max = max > data[i][j] ? max : data[i][j];
            min = min < data[i][j] ? min : data[i][j];
        }
    }
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            if (data[i][j] == max)
            {
                data[i][j] = 1;
            }
            else if (data[i][j] == min)
            {
                data[i][j] = 0;
            }
            else
            {
                data[i][j] = (data[i][j] - min) / max;
            }
        }
    }
    dmin = min;
    dmax = max;
}
void Image::renormalize()//将像素值缩放至0，255区间；
{
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            data[i][j]= data[i][j] * dmax + dmin;
        }
    }
    dmin = 0;
    dmax = 1;
}
Image Image::operator-()  //对图像取反，把所有像素的值都规整到[0,1]之间，然后每个像素都被1.0减
{
    normalize();
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            data[i][j] = 1.0 - data[i][j];
        }
    }
    return (*this);
}
Image Image::gray2bw(double t) //以给定阈值t对图像进行二值化，返回结果图像对象；
{
    normalize();
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            if (data[i][j] < t)
            {
                data[i][j] = 0;
            }
            else
            {
                data[i][j] = 1;
            }
        }
    }
    cout << "文件二值化成功！" << endl;
    return (*this);
}
Image Image::operator++(int)
{
    if (dmax == 1)
    {
        renormalize();
        Image old = *this;
        ++(*this);
        return old;
    }
    else
    {
        Image old = *this;
        ++(*this);
        return old;
    }
}
Image Image::operator--(int)  //后置自减；
{
    if (dmin == 0)
    {
        renormalize();
        Image old = *this;
        --(*this);
        return old;
    }
    else
    {
        Image old = *this;
        --(*this);
        return old;
    }
}
Image& Image:: operator++() //前置自加；
{
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            data[i][j]++;
        }
    }
    return *this;
}
Image& Image:: operator--() //前置自减；、
{
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            data[i][j]--;
        }
    }
    return *this;
}

Matrix.h

#ifndef Matrix_H
#define Matrix_H

class Matrix
{
public:
    Matrix();
    Matrix(int h, int w);
    Matrix(int h, int w, double val);
    Matrix(const Matrix& m);
    ~Matrix();
 
    void all(int h, int w);
    //运算符重载函数；
    Matrix& operator=(const Matrix& m);  //重载赋值运算符，完成对象间的深拷贝；
    bool operator==(const Matrix& m);  //判断两个Matrix对象是否相等

    Matrix& operator++();  //前置自加；
    Matrix& operator--();  //前置自减；
    Matrix operator++(int);  //后置自加；
    Matrix operator--(int);  //后置自减；


    //两个尺寸相同的矩阵，对应元素的数值相加；
    friend Matrix operator+(const Matrix& m1, const Matrix& m2);
    //所有元素加上同一数值;
    friend Matrix operator+(Matrix& m, double num);
    //两个尺寸相同的矩阵，对应元素的数值相减；
    friend Matrix operator-(const Matrix& m1, const Matrix& m2);
    //所有元素减去同一数值;
    friend Matrix operator-(Matrix& m, double num);
    //两幅尺寸相同的矩阵，对应元素的数值相乘；
    friend Matrix operator*(const Matrix& m1, const Matrix& m2);
    //所有元素乘上同一数值;
    friend Matrix operator*(Matrix& m, double num);
    //两幅尺寸相同的矩阵，对应元素的数值相除；
    friend Matrix operator/(const Matrix& m1, const Matrix& m2);
    //所有元素除以同一数值;
    friend Matrix operator/(Matrix& m, double num);

    //以上友元函数实现了Matrix对象和一个数的加减乘除，如果交换这两个操作数，即一个数和一个Matrix对象的加减乘除，应该如何做？请自行写出相关代码。
    friend Matrix operator+(double num, const Matrix& m);
    friend Matrix operator-(double num, const Matrix& m);
    friend Matrix operator*(double num, const Matrix& m);
    friend Matrix operator/(double num, const Matrix& m);
    //其它成员略
protected:
    int height;
    int width;
    double** data;
};
#endif

Matrix.cpp

#define _CRT_SECURE_NO_WARNINGS
#include"Matrix.h"
#include<cstdio>
#include<iostream>
#include<Windows.h>
#include<ctime>
#include<cmath>
using namespace std;

void Matrix::all(int h, int w)
{
    height = h;
    width = w;
    for (int i = 0; i < height; i++)
    {
        data = new double* [width];
    }
}

Matrix::Matrix()
{
    height = 0;
    width = 0;
    data = nullptr;
}

Matrix::Matrix(int h, int w)
{
    all(h, w);
}

Matrix::Matrix(int h, int w, double val)
{
    all(h, w);
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            data[i][j] = val;
        }
    }
}
Matrix::Matrix(const Matrix& m)
{
    width = m.width;
    height = m.height;
    data = new double* [height];
    for (int i = 0; i < height; i++)
    {
        data[i] = new double[width];
        for (int j = 0; j < width; j++)
        {
            data[i][j] = m.data[i][j];
        }
    }
    // cout << "拷贝构造成功!" << endl;
}
Matrix::~Matrix()
{
    /*for (int i = 0; i < height; i++)
    {
        delete[]data[i];
    }
    delete[]data;*/
}
Matrix& Matrix::operator=(const Matrix& m) //重载赋值运算符，完成对象间的深拷贝；
{
    height = m.height;
    width = m.width;
    data = new double* [height];
    for (int i = 0; i < height; i++)
    {
        data[i] = new double[width];
        for (int j = 0; j < width; j++)
        {
            data[i][j] = m.data[i][j];
        }
    }
   return(*this);
}
bool Matrix::operator==(const Matrix& m)  //判断两个Matrix对象是否相等
{
    int flag = 0;
    if (height != m.height)
    {
        flag++; cout << "不相等！" << endl;
        return false;
    }
    else if (width != m.width)
    {
        flag++; cout << "不相等！" << endl;
        return false;
    }
    else
    {
        for (int i = 0; i < height; i++)
        {
            for (int j = 0; j < width; j++)
            {
                if (data[i][j] != m.data[i][j])
                {
                     cout << "不相等！" << endl;
                    return false;
                }
            }
        }
    }
    if (flag == 0)
    {
        cout << "相等！" << endl;
        return true;
    }
}
Matrix& Matrix::operator++() //前置自加
{
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            data[i][j]++;
        }
    }
    return *this;
}
Matrix& Matrix::operator--() //前置自减
{
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            data[i][j]--;
        }
    }
    return *this;
}
Matrix Matrix::operator++(int)  //后置自加；
{
    Matrix old = *this;
    ++(*this);
    return old;
}
Matrix Matrix::operator--(int)  //后置自减；
{
    Matrix old = *this;
    --(*this);
    return old;
}
Matrix operator+(const Matrix& m1, const Matrix& m2)//两个尺寸相同的矩阵，对应元素的数值相加；
{
    Matrix m(m1);
    for (int i = 0; i < m1.height; i++)
    {
        for (int j = 0; j < m1.width; j++)
        {
            m.data[i][j] = m1.data[i][j] + m2.data[i][j];
            if (m.data[i][j] >= 255)
            {
                m.data[i][j] = 255;
            }
        }
     }
    cout << "文件相加成功！" << endl;
    return m;
}
//所有元素加上同一数值;
Matrix operator+(Matrix& m, double num)
{
    for (int i = 0; i < m.height; i++)
    {
        for (int j = 0; j < m.width; j++)
        {
            m.data[i][j]+= num;
        }
    }
    return m;
}
//两个尺寸相同的矩阵，对应元素的数值相减；
Matrix operator-(const Matrix& m1, const Matrix& m2)
{
    Matrix m(m1);
    for (int i = 0; i < m1.height; i++)
    {
        for (int j = 0; j < m1.width; j++)
        {
            if (m1.data[i][j] - m2.data[i][j] <= 0)
            {
                m.data[i][j] = 0;
            }
            else
            {
                m.data[i][j] =fabs( m1.data[i][j] - m2.data[i][j]);
            }
        }
    }
    cout << "文件相减成功！" << endl;
    return m;
}
//所有元素减去同一数值;
Matrix operator-(Matrix& m, double num)
{
    for (int i = 0; i < m.height; i++)
    {
        for (int j = 0; j < m.width; j++)
        {
            m.data[i][j] -= num;
        }
    }
    return m;
}
//两幅尺寸相同的矩阵，对应元素的数值相乘；
Matrix operator*(const Matrix& m1, const Matrix& m2)
{
    Matrix m;
    for (int i = 0; i < m1.height; i++)
    {
        for (int j = 0; j < m1.width; j++)
        {
            m.data[i][j] = m1.data[i][j] * m2.data[i][j];
        }
    }
    return m;
}
//所有元素乘上同一数值;
Matrix operator*(Matrix& m, double num)
{
    for (int i = 0; i < m.height; i++)
    {
        for (int j = 0; j < m.width; j++)
        {
            m.data[i][j] *= num;
        }
    }
    return m;
}
//两幅尺寸相同的矩阵，对应元素的数值相除；
Matrix operator/(const Matrix& m1, const Matrix& m2)
{
    Matrix m;
    for (int i = 0; i < m1.height; i++)
    {
        for (int j = 0; j < m1.width; j++)
        {
            m.data[i][j] = m1.data[i][j] / m2.data[i][j];
        }
    }
    return m;
}
//所有元素除以同一数值;
Matrix operator/(Matrix& m, double num)
{
    for (int i = 0; i < m.height; i++)
    {
        for (int j = 0; j < m.width; j++)
        {
            m.data[i][j] /= num;
        }
    }
    return m;
}

//以下实现一个数和类加减乘除
Matrix operator+(double num, const Matrix& m)
{
    for (int i = 0; i < m.height; i++)
    {
        for (int j = 0; j < m.width; j++)
        {
            m.data[i][j] += num;
        }
    }
    return m;
}
Matrix operator-(double num, const Matrix& m)
{
    for (int i = 0; i < m.height; i++)
    {
        for (int j = 0; j < m.width; j++)
        {
            m.data[i][j] -= num;
        }
    }
    return m;
}
Matrix operator*(double num, const Matrix& m)
{
    for (int i = 0; i < m.height; i++)
    {
        for (int j = 0; j < m.width; j++)
        {
            m.data[i][j] *= num;
        }
    }
    return m;
}
Matrix operator/(double num, const Matrix& m)
{
    for (int i = 0; i < m.height; i++)
    {
        for (int j = 0; j < m.width; j++)
        {
            m.data[i][j] /= num;
        }
    }
    return m;
}

四、总结

总的来说，这篇实验主要是练习运算符重载相关知识，不仅需要掌握如何写好运算符重载函数，包括参数等等，我认为正确如何调用这些函数也是很重要的，做好不会使用也是瞎忙活。还有就是有关重载为友元形式还是普通的重载函数也需要我们在自己完成所有代码的时候需要注意的，这次实验的题目已给出具体的选用哪种形式，所以这方面的练习还是有待训练的。下面附上一份选择使用哪类函数的链接一起学习。有问题欢迎大家一起讨论学习鸭！

链接: link

最后

以上就是孝顺饼干为你收集整理的【实验七 运算符重载】前言一、实验目的二、实验内容三、代码实现四、总结的全部内容，希望文章能够帮你解决【实验七 运算符重载】前言一、实验目的二、实验内容三、代码实现四、总结所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(32)

相关文章

（黑马C++）L05 运算符重载
（黑马C++）L05 运算符重载
C++基础知识（四）-友元和运算符重载整理码字不易，养成好习惯，点赞关注，你的支持就是我写下去的动力，谢谢老板。本文为C++第三篇后续接着这篇文章写，大家可以持续关注，前三篇在主页
C++基础知识（四）-友元和运算符重载整理码字不易，养成好习惯，点赞关注，你的支持就是我写下去的动力，谢谢老板。本文为C++第三篇后续接着这篇文章写，大家可以持续关注，前三篇在主页
运算符重载在ACM中的运用
运算符重载在ACM中的运用
6、运算符重载、继承(C++核心语法)
6、运算符重载、继承(C++核心语法)
【实验七 运算符重载】前言一、实验目的二、实验内容三、代码实现四、总结
【实验七 运算符重载】前言一、实验目的二、实验内容三、代码实现四、总结
C++课后作业 20. 运算符重载课堂练习：分钟秒钟的时间相减
C++课后作业 20. 运算符重载课堂练习：分钟秒钟的时间相减
运算符重载实验（超基础和干货的代码训练）T1.Purpose of the experimentT2.Experiment contentT3.Experiment summary
运算符重载实验（超基础和干货的代码训练）T1.Purpose of the experimentT2.Experiment contentT3.Experiment summary
Day05C++运算符重载
Day05C++运算符重载

评论列表共有 0 条评论

立即
投稿
返回
顶部