C++实践参考——复数类中的运算符重载

最新推荐文章于 2024-05-20 21:05:44 发布
最新推荐文章于 2024-05-20 21:05:44 发布
阅读量9.5k 收藏 30
点赞数 11
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sxhelijian/article/details/45172591
版权

返回：贺老师课程教学链接


【项目-实现复数类中的运算符重载】
（1）请用类的成员函数，定义复数类重载运算符+、-、*、/，使之能用于复数的加减乘除 
class Complex 
{
public:
    Complex(){real=0;imag=0;}
    Complex(double r,double i){real=r; imag=i;}
    Complex operator+(const Complex &c2);
    Complex operator-(const Complex &c2);
    Complex operator*(const Complex &c2);
    Complex operator/(const Complex &c2);
    void display();
private:
    double real;
    double imag;
};
//下面定义成员函数


//下面定义用于测试的main()函数
int main()
{
    Complex c1(3,4),c2(5,-10),c3;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    c3=c1+c2;
    cout<<"c1+c2=";
    c3.display();
    c3=c1-c2;
    cout<<"c1-c2=";
    c3.display();
    c3=c1*c2;
    cout<<"c1*c2=";
    c3.display();
    c3=c1/c2;
    cout<<"c1/c2=";
    c3.display();
    return 0;
}
[参考解答] 
#include <iostream>
using namespace std;
class Complex
{
public:
    Complex(){real=0;imag=0;}
    Complex(double r,double i){real=r; imag=i;}
    Complex operator+(const Complex &c2);
    Complex operator-(const Complex &c2);
    Complex operator*(const Complex &c2);
    Complex operator/(const Complex &c2);
    void display();
private:
    double real;
    double imag;
};
//下面定义成员函数
//复数相加： (a+bi)+(c+di)=(a+c)+(b+d)i.
Complex Complex::operator+(const Complex &c2)
{
    Complex c;
    c.real=real+c2.real;
    c.imag=imag+c2.imag;
    return c;
}
//复数相减：(a+bi)-(c+di)=(a-c)+(b-d)i.
Complex Complex::operator-(const Complex &c2)
{
    Complex c;
    c.real=real-c2.real;
    c.imag=imag-c2.imag;
    return c;
}
//复数相乘：(a+bi)(c+di)=(ac－bd)+(bc+ad)i.
Complex Complex::operator*(const Complex &c2)
{
    Complex c;
    c.real=real*c2.real-imag*c2.imag;
    c.imag=imag*c2.real+real*c2.imag;
    return c;
}

