精华内容
下载资源
问答
  • C++复数运算

    2012-03-30 21:01:33
    综合实验,C++语言复数运算程序,正负数加减乘除运算等
  • C++ 复数运算

    2019-05-28 08:10:11
    完成复数类的运算符重载函数,包括: 基本算术运算(+、-、*、/、=) 自增自减运算(前置++、后置++、前置–、后置–) 流运算符(<< 、>>) z=a+bi(a,b均为实数)的数称为复数,其中a称为实部,...

    完成复数类的运算符重载函数,包括:

    • 基本算术运算(+、-、*、/、=)

    • 自增自减运算(前置++、后置++、前置–、后置–)

    • 流运算符(<< 、>>)
      z=a+bi(a,b均为实数)的数称为复数,其中a称为实部,b称为虚部,i称为虚数单位。
      运算法则:

    • 加法: (a+bi)+(c+di)=(a+c)+(b+d)i

    • 减法:(a+bi)-(c+di)=(a-c)+(b-d)i

    • 乘法:(a+bi)(c+di)=ac+adi+bci+bdi2 = (ac-bd)+(bc+ad)i

    • 除法:(a+bi)/(c+di)=(ac+bd)/(c2+d2) +((bc-ad)/(c2+d2))i

    由上面题目得知,该复数需要运用到重载函数。所以先写一个.h头文件,
    如下Plural.h文件

    #pragma once
    #include <iostream>
    using namespace std;
    class Plural {
    public:
    	Plural(double x = 0, double y = 0) {
    		before = x;
    		after = y;
    	}
    //基本算术运算
    	friend Plural operator + (const Plural&, const Plural&);
    	friend Plural operator - (const Plural&, const Plural&);
    	friend Plural operator * (const Plural&, const Plural&);
    	friend Plural operator / (const Plural&, const Plural&);
    	Plural& operator = (const Plural&);
    //自增自减运算
    	Plural& operator ++();//前置++
    	Plural& operator ++(int);//后置++
    	Plural& operator --();//前置--
    	Plural& operator --(int);//后置--
    
    //流运算符(<< 、>>)
    	friend ostream& operator << (ostream& output, Plural&);
    	friend istream& operator >> (istream& input, Plural&);
    private:
    	double before, after;
    };
    

    然后创建一个.cpp文件(要和.h文件同名)。
    如下Plural.cpp文件

    #include "Plural.h"//获取头文件
    //加
    Plural operator + (const Plural& a, const Plural& b) {
    	return Plural(a.before + b.before, a.after + b.after);
    }
    //减
    Plural operator - (const Plural& a, const Plural& b) {
    	return Plural(a.before - b.before, a.after - b.after);
    }
    //乘
    Plural operator * (const Plural& a, const Plural& b) {
    	Plural coud;
    	//(ac - bd) + (bc + ad)i
    	coud.before = a.before * b.before - a.after*b.after;
    	coud.after = a.after*b.before + a.before * b.after;
    	return coud;
    }
    //除
    Plural operator /(const Plural& a, const Plural& b) {
    	Plural coud;
    	//(ac + bd) / (c2 + d2) + ((bc - ad) / (c2 + d2))i
    	coud.before = ((a.before*b.before)+(a.after*b.after))/((b.before*b.before)+(b.after*b.after));
    	coud.after  = ((a.after*b.before)-(a.before*b.after))/((b.before*b.before)+(b.after*b.after));
    	return coud;
    }
    //前置++
    Plural& Plural:: operator++() {
    	return Plural(++before, ++after);
    }
    //后置++
    Plural& Plural:: operator++(int) {
    	return Plural(before++, after++);
    }
    
    //前置--
    Plural& Plural:: operator--() {
    	return Plural(--before, --after);
    }
    //后置--
    Plural& Plural::operator--(int) {
    	return Plural(before--, after--);
    }
    Plural& Plural :: operator = (const Plural& l) {
    	if (this!=&l)
    	{
    		before = l.before;
    		after = l.after;
    	}
    	return *this;
    }
    //流运算符
    ostream & operator<<(ostream& output, Plural& ary) {
    	return output << "(" << ary.before << ")+(" << ary.after << "i)";
    }
    istream & operator >> (istream& input, Plural& ary) {
    	return input >> ary.before >> ary.after;
    }
    

    最后在main.cpp文件中写入定义和操作值
    main.cpp如下:

    #include "Plural.h"
    int main()
    {
    	Plural a, b, c;
    	cin >> a >> b;
    	cout << "a = " << a << endl << "b = " << b << endl;
    	c = a + b;
    	cout << "运算符+:" << a << " + " << b << " = " << c << endl;
    	c = a - b;
    	cout << "运算符-:" << a << " - " << b << " = " << c << endl;
    	c = a * b;
    	cout << "运算符*:" << a << " * " << b << " = " << c << endl;
    	c = a / b;
    	cout << "运算符/:" << a << " / " << b << " = " << c << endl;
    	++a, ++b;
    	cout << "前置++: a = " << a << ends << "b = " << b << endl;
    	a++, b++;
    	cout << "后置++: a = " << a << ends << "b = " << b << endl;
    	--a, --b;
    	
    cout << "前置--: a = " << a << ends << "b = " << b << endl;
    	a--, b--;
    	cout << "后置--: a = " << a << ends << "b = " << b << endl;
    }
    

    演示效果如下:

    展开全文
  • c++ 复数运算

    千次阅读 2012-05-22 16:32:23
    //定义复数类complex class complex{ private: int real; //实部 int image; //虚部 public: complex(int x=0,int y=0){ real = x; image = y; } //构造函数 //重载加号运算符,功能为:两个复数对象相加 friend ...

    //定义复数类complex class complex{ private: int real; //实部 int image; //虚部 public: complex(int x=0,int y=0){ real = x; image = y; } //构造函数 //重载加号运算符,功能为:两个复数对象相加 friend complex operator + (const complex& a, const complex& b) { complex c; c.real = a.real + b.real; c.image = a.image + b.image; return c; } } //使用 complex a(2,5),b(7,8),c; c = a + b;

     

    #include<iostream.h>
    #include<math.h>


    class Complex
    {
    public:
     Complex()
     {
      this->real=0;
      this->image=0;
     }
     Complex(double a,double b);
     Complex(const Complex &c);
     void showComplex() const
     {
      if(image<0)
      {
       cout<<"("<<real<<image<<"i"<<")";
      }else{
       cout<<"("<<real<<"+"<<image<<"i"<<")";
      }
     }
     void setComplex(double a,double b)
     {
      real=a;
      image=b;
     }
     double getReal() const
     {
      return real;
     }
     double getImage() const
     {
      return image;
     }
     Complex getConj() const
     {
      Complext c(real,-image);
      return c;
     }
     double getAbs() const
     {
      return sqrt(real*real+image*image);
     }
     double getInstance(const Complex &c)
     {
      return sqrt((real-c.real)*(real-c.real)+(image-c.image)*(image-c.image));
     }
     Complex operator +(const Complex &a)
     {
      return Complex(real+a.real,image+a.image);
     }
     Complex operator +(const double a) const
     {
      return Complex(real+a,image);
     }
     Complex operator -(const Complex &b)
     {
      return Complex(real-b.real,image-b.image);
     }
     Complex operator -(const double b)
     {
      return Complex(real-b,image);
     }
     Complex operator *(const Complex &c)
     {
      return Complex(real*c.real,image*c.image);
     }
     Complex operator *(const double c)
     {
      return Complex(real*c,image);
     }
     Complex operator /(const Complex &c)
     {
      return Complex((real*c.real+image*c.image)/(c.real*c.real+c.image*c.image),(image*c.real-real*c.image)/(c.real*c.real+c.image*c.image));
     }
     Complex operator /(const double c)
     {
      return Complex(real/c,image/c);
     }
     Complex operator =(const Complex &c)
     {
      return Complex(c.real,c.image);
     }
     bool operator==(const Complex &c) const;
    private:
     double real;
     double image;
    };
    Complex::Complex(double a,double b)
    {
     this->real=a;
     this->image=b;
    }

    Complex::Complex(const Complex &c)
    {
     real=c.real;image=c.image;
    }
    bool Complex::operator==(const Complex &c)
    {
     if(c.real==real && c.image==image)
      return true;
     else
      return false;
    }
    void main(void)
    {
     cout<<"OK"<<endl;
     Complex z1(23.12,234.1);
     Complex z2(21.2,-89.09);
     z1.showComplex();
     cout<<"/";
     z2.showComplex();

     Complex z3;
     z3=z1/z2;
     cout<<"=";
     z3.showComplex();
     cout<<endl;
    }

     

    展开全文
  • 标准C++复数运算类详解及使用例程

    万次阅读 多人点赞 2016-03-17 11:38:59
     1)标准C++复数运算库:complex ObjectName(realPart, imagePart);  2)自定义复数运算类:包括复数的实部、虚部、四则运算、模运算、共轭等。  后者可以根据需要自己定义,关于类的定义这里不再说明,具体的...

        在C++中复数运算可以通过两种方式来实现:

        1)标准C++复数运算库:complex<typedef> ObjectName(realPart, imagePart);

        2)自定义复数运算类:包括复数的实部、虚部、四则运算、模运算、共轭等。

        后者可以根据需要自己定义,关于类的定义这里不再说明,具体的功能可以根据自己的需要去实现。这里介绍C++标准的复数运算类complex,网上已经有一些关于complex类的简单介绍,但大多都是比较粗略的说明,并没有提供完整而详细的介绍。这里参考了网上的一些资源,首先介绍complex类的定义,包括:对象的构造方法、算术运算、赋值运算符、指数运算、对数运算、幂运算、三角函数运算、输入输出重载等,然后给出了一个使用例程,用于对其使用方法的总结用户总结。


    一、complex类简介


        C++复数运算由标准C++复数运算库(complex number mathematics library)来实现。complex类定义了标准的输入输出运算、算是运算、关系运算和赋值运算,同时还包括指数运算、对数运算、幂运算、平方根、三角函数(正弦,余弦,双曲正弦,双曲余弦)等,还包括笛卡尔坐标系到极坐标系转换的函数。


    二、文件包含


    1、 #include <complex.h>

    2、 #include <math.h>


    三、构造方法


    1、complex为模板类,因此在定义一个复数时需要制定变量类型,如complex<double> cm(1,1);

    2、定义时实部和虚部参数可以使用变量,如:

    double a = 1;
    double b = 1;
    complex<double> cm(a, b);


    3、以下定义均合法:

        a) complex(): complex<double> c1;// c1 = (0,0);

        b) complex(double real, double<double> imag = 0.0): complex c2(1.0);// c2 = (1.0,0);

        c) complex<double> c3 = 3.4; // c3 = (3.4,0);

        d) complex c4 = 3.4 + complex(1.2, 3.5);


    四、笛卡尔坐标系和极坐标系下有关函数


    1、real();: friend double real(complex a);

    2、 img();: friend double imag(complex a);

    3、 abs();: friend double abs(complex a);

    4、 norm();: friend double norm(complex a);

    5、 arg();: friend double arg(complex a);

    6、 conj();: friend complex conj(complex a);

    7、 polar();: friend complex polar(double r,double t);


    示例:

    d = real(a);// 返回复数a的实部
    d = imag(a);// 返回复数a的虚部
    d = abs(a);// 返回复数a的模值/幅值
    d = norm(a);// 返回复数a的模值平方
    d = arg(a);// 返回复数a的幅角
    z = conj(a);// 返回复数a的共轭复数
    z = polar(r,t);// 复数的极坐标定义方式,r为幅值,t为幅角


    五、指数、对数、幂、平方根运算函数


    1、 exp(); friend complex exp(complex a);

    2、 log(); friend complex log(complex a);

    3、 pow(); 四种

            a) friend complex pow(double a, complex b);

            b) friend complex pow(complex a, int b);

            c) friend complex pow(complex a, double b);

            d) friend complex pow(complex a,complex b);

    4、 sqrt();friend complex sqrt(complex a);


    六、三角关系运算函数


    1、 sin(); friend complex sin(complex a);

    2、 cos(); friend complex cos(complex a);

    3、 sinh(); friend complex sinh(complex a);

    4、 cosh(); friend complex cosh(complex a);


    七、运算符重载


        运算符重载包括:+、-、*、/(包括+=、-=、*=、/=)、==、!=、<<、>>



    八、使用例程


    1、开发环境:Win7 (X64) / VS2010

    2、创建新项目,编写代码如下:

    #include <iostream>
    #include <complex>
    #include <math.h>
    
    using namespace std;
    
    void main()
    {
    	// 复数类对象定义
    	cout << "复数类对象定义" << endl;
    	double r = 1.0;
    	double x = 1.0;
    	complex<double> c1;
    	complex<double> c2(1,1);
    	complex<double> c3(r,x);
    	complex<double> c4 = 2.0;
    	complex<double> c5 = c4 + complex<double>(2,1);
    
    	cout << "c1 = " << c1 << endl;
    	cout << "c2 = " << c2 << endl;
    	cout << "c3 = " << c3 << endl;
    	cout << "c4 = " << c4 << endl;
    	cout << "c5 = " << c5 << endl << endl;
    
    	// 笛卡尔坐标系和极坐标系下有关函数
    	cout << "笛卡尔坐标系和极坐标系下有关函数" << endl;
    	cout << "c5实部real:" << c5.real() << endl;
    	cout << "c5虚部imag:" << c5.imag() << endl;
    	cout << "c5模值abs:" << abs(c5) << endl;
    	cout << "c5模值平方norm:" << norm(c5) << endl;
    	cout << "c5幅角arg:" << arg(c5) << endl;
    	cout << "c5共轭复数conj:" << conj(c5) << endl;
    	complex<double> z = polar(1.0, 3.14/6);
    	cout << "复数极坐标定义polar:" << z << endl << endl;
    
    	// 运算符重载,四则运算
    	cout << "运算符重载,四则运算" << endl;
    	cout << "c2 + c5 = " << c2 + c5 << endl;
    	cout << "c2 - c5 = " << c2 - c5 << endl;
    	cout << "c2 * c5 = " << c2 * c5 << endl;
    	cout << "c2 / c5 = " << c2 / c5 << endl << endl;
    
    	system("pause");
    }

    3、运行结果如图1所示:


    图1


    参考:

    1)http://blog.chinaunix.net/uid-20559667-id-1924707.html

    2)http://blog.csdn.net/qhs1573/article/details/12254205




    展开全文
  • C++复数运算的运算符重载

    千次阅读 2015-07-19 09:07:22
    C++提供了运算符重载,极大地方便了自定义类型之间的运算, 本文就最简单的复数运算实现让初学者体会运算符重载的作用以及运算符重载的原理。

    C++提供了运算符重载,极大地方便了自定义类型之间的运算,

    本文就最简单的复数运算实现让初学者体会运算符重载的作用以及运算符重载的原理。


    假设我们有如下复数类

    class Complex
    {
    private:
    	double real;<span style="white-space:pre">			</span>//代表实数部分
    	double image;<span style="white-space:pre">			</span>//代表虚数部分
    public:
    
    	Complex(){real=0;image=0;}<span style="white-space:pre">	</span>//默认构造函数<span style="white-space:pre">	</span>
    	Complex(double r,double i)<span style="white-space:pre">	</span>//构造函数
    	{
    	real=r;
    	image=i;
    	}
    }

    现在我们有两个复数,并想计算和要怎么实现呢?(如下)

    Complex sum,c1,c2;
    sum=c1+c2;

    要在以前,我们是这么计算的:

    Complex sum,c1,c2;
    sum.real=c1.real+c2.real;
    sum.image=c1.image+c2.image;
    

    看起来似乎也不是很复杂,但如果这个类的属性很多,有好几个甚至好几十个呢?这时候C++运算符重载的优势就体现出来了。实现了运算符重载后上述的sum=c1+c2就能直接进行计算了。

    实现运算符重载之前我们先要知道其表现形式有两种:重载为成员函数,重载为友元函数

    不懂?不要急!我们先从一个简单的函数出发:

    Complex operate + (Complex c2)
    {
    Complex c;
    c.real=this->real+c2.real;
    c.image=this->image+c2.image;
    }

    注意到,运算符重载的申明形式为:

    函数类型 operate 运算符 (形参列表)

    {

    ...

    }


    可以发现这个重载函数将加的运算封装进了Complex类的+运算中使其能支持该类的直接运算。

    + 运算实现两个数相加自然需要两个参数,为何只有c2一个参数呢?

    因为上述这段代码将 Complex类的 + 重载为了成员函数,其实它的形参表里隐含了一个this指针,实质上这个成员函数有两个形参(Complex* this,Complex c2),只不过被隐含了。

    即该函数能利用this指针直接访问该类的private变量real和image,this指针也可省略不写。

    这一规则也就意味着重载为类的成员函数时必须写成静态形式,即在函数类型前面加上 const 关键字,以防止this指针的滥用改变了不该改变的成员变量。

    另外,为了有效利用C++的高效,传参时应使用引用而不是,但不在本文讨论范围故不在赘述。

    优化后的代码:

    const Complex operate + (const Complex &c2)	//第一个const表示函数只读,防止this指针滥用 
    {						//第二个const防止引用的滥用
    Complex c;
    c.real=real+c2.real;				//隐含了this指针
    c.image=image+c2.image;
    return c;
    }




    那么这个运算能被重载为友元函数么?什么是友元函数?

    先来看这段代码:

    friend Complex operator +(const Complex &c1,const Complex &c2)
    {
    	return Complex(c1.real+c2.real,c1.image+c2.image);
    }


    这是 Complex 类的 + 重载为了友元函数。由于不是成员函数,因此没有隐含的 this 指针,故要把 + 左右两边的参数都传进去,为了使该函数能够访问其他 Complex 对象的成员变量 real 和 image,必须申明为友元函数。 

    声明为友元函数更重要的一个理由:重载一个运算符,使之不再需要用"对象.成员名"的形式调用。参见下表。

    该友元函数的形参代表了依自左向右次序排列的各操作数。

    为了区分前置后置运算,后置单目运算符++、--的重载,形参表中要增加一个 int,但不必写形参名。


    重载为成员函数与重载为友元函数的区别:

    运算符成员函数的设计:

    运算符 使用形式 等价式
    双目运算符@ X1 @ X2 X1.operate @ (X2)
    前置单目@ @ X X1.operate @()
    后置单目@ X @ X1.operate @(0)

    运算符友元函数的设计:

    运算符 使用形式 等价式
    双目运算符@ X1 @ X2 operate @ (X1,X2)
    前置单目@ @ X operate @(X1)
    后置单目@ X @ operate @(X1,0)

    * 后置单目运算中多出来的0参数仅表示其后置意义。

    由上可知,重载为成员函数时:形参个数 = 原操作数个数 -1 (-1为隐含的this指针)(后置++ --除外)  

      重载为友元函数时:形参个数 = 原操作数个数


    那么什么时候该重载为成员函数,什么时候该重载为友元函数呢?

    为类设计重载操作符的时候,必须选择是将操作符设置为 类成员还是友元函数。在某些情况下,程序员没有选择, 操作符必须是成员;在另一些情况下,有些经验原则可指导我们做出决定。

    遵循下列原则:

    1. 赋值(=)、下标([])、调用(())和成员访问箭头(->)等操作符必须定义为成员,将这些操作符定义为非成员函数将在编译时标记为错误。  
    2. 像赋值一样,复合赋值操作符通常应定义为类的成员函数,与赋值不同的是,不一定非得这样做,如果定义非成员复合赋值操作符,不会出现编译错误
    3. 改变对象状态或与给定类型紧密联系的其他一些操作符, 如自增、自减和解引用,通常就定义为类成员。 
    4. 对称的操作符,如算术操作符、相等操作符、关系操作 符最好定义为友元函数。 
    5.  >>、<<操作符定义为友元函数。

    运算符 + 与 += 的重载区别与联系?

    回过头来看,在重载了 + 运算符时,通常会同时重载 += 运算符,思考下这两个运算符应该怎么重载? 

    1. operator+  通常定义成非成员,operator+=通常定义成成员 
    2. operator+= 返回操作数的引用,而operator+返回一个临时对象
    3. 通常我们用 operator += 来实现 operator+
    4. 其它算术操作符(+,-,*,/,%)同+ 

    废话少说,上代码解释:

    //重载 +=(复数相加)
    	Complex operator +=(const Complex &c2)
    	{
    		real+=c2.real;
    		image+=c2.image;
    		return *this;
    	}

    //重载 +(复数相加)
    	friend Complex operator +(const Complex &c1,const Complex &c2)
    	{
    		Complex c(c1);
    		c+=c2;
    		return c;
    	}

    为什么要用 += 来实现 + 呢?

    基于效率考虑,这样可以使 += 返回一个操作数的引用,而 + 不行。(故 += 效率远大于 + )


    最后几点:

    如果一个运算符想用某个基本类型的数据调用,它就必须定义成全局的友元函数。

    如: complex a; complex b = 2 + a;   

    这个 operator+ 不能是 complex 类的成员函数,也不能是其他类的成员函数,因为不存在一个函数: 

         complex & int.operator+ ( complex& rhs) 


    最后的最后,贴出一些简单运算符的重载代码,其他的自行思考。

    //复数相关运算的运算符重载
    
    
    #include <iostream>
    using namespace std;
    
    class Complex
    {
    private:
    	double real;
    	double image;
    public:
    
    	Complex(){real=0;image=0;}
    	Complex(double r,double i)
    	{
    	real=r;
    	image=i;
    	}
    	
    	void ShowComplex()
    	{		
    		cout<<real;
    		if(real>0) cout<<"+";
    		cout<<image<<"i"<<"\n";
    	}
    	
    	//重载 <<
    	friend ostream& operator <<(ostream &out,const Complex &c)
    	{
    		out<<c.real;
    		if(c.real>0) out<<"+";
    		out<<c.image<<"i"<<"\n";
    		return out;
    	}
    	
    	//重载 >>
    	friend istream& operator >>(istream &in,Complex &c)
    	{
    		cout<<"input r:"<<endl;
    		in>>c.real;
    		cout<<"input i:"<<endl;
    		in>>c.image;
    		return in;
    	}
    	
    	//重载 =
    	Complex operator =(const Complex &c)
    	{
    		if(this == &c) return *this; 	//重要!防止自赋值导致低效
    		real=c.real;
    		image=c.image;
    		return *this;
    	}
    
    	//重载 -=
    	Complex operator -=(const Complex &c2)
    	{
    		real-=c2.real;
    		image-=c2.image;
    		return *this;
    	}
    
    	//重载 +=(两个复数相加)
    	Complex operator +=(const Complex &c2)
    	{
    		real+=c2.real;
    		image+=c2.image;
    		return *this;
    	}
    
    	//重载 +=(复数与实数相加)
    	Complex operator +=(double c2)
    	{
    		real+=c2;
    		return *this;
    	}
    
    	//重载 *=
    	Complex operator *=(const Complex &c2)
    	{
    		real=real*c2.real-image*c2.image;
    		image=image*c2.real+real*c2.image;
    		return *this;
    	}
    
    	//重载/=
    	Complex operator /=(const Complex &c2)
    	{
    		real=(real*c2.real+image*c2.image)/(c2.real*c2.real+c2.image*c2.image);
    		image=(image*c2.real-real*c2.image)/(c2.real*c2.real+c2.image*c2.image);
    		return *this;
    	}
    
    
    	//重载 +(复数相加)
    	friend Complex operator +(const Complex &c1,const Complex &c2)
    	{
    		Complex c(c1);
    		c+=c2;
    		return c;
    	}
    
    	//重载 +(复数与实数相加)
    	friend Complex operator +(const Complex &c1,double c2)
    	{
    		Complex c(c2,0);
    		c+=c1;
    		return c;
    	}
    
    	//重载 -
    	friend Complex operator -(const Complex &c1,const Complex &c2)
    	{
    		Complex c(c1);
    		c-=c2;
    		return c;
    	}
    
    	//重载 *
    	friend Complex operator *(const Complex &c1,const Complex &c2)
    	{
    		Complex c(c1);
    		c*=c2;
    		return c;
    	}
    
    	//重载 /
    	friend Complex operator /(const Complex &c1,const Complex &c2)
    	{
    		Complex c(c1);
    		c/=c2;
    		return c;
    	}
    	
    };
    
    int main()
    {
    	Complex c;
    	Complex c1(1.5,2.5);
    	Complex c2(2.5,3.5);
    	cout<<"c1:\t";
    	c1.ShowComplex();
    	cout<<"c2:\t";
    	c2.ShowComplex();
    	c=c1+c2;
    	cout<<"c1+c2:\t";
    	c.ShowComplex();
    	cout<<"c1+5:\t";
    	c1+=5;
    	c1.ShowComplex();
    	c=c1-c2;
    	cout<<"c1-c2:\t";
    	c.ShowComplex();
    	c=c1*c2;
    	cout<<"c1*c2:\t";
    	c.ShowComplex();
    	c=c1/c2;
    	cout<<"c1/c2:\t";
    	c.ShowComplex();
    	cin>>c1;
    	cout<<"c:"<<c1;
    	return 0;
    }
    

    运算符重载表:

    可以重载C++中除下列运算符之外的所有运算符:

    . .* :: ?: sizeof typeid # static_cast<> dynamic_cast<>   const_cast<>   reinterpret_cast<>     ||   &&   ,

    可重载运算符: 

    + - * / % ^ & | ~ ! = < > <= >= ++ -- >> == != += -= /= %= ^= &= |= *= <<= >>= [] () -> ->* new new [] delete delete [] 






    展开全文
  • C++ 复数运算(友元函数)

    千次阅读 2020-04-25 14:44:37
    复数类的声明如下: 要求如下: 实现复数类和友元函数addCom和outCom。 参考addCom函数为复数类增加一个友元函数minusCom,用于实现两个复数的减法 在main函数中,通过友元函数,实现复数的加减法和复数的...
  • C++复数运算C++复数运算C++复数运算
  • C++复数运算

    2016-06-25 20:17:47
    C++复数运算C++复数运算C++复数运算C++复数运算
  • C++复数四则运算。。。。。。。。。。。。。。。
  • 复数运算

    2021-05-13 16:00:30
    复数运算法则:https://baike.baidu.com/item/复数/254365?fr=aladdin C++ 代码实现:标准C++复数运算类详解及使用例程
  • C++复数运算

    2013-01-15 17:48:25
    通过C++实现复数的四则运算,希望大家多多肯定,支持哦。
  • 复数运算 C++

    2011-09-16 08:45:26
    复数运算及直角坐标转换 运用类的定义 友元类
  • 这是C++复数运算的一种方法的源代码!
  • C++封装复数类,实现复数运算

    千次阅读 2019-01-03 11:07:19
    复数类Complex中定义了两个私有的成员变量 real 和 img 分别表示...然后是一个没有返回值对的disp()函数用来显示输出复数的值,接下来就是对四则运算的重载函数和一个赋值重载运算符的重载,用来计算该复数的...
  • class Complex//复数类,重载运算符使其能进行复数运算 { private: double x; double y; public: double GetValuex(){return x;}; double GetValuey(){return y;}; void SetValue(double m0,double n0){x=m0;y=...
  • C++ 复数类的运算

    2020-04-27 17:10:35
    根据以下代码段完善 ?? 处内容及程序内容,以实现规定的输出。 class Complex { public: Complex(double r=0, double i=0):real(r), imag(i){ } Complex operator+( ??...//重载双目运算符'+' ...
  • 进行运算。返回给空对象c3 cout << "c1="; c1.display(); //调用c1的成员函数display,输出c1的值 cout << "c2="; c2.display(); //调用c2的成员函数display,...
  • C++:实现复数运算

    千次阅读 2019-01-19 20:43:03
    要求使用c++ class编写程序。可以创建如下class #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;iostream&gt; #include &lt;algorithm&gt; using namespace .....
  • 定义一个表示复数的Complex类,包含实部和虚部的两个属性。 在类的外部以友元函数的形式重载+、-、*等运算符。 class Complex{ public: Complex(double r,double i){ …… } //友元函数声明 private: double ...
  • 运用c++语言编写的源程序,可以实现复数的基本运算,如加法,减法,乘法,除法。
  • c++期末大作业,复数运算。 编程思路: (1)确定Complex复数类的数据成员和成员函数。 (2)重载运算符“+、-、*、/”的友元函数 ,重载流插入运算符“”和流提取运算符 “>>” 。 (3)复数和整数运算时在运算符...
  • 运用class实现分数和复数的四则运算,比较大小,适用于class初学者的编程练习
  • C++大学教程第五版第十一章课后作业复数运算和指数运算
  • 复数运算C++实现)

    千次阅读 2020-02-14 13:47:03
    定义复数类Complex,利用运算符重载实现复数的加、减、乘、除四则运算
  • C++ 重载运算符实现复数相加1、重载运算符为成员函数2、重载运算符为友元函数 1、重载运算符为成员函数 Complex.h #ifndef COMPLEX_H #define COMPLEX_H #include <iostream> using namespace std; class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,352
精华内容 4,140
关键字:

c++复数运算

c++ 订阅