【实验七 运算符重载】

已于 2022-06-16 19:19:33 修改
阅读量442 收藏 1
点赞数 1
文章标签： 图像处理 c++ c语言 矩阵
于 2022-06-09 21:09:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63438506/article/details/124700086
版权

文章目录

前言

一、实验目的

掌握运算符重载
实现对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

whiteeeet
关注
实验七，运算符重载
qq_41797651的博客
06-12 2554
一、实验目的和要求  熟悉运算符重载的定义和使用方法二、实验内容1.调试下列程序//sy7_1.cpp #include&lt;iostream&gt; using namespace std; class complex { public: complex(){real=imag=0.0;} complex(double r){...
第七章 实验
mygrxf14的博客
06-05 670
实验目的和要求  熟悉运算符重载的定义和使用方法实验内容1.调试下列程序//sy7_1.cpp #include&lt;iostream&gt; using namespace std; class complex { public: complex(){real=imag=0.0;} complex(double r){real=r;imag=0.0;} ...
C++实验4——运算符重载
weixin_51703554的博客
01-18 4352
实验目的 掌握运算符重载 实现对Matrix类的运算符重载 实验内容 在之前的实验中，我们实现了矩阵类Matrix及其子类Image。本次实验我们给Matrix类添加一些重载的运算符，包括赋值运算符“=”，两个Matrix对象的“+”、“-”、“*”、“/”（都是矩阵对应元素间的运算，而不是矩阵的乘除），自加自减，矩阵（或图像）对象和一个数（标量）的“=”、“+”、“-”、“*”、“/”操作，判断两个矩阵（或图像）是否相等的“==”。 给Image类添加一个单目运算符“-”，作用是图像的像素值取反
实验八—运算符重载
m0_47696752的博客
12-13 1275
实验目的： 1.掌握C++语言多态性的基本概念 2.掌握运算符重载函数的声明和定义方法 运算符重载： 1.运算符重载是通过创建运算符重载函数来实现的，运算符重载函数可以是在类外定义的普通函数，也可以是类的成员函数或友元函数。 C++为运算符重载提供了一种方法，即在进行运算符重载时，必须定义一个运算符重载函数，其名字为operator，后随一个要重载的运算符。 2.运算符重载的函数格式： 3.C++中绝大多数的运算符允许重载，不能重载的运算符有以下几个： . 成员访问运算符； .* 成员指针访
实验7 运算符重载
CSDNwbdream的博客
08-29 1531
实验7  运算符重载 一、实验目的 了解多态性； 掌握算术运算符和关系运算符的重载； 掌握运算符重载的方法； 掌握作为成员函数的运算符重载和作为友元函数的运算符重载的不同特点。 二、相关知识 1．概念理解 多态是指类族中具有相似功能的不同函数使用同一名称来实现，从而可以使用相同的调用方式来调用这些具有不同功能的同名函数。 C++中的多态的实现形式：函数重载、运算符重载、虚函数等。函...
实验七 运算符重载及应用.pdf
03-22
本实验主要介绍了运算符重载的概念、分类、实现方法及其应用，旨在让学生理解多态性概念，掌握在 C++中用成员函数及友元函数实现运算符重载的方法，并熟悉运算符重载的应用。 一、多态性概念及分类 多态性是指不同...
实验七 运算符重载及应用.docx
03-22
实验七主要探讨了C++中的运算符重载和多态性这两个核心概念。多态性是面向对象编程的重要特性，分为静态多态性和动态多态性。静态多态性在编译时就能确定，通过函数重载和运算符重载实现。函数重载允许在同一个作用...
C++实验报告实验七-运算符重载
最新发布
03-14
### C++实验报告实验七-运算符重载 #### 实验目的 本次实验的主要目标是通过实际编程加深对C++中运算符重载的理解和应用。具体包括： 1. **编写程序熟悉运算符重载函数的定义和使用**：通过实践操作理解如何...
实验二 运算符重载的应用.doc
02-25
实验二 运算符重载的应用.doc 本实验报告的主要内容是对运算符重载的应用，通过构造函数、引用、运算符重载的概念和使用方法的学习和掌握，为后续的面向对象程序设计打下基础。 一、实验目的 1. 进一步熟悉构造...
上机实验7 运算符重载
little_wmm的博客
12-13 1947
实验目的 1.掌握C+ +语言多态性的基本概念 2.掌握运算符重载函数的声明和定义方法 实验内容 编写一个程序，实现复数的乘法。 多态性 在面向对象方法中，所谓多态性就是不同对象收到相同消息，产生不同的行为。在C++程序设计中，多态性是指用一个名字定义不同的函数，这些函数执行不同但又类似的操作，这样就可以用同一个函数名调用不同内容的函数。 运算符重载函数 系统已定义的运算符不适用于新的自定义数据类型，为了解决这一问题，C++允许运算符的重载。 运算符的重载是通过创建运算符重载函数来实现的;运算
运算符重载实验仅供参考
12-24
大学实验c++运算符重载，需要的可以参考。
矩阵类的运算符重载
05-19
矩阵类的运算符重载，编写一个矩阵类Matrix，并重载运算符“+”、“-”、“*”、“>>”、“<<”来分别实现矩阵的加法、减法、乘法，以及标准流输入和流输出操作。
实验：运算符重载
ysds20211402的博客
04-05 327
转自：微点阅读https://www.weidianyuedu.com/content/4717694373455.html 实验：运算符重载 【实验目的】 1. 2. 3. 4. 进一步了解运算符重载的概念和使用方法。 掌握几种常用的运算符重载的方法。 了解转换构造函数的使用方法。 了解在Visual c++6.0环境下进行运算符重载要注意的问题. 【实验要求】 1.硬件基本配置：Intel PentiumIII以上级别的cPU，大于64MB的内存。 2.软件要求：Window 2..
运算符重载实验（超基础和干货的代码训练）
Eumenides_Suki的博客
05-02 544
T1.Purpose of the experiment Master the basic syntax of operator overloading. Skillfully use the function with the same name to complete the same basic operation. T2.Experiment content [Experiment top...
实验八：运算符重载
qq_58745531的博客
12-18 715
一： 二：运算符重载： 多态性： 在面向对象方法中，所谓多态性就是不同对象收到相同的消息时，产生不同的行为。在C++ 程序设计中，多态性是指用一个名字定义不同的函数，这些函数执行不同但又类似的操作，这样就可以用同一个函数名调用不同内容的函数。 运算符重载： 运算符重载规则如下： ①、 C++中的运算符除了少数几个之外，全部可以重载，而且只能重载C++中已有的运算符。 ②、 重载之后运算符的优先级和结合性都不会改变。 ③、 运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。一般来说，
实验九运算符重载
LovingLif的博客
06-20 419
用成员函数实现运算符 “+”、“-”、“++”、“–”和”[ ]”的重载。 （1）实现将两个二维数组相加、相减。其中第一个数组的值由构造函数设置，第二个数组由键盘输入。 （2）数组能进行自增和自减运算。前”++”、“–”和后”++”、 “–”都要分别实现。数组通过构造函数设置 （3）实现数组和一个整数相加、相减。数组和整数都采取键盘输入。 （4）实现下标运算符重载。根据键盘输入i,j来访问数组中的...
实验七 运算符重载
chendan_666的博客
06-02 960
实验目的和要求熟悉运算符重载的定义和使用方法 实验内容1.调试下列程序//sy7_1.cpp #include&lt;iostream&gt; using namespace std; class complex { public: complex(){real=imag=0.0;} complex(double r){real=...
实验七 运算符重载
qq_41798905的博客
06-25 367
实验目的和要求熟悉运算符重载的定义和使用方法 实验内容1.调试下列程序[cpp] view plain copy//sy7_1.cpp    #include&lt;iostream&gt;    using namespace std;    class complex    {        public:            complex(){real=imag=0.0;}       ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值