//复数相除：(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i
Complex Complex::operator/(const Complex &c2)
{
    Complex c;
    c.real=(real*c2.real+imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    c.imag=(imag*c2.real-real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    return c;
}

void Complex::display()
{
    cout<<"("<<real<<","<<imag<<"i)"<<endl;
}
//下面定义用于测试的main()函数
int main()
{
    Complex c1(3,4),c2(5,-10),c3;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    c3=c1+c2;
    cout<<"c1+c2=";
    c3.display();
    c3=c1-c2;
    cout<<"c1-c2=";
    c3.display();
    c3=c1*c2;
    cout<<"c1*c2=";
    c3.display();
    c3=c1/c2;
    cout<<"c1/c2=";
    c3.display();
    return 0;
}

（2）请用类的友元函数，而不是成员函数，再次完成上面提及的运算符的重载；
[参考解答] 
#include <iostream>
using namespace std;
class Complex
{
public:
    Complex()
    {
        real=0;
        imag=0;
    }
    Complex(double r,double i)
    {
        real=r;
        imag=i;
    }
    friend Complex operator+(Complex &c1, Complex &c2);
    friend Complex operator-(Complex &c1, Complex &c2);
    friend Complex operator*(Complex &c1, Complex &c2);
    friend Complex operator/(Complex &c1, Complex &c2);
    void display();
private:
    double real;
    double imag;
};

//复数相加：(a+bi)+(c+di)=(a+c)+(b+d)i.
Complex operator+(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=c1.real+c2.real;
    c.imag=c1.imag+c2.imag;
    return c;
}

//复数相减：(a+bi)-(c+di)=(a-c)+(b-d)i.
Complex operator-(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=c1.real-c2.real;
    c.imag=c1.imag-c2.imag;
    return c;
}

//复数相乘：(a+bi)(c+di)=(ac－bd)+(bc+ad)i.
Complex operator*(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=c1.real*c2.real-c1.imag*c2.imag;
    c.imag=c1.imag*c2.real+c1.real*c2.imag;
    return c;
}

//复数相除：(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i
Complex operator/(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=(c1.real*c2.real+c1.imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    c.imag=(c1.imag*c2.real-c1.real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    return c;
}

void Complex::display()
{
    cout<<"("<<real<<","<<imag<<"i)"<<endl;
}

int main()
{
    Complex c1(3,4),c2(5,-10),c3;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    c3=c1+c2;
    cout<<"c1+c2=";
    c3.display();
    c3=c1-c2;
    cout<<"c1-c2=";
    c3.display();
    c3=c1*c2;
    cout<<"c1*c2=";
    c3.display();
    c3=c1/c2;
    cout<<"c1/c2=";
    c3.display();
    return 0;
}

　　事实上，运算符重载的函数还可以定义成一般函数，只不过这种做法并不好。下面给出使用一般函数完成运算符重载的程序。其中，加了序号的几处注释值得关注。

#include <iostream>
using namespace std;
class Complex
{
public:
    Complex()
    {
        real=0;
        imag=0;
    }
    Complex(double r,double i)
    {
        real=r;
        imag=i;
    }
    double getReal() const
    {
        return real;   //(1)定义公用的数据接口，可以为const成员函数
    }
    double getImag() const
    {
        return imag;
    }
    void setReal(double r)
    {
        real=r;   //(1)定义公用的数据接口
    }
    void setImag(double i)
    {
        imag=i;
    }


    void display();
private:
    double real;
    double imag;
};

//复数相加：(a+bi)+(c+di)=(a+c)+(b+d)i.
Complex operator+(const Complex &c1, const Complex &c2) //(3)将参数处理为const更符合需求
{
    Complex c;
    c.setReal(c1.getReal()+c2.getReal());   //(2)调用公用数据接口读取和修改私有数据成员
    c.setImag(c1.getImag()+c2.getImag());
    return c;
}

//复数相减：(a+bi)-(c+di)=(a-c)+(b-d)i.
Complex operator-(const Complex &c1, const Complex &c2)
{
    Complex c;
    c.setReal(c1.getReal()-c2.getReal());
    c.setImag(c1.getImag()-c2.getImag());
    return c;
}

//复数相乘：(a+bi)(c+di)=(ac－bd)+(bc+ad)i.
Complex operator*(const Complex &c1, const Complex &c2)
{
    Complex c;
    c.setReal(c1.getReal()*c2.getReal()-c1.getImag()*c2.getImag());
    c.setImag(c1.getImag()*c2.getReal()+c1.getReal()*c2.getImag());
    return c;
}

//复数相除：(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i
Complex operator/(const Complex &c1, const Complex &c2)
{
    Complex c;
    double d= (c2.getReal()*c2.getReal()+c2.getImag()*c2.getImag());
    c.setReal((c1.getReal()*c2.getReal()+c1.getImag()*c2.getImag())/d);
    c.setImag((c1.getImag()*c2.getReal()-c1.getReal()*c2.getImag())/d);
    return c;
}

void Complex::display()
{
    cout<<"("<<real<<","<<imag<<"i)"<<endl;
}

int main()
{
    Complex c1(3,4),c2(5,-10),c3;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    c3=c1+c2;
    cout<<"c1+c2=";
    c3.display();
    c3=c1-c2;
    cout<<"c1-c2=";
    c3.display();
    c3=c1*c2;
    cout<<"c1*c2=";
    c3.display();
    c3=c1/c2;
    cout<<"c1/c2=";
    c3.display();
    return 0;
}


（3）定义一个定义完整的类（是可以当作独立的产品发布，成为众多项目中的“基础工程”）。这样的类在(2)的基础上，扩展+、-、*、/运算符的功能，使之能与double型数据进行运算。设Complex c; double d; c+d和d+c的结果为“将d视为实部为d的复数同c相加”，其他-、*、/运算符类似。
[参考解答] 
#include <iostream>
using namespace std;
class Complex
{
public:
    Complex()
    {
        real=0;
        imag=0;
    }
    Complex(double r,double i)
    {
        real=r;
        imag=i;
    }
    friend Complex operator+(Complex &c1, Complex &c2);
    friend Complex operator+(double d1, Complex &c2);
    friend Complex operator+(Complex &c1, double d2);
    friend Complex operator-(Complex &c1, Complex &c2);
    friend Complex operator-(double d1, Complex &c2);
    friend Complex operator-(Complex &c1, double d2);
    friend Complex operator*(Complex &c1, Complex &c2);
    friend Complex operator*(double d1, Complex &c2);
    friend Complex operator*(Complex &c1, double d2);
    friend Complex operator/(Complex &c1, Complex &c2);
    friend Complex operator/(double d1, Complex &c2);
    friend Complex operator/(Complex &c1, double d2);
    void display();
private:
    double real;
    double imag;
};

//复数相加：(a+bi)+(c+di)=(a+c)+(b+d)i.
Complex operator+(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=c1.real+c2.real;
    c.imag=c1.imag+c2.imag;
    return c;
}
Complex operator+(double d1, Complex &c2)
{
    Complex c(d1,0);
    return c+c2; //按运算法则计算的确可以，但充分利用已经定义好的代码，既省人力，也避免引入新的错误，但可能机器的效率会不佳
}
Complex operator+(Complex &c1, double d2)
{
    Complex c(d2,0);
    return c1+c;
}
//复数相减：(a+bi)-(c+di)=(a-c)+(b-d)i.
Complex operator-(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=c1.real-c2.real;
    c.imag=c1.imag-c2.imag;
    return c;
}
Complex operator-(double d1, Complex &c2)
{
    Complex c(d1,0);
    return c-c2;
}
Complex operator-(Complex &c1, double d2)
{
    Complex c(d2,0);
    return c1-c;
}

//复数相乘：(a+bi)(c+di)=(ac－bd)+(bc+ad)i.
Complex operator*(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=c1.real*c2.real-c1.imag*c2.imag;
    c.imag=c1.imag*c2.real+c1.real*c2.imag;
    return c;
}
Complex operator*(double d1, Complex &c2)
{
    Complex c(d1,0);
    return c*c2;
}
Complex operator*(Complex &c1, double d2)
{
    Complex c(d2,0);
    return c1*c;
}

//复数相除：(a+bi)/(c+di)=(ac+bd)/(c^2+d^2) +(bc-ad)/(c^2+d^2)i
Complex operator/(Complex &c1, Complex &c2)
{
    Complex c;
    c.real=(c1.real*c2.real+c1.imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    c.imag=(c1.imag*c2.real-c1.real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
    return c;
}
Complex operator/(double d1, Complex &c2)
{
    Complex c(d1,0);
    return c/c2;
}
Complex operator/(Complex &c1, double d2)
{
    Complex c(d2,0);
    return c1/c;
}

void Complex::display()
{
    cout<<"("<<real<<","<<imag<<"i)"<<endl;
}

int main()
{
    Complex c1(3,4),c2(5,-10),c3;
    double d=11;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    cout<<"d="<<d<<endl<<endl;
    cout<<"下面是重载运算符的计算结果: "<<endl;
    c3=c1+c2;
    cout<<"c1+c2=";
    c3.display();
    cout<<"c1+d=";
    (c1+d).display();
    cout<<"d+c1=";
    (d+c1).display();
    c3=c1-c2;
    cout<<"c1-c2=";
    c3.display();
    cout<<"c1-d=";
    (c1-d).display();
    cout<<"d-c1=";
    (d-c1).display();
    c3=c1*c2;
    cout<<"c1*c2=";
    c3.display();
    cout<<"c1*d=";
    (c1*d).display();
    cout<<"d*c1=";
    (d*c1).display();
    c3=c1/c2;
    cout<<"c1/c2=";
    c3.display();
    cout<<"c1/d=";
    (c1/d).display();
    cout<<"d/c1=";
    (d/c1).display();
    return 0;
}

迂者-贺利坚
关注
  • 11
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
LHL PTA 实验11 运算符重载、模板
Simple_questions的博客
06-06 2109
题目1 6-1 学生成绩的输入和输出（运算符重载） (25分) 现在需要输入一组学生的姓名和成绩，然后输出这些学生的姓名和等级。 输入时，首先要输入学生数（正整数）N。接着输入N组学生成绩，每组成绩包括两项：第一项是学生姓名，第二项是学生的成绩（整数）。 输出时，依次输出各个学生的序号（从1开始顺序编号），学生姓名，成绩等级（不小于60为PASS，否则为FAIL） 函数接口定义： 面向Student类对象的流插入和流提取运算符 裁判测试程序样例： #include #include using name
复数的运算 运算符重载.cpp
07-07
# 运算符重载 [TOC] ## 1.定义 运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。也就是说，运算符重载是通过定义函数实现的。运算符重载实质上是函数的重载。 运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。 --- ## 2.重载运算符声明方式 由关键字 operator 和 其后要重载的运算符符号构成 - 不能被重载的运算符有：`.` 、`.*` 、`::` 、`?:` 、`sizeof` - 只能作为类成员函数重载的运算符有：`()` 、`[]` 、`->` 、`=` ```cpp 函数类型 operator 运算符名称 (形参表列) { // 对运算符的重载处理 } ``` --- ## 3.重载的两种方式 ### （1）类内重载 ​ 运算符重载函数作为类的成员函数 ```cpp #include <iostream> using namespace std; class Point{ public: Point(){};
C++第四章函数
weixin_46480973的博客
04-01 932
6-1 使用成员函数重载复数类的运算符+类Complex声明了一个复数类，有两个数据成员realPart（代表复数的实部）和imgPart（代表复数的虚部），并定义了成员函数实现了重载运算符“+”以实现两个复数对象的相加操作。成员函数Show用来输出复数的实部和虚部。请完成对运算符“+”的重载操作。Complex& Complex::operator+(Complex& com);参数com为复数类Complex的对象的引用，函数的返回值为当前对象与com对象相加后的值。#include
复数的输入输出运算符重载
最新发布
2301_80920713的博客
05-20 446
本题目要求完成复数类对象的输入运算符>>和输出运算符,使主函数可以通过cin>>接收复数对象的输入；重载输出运算符
利用重载运算符实现两个复数相加、减、乘、除
m0_55726741的博客
07-07 2204
声明一个复数类 Complex,重载运算符”+”,“-”,“*”,“/”,使之能用于复数的加、减、乘、除,运算符重载函数作为 Complex类的成员函数。编程序,分别求两个复数之和、差、积和商。 1.程序代码： 2.运行结果：...
6-1 使用成员函数重载复数类的运算符+ (5 分)
weixin_45886685的博客
07-04 1526
类Complex声明了一个复数类，有两个数据成员realPart（代表复数的实部）和imgPart（代表复数的虚部），并定义了成员函数实现了重载运算符“+”以实现两个复数对象的相加操作。成员函数Show用来输出复数的实部和虚部。请完成对运算符“+”的重载操作。 函数接口定义： Complex& Complex::operator+(Complex& com); 参数com为复数类Complex的对象的引用，函数的返回值为当前对象与com对象相加后的值。 裁判测试程序样例： #include
c++篇——从零开始学类【三】重载，对于复数
soysauce123的博客
11-18 444
1创建一个复数类，通过运算符重载方式实现复数的“+、-、X、/”运算。 2.重载流插入运算符“” 4.实现单目运算符“++，--”的重载，要求分别实现前置与后置运算符的重载，“++，--”的计算是虚部与实部都加1。
C++程序设计第十章课后习题答案——运算符重载练习
君莫笑的博客
11-06 6892
重载运算符//习题 2public:imag=0;}imag=i;}private:};}}}}}//习题 3public:imag=0;}imag=i;}private:};c3=c1+c2;c3=i+c1;c3=c1+i;}//习题 6 class Complex {public :imag= 0;imag=i;imag= 0;};double d1;
第八周实验报告1之方案三
liuchengcheng123的专栏
04-10 413
方案三：在方案二的基础上，扩展+，-,*,/运算符的功能，使之能与double型数据进行运算。另外，再定义一目运算符-，-c相当于0-c. #include using namespace std; class Complex { public: Complex(){real=0;imag=0;} Complex(double r,double i){r
C++ 运算符重载（复数类为例）
wayne17的博客
03-27 1759
/* 运算符重载（复数为例），两种重载形式：重在为类的非静态函数（加法），重载为非成员函数（减法） * 实现 +,-,++,--,<< 运算符的重载 * date: Mar,27 **/ #include <iostream> #include <cmath> using namespace std; class Complex // 复数类 { pu...
【C++】运算符重载——复数类
维欣~fighting✔
07-16 2203
CComplex类 class CComplex { public: CComplex(int real, int image) :mreal(real), mimage(image) {} private: int mreal;//实部 int mimage;//虚部 }; int main() { CComplex c1(10, 20); CComplex c2 = c1 + 10; CComplex c3 = 10 + c1; CComplex c4 = c1 + c2;
第12周项目1-实现复数类中的运算符重载
zyzct0568的博客
05-19 395
/* *Copyright (c) 2016,烟台大学计算机学院 *All rights reserved. *文件名称：text.cpp *作者：陈腾 *完成日期：2016年5月19日 *版本号：v1.0 问题描述：请用类的成员函数，定义复数类重载运算符+、-、*、/，使之能与复数的加减乘除 输入描述：定义成员函数 输出描述：复数结果 */ #include using
定义一个复数类，通过重载运算符：”+”、”-”和”*”为复数类的成员函数，直接 实现两个复数之间的运算。编写一个完整的程序包括主函数测试。
qq_25368751的博客
06-09 6596
#include&lt;iostream&gt; using namespace std; class Complex { private: double real; double image; public: Complex() { real = 0; image = 0; } Complex(double a, double b) { real = a; imag...
C++ 定义一个复数类Complex，重载运算符“＋”，“-”，使之能用于复数的加，减运算， 运算符重载函数作为Complex类的成员函数。编程序，分别求出两个复数之和，差。初值自拟
weixin_46017348的博客
11-02 3363
C++练习题： 定义一个复数类Complex，重载运算符“＋”，“—”，使之能用于复数的加，减运算， 运算符重载函数作为Complex类的成员函数。编程序，分别求出两个复数之和，差。初值自拟 注意：重载函数要作为类的成员函数 #include<iostream.h> class Complex { private: double real,imag; public: Complex(){real=0;imag=0;} Complex(double a,double b){real=a;i
定义一个复数类Complex，重载运算符“+”,“-”,“*”,“/”，使之能用于复数的加、减、乘、除。运算符重载函数作为Complex类的成员函数。编写程序，分别求两个复数之和、差、积和商。
qq904069486的博客
11-04 4007
#include &lt;iostream&gt; #include &lt;iomanip&gt; using namespace std; class Complex { public: Complex(); Complex(double r,double i); Complex operator+(Complex &amp;c2); Com...
Matlab之real和imag函数
Mrweng1996的博客
02-14 1万+
1、函数功能： real函数：求复数的实部； imag函数：求复数的虚部。 2、代码示例： clc; clear all; a = 4+1i; %复数向量 real(a) imag(a) A = [2,2;3,3]; B = [4,4;5,5]; C = A + B*i; %复数矩阵 real(C) imag(C) 运行结果： ans = 4 ans =...
real和imag在python_Python numpy.imag() 使用实例
weixin_28955929的博客
01-30 1056
The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can al...
PTA编程题摘录
热门推荐
min_mmax的博客
06-27 4万+
7-1 计算平均值（10 分） 现在为若干组整数分别计算平均值。 已知这些整数的绝对值都小于100，每组整数的数量不少于1个，不大于20个。 输入格式:首先输入K（不小于2，不大于20）。接下来每一行输入一组数据（至少有一组数据），每组至少有一个数据，在有多个数据时，两个数据之间有1到3个空格。最后一行输入100，标志输入的结束。 输出格式：对于每一组数据，输出其前K个数据的均值，如果该组...
重载运算符计算复数
m0_54158068的博客
05-23 767
重载加减运算符计算复数

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

迂者-贺利坚

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值