一个等式中，未知数是Z（复数），可以直接对其进行加减乘除吗？

给你弄了几行~你照着写下去吧~好久没有动手了~#includeclassComplex{public:Complex(doubler=0,doublev=0):real(r),virt(v){}friendComplexoperator+(Complexa,Complexb);friendostream&operator<<(ostream&out,Complex&a);private:doublereal;doublevirt;};ostream&operator<<(ostream&out,Complex&a){returnout<评论00加载更多

D 对于复数的加减法运算法则判断出①对；对于②向量a的性质 ，但 是实数，但 不一定是实数，如z=i，就不成立，故②错；对于③复数加法的几何意义判断出③对，故选D

不知道是不是 ～//复数类。public class Complex{ private double real,im; //实部，虚部 public Complex(double real, double im) //构造方法 { this.real = real; this.im = im; } public Complex(double real) //构造方法重载 { this(real,0); } public Complex() { this(0,0); } public Complex(Complex c) //拷贝构造方法 { this(c.real,c.im); } public boolean equals(Complex c) //比较两个对象是否相等 { return this.real==c.real && this.im==c.im; } public String toString() { return "("+this.real+"+"+this.im+"i)"; } public void add(Complex c) //两个对象相加 { //改变当前对象，没有返回新对象 this.real += c.real; this.im += c.im; } public Complex plus(Complex c) //两个对象相加，与add()方法参数一样不能重载 { //返回新创建对象，没有改变当前对象 return new Complex(this.real+c.real, this.im+c.im); } public void subtract(Complex c) //两个对象相减 { //改变当前对象，没有返回新对象 this.real -= c.real; this.im -= c.im; } public Complex minus(Complex c) //两个对象相减，与subtract()方法参数一样不能重载 { //返回新创建的对象，没有改变当前对象 return new Complex(this.real-c.real, this.im-c.im); }}class Complex__ex{ public static void main(String args[]) { Complex a = new Complex(1,2); Complex b = new Complex(3,5); Complex c = a.plus(b); //返回新创建对象 System.out.println(a+" + "+b+" = "+c); } }/*程序运行结果如下：(1.0+2.0i) + (3.0+5.0i) = (40.0+7.0i)*/

首先1i/1-i可以化简.同乘1i得（i方加2i加1）/2.因为i方等于-1所以这时候这项变成i.然后原来的试子就变成了i乘i方乘i的二次方乘i的三次方乘.一直乘到i的一百次方,最后的i的五千零五十次方.化简的负一

#include "iostream.h"class Complex{ private: double real,imag; public: Complex(double r,double i) { real=r; imag=i; } /*friend Complex operator +(Complex& a,Complex& b)//友元运算符重载 { double r=a.real+b.real; double i=a.imag+b.imag; return Complex(r,i); }*/ Complex operator +(Complex&b)//类运算符重载 { double r=real+b.real; double i=imag+b.imag; return Complex(r,i); } show() { cout<<real<<"+"<<imag<<"i"; } };void main(){ Complex c1(6,3),c2(3,6),c=c1+c2; c1.show(); cout<<"+"; c2.show(); cout<<"="; c.show(); cout<<endl;}以上重载"+",重载"-"以此类似,仅供参考

去括号的时候要把括号前的“系数”乘以括号内的每一项，也就是说如果括号前是加就直接去掉，如果是减就要改变括号内的每一项符号，再去掉

不知道是不是 ～//复数类。public class Complex{ private double real,im; //实部，虚部 public Complex(double real, double im) //构造方法 { this.real = real; this.im = im; } public Complex(double real) //构造方法重载 { this(real,0); } public Complex() { this(0,0); } public Complex(Complex c) //拷贝构造方法 { this(c.real,c.im); } public boolean equals(Complex c) //比较两个对象是否相等 { return this.real==c.real && this.im==c.im; } public String toString() { return "("+this.real+"+"+this.im+"i)"; } public void add(Complex c) //两个对象相加 { //改变当前对象，没有返回新对象 this.real += c.real; this.im += c.im; } public Complex plus(Complex c) //两个对象相加，与add()方法参数一样不能重载 { //返回新创建对象，没有改变当前对象 return new Complex(this.real+c.real, this.im+c.im); } public void subtract(Complex c) //两个对象相减 { //改变当前对象，没有返回新对象 this.real -= c.real; this.im -= c.im; } public Complex minus(Complex c) //两个对象相减，与subtract()方法参数一样不能重载 { //返回新创建的对象，没有改变当前对象 return new Complex(this.real-c.real, this.im-c.im); }}class Complex__ex{ public static void main(String args[]) { Complex a = new Complex(1,2); Complex b = new Complex(3,5); Complex c = a.plus(b); //返回新创建对象 System.out.println(a+" + "+b+" = "+c); } }/*程序运行结果如下：(1.0+2.0i) + (3.0+5.0i) = (40.0+7.0i)*/

in cmplx.h#ifndef CMPLX1_H_#define CMPLX1_H_#ifdef __cplusplusextern "C"{#endiftypedef struct _CMPLX{ float c_real; float c_vir;}CMPLX, *PCMPLX;CMPLX CMPLX_(float real, float vir);//operations between CMPLXCMPLX C_add(CMPLX c_l, CMPLX c_r);CMPLX C_sub(CMPLX c_l, CMPLX c_r);CMPLX C_mul(CMPLX c_l, CMPLX c_r);CMPLX C_div(CMPLX c_l, CMPLX c_r);void C_out(CMPLX data);#ifdef __cplusplus}#endif#endif /* CMPLX1_H_ */in cmplx.c#include <stdio.h>#include <string.h>#include "cmplx.h"CMPLX CMPLX_(float real, float vir){ CMPLX d; d.c_real = real; d.c_vir = vir; return d;}CMPLX C_add(CMPLX c_l, CMPLX c_r){ c_l.c_real += c_r.c_real; c_l.c_vir += c_r.c_vir; return c_l;}CMPLX C_sub(CMPLX c_l, CMPLX c_r){ c_l.c_real -= c_r.c_real; c_l.c_vir -= c_r.c_vir; return c_l;}CMPLX C_mul(CMPLX c_l, CMPLX c_r){ int rl = c_l.c_real; int vl = c_l.c_vir; int rr = c_r.c_real; int vr = c_r.c_vir; c_l.c_real = rl*rr - vl*vr; c_l.c_vir = rl*vr + rr*vl; return c_l;}CMPLX C_div(CMPLX c_l, CMPLX c_r){ CMPLX c_r_r = CMPLX_(c_r.c_real, -c_r.c_vir);/*a-b*i*/ float c_d = (c_r.c_real*c_r.c_real + c_r.c_vir*c_r.c_vir); if(c_d == 0) { memset(&c_l, 0x00, sizeof(CMPLX)); return c_l; } c_l = C_mul(c_l, c_r_r); c_l.c_real /= c_d; c_l.c_vir /= c_d; return c_l;}void C_out(CMPLX data){ if(data.c_real!=(float)0.0 && data.c_vir!=(float)0.0) printf("%f%c%fi ", data.c_real,data.c_vir<0?("-"):("+"), data.c_vir<0?(-data.c_vir):(data.c_vir)); else if(data.c_real == (float)0) printf("%fi ", data.c_vir); else if(data.c_vir == (float)0) printf("%f ", data.c_real);}in P4.c#include <stdio.h>#include "cmplx.h"int test(){ CMPLX dat1 = CMPLX_(2, 1); CMPLX dat2 = CMPLX_(1, 1); CMPLX dat_sum = C_add(dat1, dat2); CMPLX dat_sub = C_sub(dat1, dat2); CMPLX dat_mul = C_mul(dat1, dat2); CMPLX dat_div = C_div(dat1, dat2); C_out(dat_sum); C_out(dat_sub); C_out(dat_mul); C_out(dat_div); return 1;}int main(){ test(); return 0;}

你必须有一个输入格式约定，无论简单或复杂。例如：必须有实部和虚部，格式为3-2i1-i1+i等。然后才好处理。这里放入charstr[80]；了，如果是键盘输入流，也用类似格式。#include<stdio.h>main(){charstr[80]="1-i";//1+i2-2i2+3i0-iintr,m;inti,flag,s;flag=sscanf(str,"%d%di",&r,&m);if(flag==1){s=1;for(i=0;i<strlen(str);i++)if(str[i]=="-")s=-1;elseif(str[i]=="+")s=1;m=s;}printf("real=%dimag=%d ",r,m);return0;}

U1uff0bU2uff1dj30uff0b100uff1d104.4U000200cb16.70u20e3ufe0fV

因为复数虽然是表示为a+bi的形式，但它和向量确实不是一回事啊~~ 复数终归就是一个数啊~ 2维向量的两个维是等同的，而复数的1和i可以看成是不同的单位。而且i*i=-1，这一点是向量办不到的。 另外，比如说复数可以计算几次方，向量根本没这回事。

#include <iostream>using namespace std;class Complex{public: Complex(double pr=0, double pi=0) { real=pr; imag=pi; } Complex operator+(Complex c); Complex operator-(Complex c); Complex operator*(Complex c); Complex operator/(Complex c); void display();private: double real; double imag;};Complex Complex::operator+(Complex c){ return Complex(real+c.real, imag+c.imag);}Complex Complex::operator-(Complex c){ return Complex(real-c.real, imag-c.imag);}Complex Complex::operator*(Complex c){ double r,i; r=real*c.real+imag*c.imag; i=imag*c.real+real*c.imag; return Complex(r,i);}Complex Complex::operator/(Complex c){ double r,i,d; r=real*c.real+imag*c.imag; i=imag*c.real+real*c.imag; d=c.real*c.real+c.imag*c.imag; if(d>0) return Complex(r/d,i/d); else{ cout <<"Error!"; exit(1); }} void Complex::display(){ cout <<real<<"+"<<imag<<"i"<<endl;}int main(){ Complex c1(3,4),c2(-5,6),c3,c4,c5,c6; c3=c1+c2; c4=c1-c2; c5=c1*c2; c6=c1/c2; c3.display(); c4.display(); c5.display(); c6.display(); return 0;}

循环用当型循环吧 复数 你单独写个世子 去判断下

题中二复数之和等于-14.05-2.34i因为实部与虚部都小于0,故该复数位于复平面第三象限它的幅角应为arctan(-2.34/-14.05)-180°,从而等于170.54°复数分为实部和虚部，记为a+ib在直角坐标系中，横轴代表实数，纵轴代表虚数，以A（a,b）代表实数A=a+ib，在极坐标系中，以原点作为始点，A（a,b）作为终点的矢量代表该虚数，用A（r,θ）表示，其中r=(a平方+b平方）的开二次方，θ=arctg（b/a)。扩展资料：极坐标系是一个二维坐标系统。该坐标系统中的点由一个夹角和一段相对中心点——极点（相当于我们较为熟知的直角坐标系中的原点）的距离来表示。极坐标系的应用领域十分广泛，包括数学、物理、工程、航海以及机器人等领域。在两点间的关系用夹角和距离很容易表示时，极坐标系便显得尤为有用；而在平面直角坐标系中，这样的关系就只能使用三角函数来表示。对于很多类型的曲线，极坐标方程是最简单的表达形式，甚至对于某些曲线来说，只有极坐标方程能够表示。参考资料来源：百度百科-极坐标

那个i，你把它当成字母输出

第二步+i移到括号时应该变成-i望采纳

正解见下：#include<iostream>using namespace std;class complex//复数类声明{private: double real; double image;public: complex(double r=0.0,double i=0.0)//构造函数 { real=r; image=i; } complex operator+(complex c2);//+重载为成员函数 complex operator-(complex c2);//-重载为成员函数 complex operator*(complex c2);//*重载为成员函数 friend complex operator/(complex,complex);///重载为成员函数 bool operator==(complex c2);//==重载为成员函数 void display();};complex complex::operator +(complex c2)//重载的实现{complex c;c.real=c2.real+real;c.image=c2.image+image;return complex(c.real,c.image);}complex complex::operator -(complex c2)//重载的实现{complex c;c.real=real-c2.real;c.image=image-c2.image;return complex(c.real,c.image);}complex complex::operator *(complex c2)//重载的实现{complex c;c.real=c2.real*real;c.image=c2.image*image;return complex(c.real,c.image);}complex operator/(complex c1,complex c2)//重载的实现{return complex(c1.real/c2.real,c1.image/c2.image);}bool complex::operator ==(complex c2)//重载的实现{if((real==c2.real)||(image==c2.image))return true;else return false;}void complex::display(){cout<<"("<<real<<","<<image<<")"<<endl;}void main(){complex c1(5.0,4),c2(5.0,4),c3;cout<<"c1=";c1.display();cout<<"c2=";c2.display();c3=c1+c2;//使用重载运算符完成复数加法cout<<"c3=c1+c2=";c3.display();c3=c1-c2;//使用重载运算符完成复数减法cout<<"c3=c1-c2=";c3.display();c3=c1*c2;//使用重载运算符完成复数乘法cout<<"c3=c1*c2=";c3.display();c3=c1/c2;//使用重载运算符完成复数除法cout<<"c3=c1/c2=";c3.display();//使用重载运算符完成两个复数的比较bool result=(c1==c2);cout<<"(c1==c2)="<<result<<endl

i^2=-1原式=i-1+1+1+i=1+2i

// Lab 4: Complex.h#ifndef COMPLEX_H#define COMPLEX_H/* Write class definition for Complex */#include <iostream>//#include <double>using namespace std;#include "Complex.h"// Complex class definitionclass Complex{public: ComplexNumber(double ,double ); void setComplexNumber(double rp, double ip); // double getComplexNumber(); Complex add(const Complex & ); Complex subtract(const Complex &); void printComplex(); Complex(double ,double);private: double realPart; double imaginaryPart;};#endif// Lab 4: ComplexTest.cpp#include <iostream>using namespace std;#include "Complex.h"int main(){ Complex a( 1, 7 ), b( 9, 2 ), c(0,0); // create three Complex objects a.printComplex(); // output object a cout << " + "; b.printComplex(); // output object b cout << " = "; c = a.add( b ); // invoke add function and assign to object c c.printComplex(); // output object c cout << " "; a.setComplexNumber( 10, 1 ); // reset realPart and b.setComplexNumber( 11, 5 ); // and imaginaryPart a.printComplex(); // output object a cout << " - "; b.printComplex(); // output object b cout << " = "; c = a.subtract( b ); // invoke add function and assign to object c c.printComplex(); // output object c cout << endl;} // end main// Lab 4: Complex.cpp// Member-function definitions for class Complex.#include <iostream>using namespace std;#include "Complex.h"Complex::Complex( double real, double imaginary ){ setComplexNumber( real, imaginary );} // end Complex constructorComplex Complex::add( const Complex &right ){ /* Write a statement to return a Complex object. Add the realPart of right to the realPart of this Complex object and add the imaginaryPart of right to the imaginaryPart of this Complex object */ realPart=realPart+right.realPart; imaginaryPart=imaginaryPart+right.imaginaryPart; return Complex(realPart,imaginaryPart);} // end function addComplex Complex::subtract( const Complex &right ){ /* Write a statement to return a Complex object. Subtract the realPart of right from the realPart of this Complex object and subtract the imaginaryPart of right from the imaginaryPart of this Complex object */ realPart=realPart-right.realPart; imaginaryPart=imaginaryPart-right.imaginaryPart; return Complex(realPart,imaginaryPart);} // end function subtractvoid Complex::printComplex(){ cout << "(" << realPart << ", " << imaginaryPart << ")";} // end function printComplexvoid Complex::setComplexNumber( double rp, double ip ){ realPart = rp; imaginaryPart = ip;} // end function setComplexNumber

相量：时域函数的复数形式。所以相量的加减就是复数加减，复数加减应该将其化为复数的代数形式。故本题就是将复数的极坐标形式化为复数的代数形式。

#include <iostream>using namespace std; class Complex{public: Complex(double r=0.0,double i=0.0)： real（r）， imag（i）{} Complex operator+(const Complex &c2) const; Complex operator-(const Complex &c2) const; Complex operator*(const Complex &c2) const; Complex operator/(const Complex &c2) const; void display() const;private: double real; double imag;};Complex Complex::operator+(const Complex &c2) const{ return Complex(real+c2.real, imag+c2.imag);} Complex Complex::operator-(const Complex &c2) const{ return Complex(real-c2.real, imag-c2.imag);}Complex Complex::operator*(const Complex &c2) const{ Complex c; c.real=real*c2.real-imag*c2.imag; c.imag=imag*c2.real+real*c2.imag; return c;}Complex Complex::operator/(const Complex &c2) const{ Complex c; double d=imag*imag+c2.imag*c2.imag; c.real=(real*c2.real+imag*c2.imag)/d; c.imag=(imag*c2.real-real*c2.imag)/d; return c;}void Complex::display() const{ cout<<"("<<real<<","<<imag<<")"<<endl;} int main(){ Complex c1(5,4),c2(2,10),c3; cout<<"c1=";c1.display(); cout<<"c2=";c2.display(); c3=c1+c2; cout<<" c3=c1+c2=";c3.display(); c3=c1-c2; cout<<" c3=c1-c2=";c3.display(); c3=c1*c2; cout<<" c3=c1*c2=";c3.display(); c3=c1/c2; cout<<" c3=c1/c2=";c3.display(); return 0;}

解析：(a+bi)+(c+di)=(a+c)+(b+d)i～～～～～～～～～(a+bi)-(c+di)=(a-c)+(b-d)i

这种格式只适合复数的乘除，乘方、开方计算不适合复数的加减计算，角度不能相加，角度相加是复数乘法的计算法则所以一般还是转化为a+bi（数学中的复数表示方法）或a+jb（电工学中的复数表示方法）后计算。

复数的加法按照以下规定的法则进行：设z1=a+bi,z2=c+di是任意两个复数，则它们的和是 (a+bi)+(c+di)=(a+c)+(b+d)i.两个复数的和依然是复数，它的实部是原来两个复数实部的和，它的虚部是原来两个虚部的和。复数的加法满足交换律和结合律，即对任意复数z1,z2,z3,有： z1+z2=z2+z1; (z1+z2)+z3=z1+(z2+z3). 复数的减法按照以下规定的法则进行：设z1=a+bi,z2=c+di是任意两个复数，则它们的差是 (a+bi)-(c+di)=(a-c)+(b-d)i.两个复数的差依然是复数，它的实部是原来两个复数实部的差，它的虚部是原来两个虚部的差。

首先1 i/1-i可以化简。同乘1 i得（i方加2i加1）/2。因为i方等于-1所以这时候这项变成i。然后原来的试子就变成了i乘i方乘i的二次方乘i的三次方乘。。。。。一直乘到i的一百次方，最后的i的五千零五十次方。化简的负一

加减法需要把极坐标形式化成代数形式计算，以后把结果再化成极坐标形式。乘除需要模模相乘除，复角相加减

图解法，直角三角形，勾股定理，计算斜边长度。

1、复数是指实数和虚数，是高等数学的基础知识，是大学一年级的第一章。我们把形如z=a+bi（a,b均为实数）的数称为复数，其中a称为实部，b称为虚部，i称为虚数单位。当z的虚部等于零时，常称z为实数；当z的虚部不等于零时，实部等于零时，常称z为纯虚数。 2、复数运算法则有：加减法、乘除法。两个复数的和依然是复数，它的实部是原来两个复数实部的和，它的虚部是原来两个虚部的和。复数的加法满足交换律和结合律。此外，复数作为幂和对数的底数、指数、真数时，其运算规则可由欧拉公式e^iθ=cos θ+i sin θ（弧度制）推导而得。

#define ARR_SIZE 20typedef struct complex{int aNum;int bNum;}Complex;void Add(Complex *A, Complex *B){ A->aNum=A->aNum+B->aNum; A->bNum=A->bNum+B->bNum;}void Minus(Complex *A, Complex *B){A->aNum=A->aNum-B->aNum;A->bNum=A->bNum-B->bNum;}char * FormatComplex(Complex *A) //格式化复数，变成a+bi{char temp[ARR_SIZE];wsprintf(temp,"%d+%d i",A->aNum,A->bNum);return temp;}

不能

string.hpp：#ifndef __STRING_HPP__#define __STRING_HPP__#include<iostream>#include<cstring>#include<cstdio>#include<cstdlib>using namespace std;class String{ private: char* data; int len; public: String();//构造函数 String(int,char);//构造函数的存在 String(const char*); ~String();//析构函数 String(const String&);//拷贝构造函数 //赋值运算符函数 String& operator=(const String&); void show(); friend ostream& operator<< (ostream&,const String&);//插入运算符的重载 //提取运算符的重载 friend istream& operator>>(istream&,String&); const String operator +(const String&)const; String& operator+=(const String&); char& operator[](int); char* getdata(); int getlength(); operator char*(); friend bool operator==(const String&,const String&); friend bool operator!=(const String&,const String&); friend bool operator<(const String&,const String&); friend bool operator>(const String&,const String&);};#endif //__STRING_HPP__string.cpp中：#include"string.hpp"String::String()//构造函数{ data=new char[1]; len=0; *data="";}String::String(int n,char ch)//构造函数的存在{ data=new char[1+n]; len=n; char* p=data;w while(n-->0) *p++=ch;}String::String(const char* str){ /*if(str!=NULL) { len=strlen(str); data=new char[1+len]; strcpy(data,str); } else { data=new char[1]; len=0; *data=""; }*/ len=strlen(str?str:""); data=new char[1+len]; strcpy(data,str?str:"");}String::~String()//析构函数{ delete[]data; data=NULL;}String::String(const String& that)//拷贝构造函数{ //cout<<"拷贝构造函数被调用"<<endl; len=that.len; data=new char[1+len]; strcpy(data,that.data);}//赋值运算符函数String& String::operator=(const String& that){ // obj3=obj4; //初级程序员的写法 /*if(this==&that) return *this;//防止自赋值 delete[]data;//释放原内存 data=new char[1+that.len];//开辟新的内存 len=that.len; strcpy(data,that.data);//拷贝新内容 return *this;//返回自引用*/ //中级程序员的写法 //a=that; if(&that==this) return *this; char* p=new char[1+that.len]; if(!p) { cout<<"内存开辟失败"<<endl; exit(-1); } //如果开辟内存不成功的话，就抛出一个异常 delete[]data; data=strcpy(p,that.data); len=that.len; return *this; //高级程序员的写法 //a=that if(&that!=this) { String other(that); len=that.len; swap(data,other.data); } return *this;}void String::show(/*int a*/){ cout<<data<<" "<<len<<endl;}ostream& operator<<(ostream& os,const String& that){ //在插入运算符中可以把流对象os当作cout来使用 //最后还要返回流对象自身,以备连用 return os<<that.data<<" "<<that.len; //return os;}istream& operator>>(istream& is,String& that){ //return is>>that.data; char buf[256]={}; is.getline(buf,100); that.len=strlen(buf); delete[]that.data; that.data=new char[1+that.len]; strcpy(that.data,buf); return is;}const String String::operator+(const String& that) const{ String other; other.len=len+that.len; delete[]other.data; other.data=new char[1+other.len]; //strcat(strcpy(other.data,data),that.data); strcpy(other.data,data); strcat(other.data,that.data); //that.len=0; return other;}//obj1 =obj2 + obj3 //int a,b,c;//a=b+c;//ok//b+c=a;//error匿名变量只能做右值/*a=1,b=2,c=3;(a=b)=c;a=3 b=2 c=3*/String& String::operator+=(const String& that){ /*String other(*this); delete[]data; len+=that.len; data=new char[1+len]; strcat(strcpy(data,other.data),that.data);*/ *this=*this+that; return *this;}char& String::operator[](int i){ if(i<0||i>len) { cout<<"数组下标越界"<<endl; exit(-1); } return data[i];}/*obj1("abcdf");cout<<obj1[0]<<endl;//aobj1[0]="A"；cout<<obj1<<endl;//Abcdf*/char* String::getdata(){ return data;}int String::getlength(){ return len;}String::operator char*(){ static char buf[256]={}; sprintf(buf,"%s%d",data,len); return buf;}//obj1("abcdef");//cout<<(char*)obj1<<endl;//abcdef6bool operator==(const String&that,const String&other){ return strcmp(that.data,other.data)==0;}bool operator!=(const String&that,const String&other){ //return strcmp(that.data,other.data)!=0; return !(that==other);}bool operator>(const String&that,const String&other){ return strcmp(that.data,other.data)>0;}bool operator<(const String&that,const String&other){ return strcmp(that.data,other.data)<0;}至于对类的使用，你可以自己写个程序测试下吧

(600，120°)+(400，-60°)=(600，120°)+(-400，120°)=(200，120°)

因为 i^2=-1 假设上式成立 . 两边平方 计算左边 即[(i+(-i)]^2=i^2+(-i)^2+2i(-i)=-1+(-1)-2i^2=-2+2=0=右边 所以i+（-i）=0正确

#include "iostream"using namespace std;class calc{public: int a1,b1,a2,b2; char temp[32]; void add(); void cut(); void multiply(); void divide();private: void init();};void calc::init(){ cout<<"请输入第一个数的实部："; cin>>a1; cout<<"请输入第一个数的虚部："; cin>>b1; cout<<"请输入第二个数的实部："; cin>>a2; cout<<"请输入第二个数的虚部："; cin>>b2;}void calc::add(){ init(); sprintf(temp,("%d,%di + %d,%di = %d,%di"),a1,b1,a2,b2,a1+a2,b1+b2); cout<<temp<<endl;}void calc::cut(){ init(); sprintf(temp,("%d,%di - %d,%di = %d,%di"),a1,b1,a2,b2,a1-a2,b1-b2); cout<<temp<<endl;}void calc::multiply(){ init(); sprintf(temp,("%d,%di × %d,%di = %d,%di"),a1,b1,a2,b2,a1*a2-b1*b2,a1*b2+a2*b1); cout<<temp<<endl;}void calc::divide(){ init(); sprintf(temp,("%d,%di ÷ %d,%di = %d,%di"), a1,b1,a2,b2,(a1*a2+b1*b2)/(a2*a2+b2*b2),(b1*a2-a1*b2)/(a2*a2+b2*b2)); cout<<temp<<endl;}void main(){ int i; calc ll; while(1) { cout<<endl<<endl; cout<<" 1.加法 2.减法 3.乘法 4.除法 5.退出"<<endl; cin>>i; switch (i) { case 1:ll.add(); break; case 2:ll.cut(); break; case 3:ll.multiply(); break; case 4:ll.divide(); break; case 5:return; break; default: cout<<"输入错误！"<<endl; } }}

题中二复数之和等于-14.05-2.34i因为实部与虚部都小于0,故该复数位于复平面第三象限,它的幅角应为arctan(-2.34/-14.05)-180°,从而等于170.54°

你仔细看看复变函数吧,我学过的.复变其实就相当于复数的基本运算加上微积分,里面从复数的极限、连续、导数、极数再到积分,都是有的.大体的思想还是差不多的,比如可导推出连续.不过在复数域里还是有很多与实数域相差别的地方.比如sin x在复数域里不再是有界函数,而是可以取尽复数域的所有数.复数域里面...

运算过程分解，配图解

复数运算Description输入两个复数a1+b1i和a2+b2i，对此进行加（+）、减（-）、乘（*）和除（/）法运算。Input输入多组测试数据，第一行为测试数据的组数T，每组测试数据由3行组成，第1行为a1和b1，第2行为一个字符，代表a1+b1i与a2+b2i所进行的运算（可能的值有+、-、*、/），第3行为a2和b2。这里的a1、b1、a2、b2均为整数。我们的测试数据保证在进行除法运算时不会发生被0除的情况。Output每组测试数据输出一行，即计算后的结果a3+b3i的最简形式，中间不包含任何空格，其中a3和b3均保留1位小数。SampleInput311+1111-1011+-1-1#include<iostream>#include<iomanip>usingnamespacestd;classComplex{private:doublereal;doubleimag;public:Complex(){real=0;imag=0;}voidInit();Complexoperator+(Complex&c2);Complexoperator-(Complex&c2);Complexoperator*(Complex&c2);Complexoperator/(Complex&c2);doubleGet_real(){returnreal;}doubleGet_imag(){returnimag;}voiddisplay();};voidComplex::Init(){cin>>real>>imag;}ComplexComplex::operator+(Complex&c2){Complexc;c.real=real+c2.real;c.imag=imag+c2.imag;returnc;}ComplexComplex::operator-(Complex&c2){Complexc;c.real=real-c2.real;c.imag=imag-c2.imag;returnc;}ComplexComplex::operator*(Complex&c2){Complexc;c.real=real*c2.real-imag*c2.imag;c.imag=real*c2.imag+imag*c2.real;returnc;}ComplexComplex::operator/(Complex&c2){Complexc;doublet=c2.real*c2.real+c2.imag*c2.imag;c.real=(real*c2.real+imag*c2.imag)/t;c.imag=(imag*c2.real-real*c2.imag)/t;returnc;}voidComplex::display(){doublere=real,im=imag;if(re==0){if(im==0)cout<<"0.0 ";else{if(im==1)cout<<"i"<<endl;elseif(im==-1)cout<<"-i"<<endl;elsecout<<setiosflags(ios::fixed)<<setprecision(1)<<im<<"i"<<endl;}}else{if(im==0)cout<<setiosflags(ios::fixed)<<setprecision(1)<<re<<endl;elseif(im>0){if(im==1){cout<<setiosflags(ios::fixed)<<setprecision(1)<<re;cout<<"+"<<setiosflags(ios::fixed)<<setprecision(1)<<"i"<<endl;}else{cout<<setiosflags(ios::fixed)<<setprecision(1)<<re;cout<<"+"<<setiosflags(ios::fixed)<<setprecision(1)<<im<<"i"<<endl;}}else{if(im==-1){cout<<setiosflags(ios::fixed)<<setprecision(1)<<re;cout<<setiosflags(ios::fixed)<<setprecision(1)<<"-i"<<endl;}else{cout<<setiosflags(ios::fixed)<<setprecision(1)<<re;cout<<setiosflags(ios::fixed)<<setprecision(1)<<im<<"i"<<endl;}}}}intmain(){Complexc1,c2,c3;intt;cin>>t;while(t--){charch;c1.Init();cin>>ch;c2.Init();if(ch=="+")c3=c1+c2;elseif(ch=="-")c3=c1-c2;elseif(ch=="*")c3=c1*c2;elsec3=c1/c2;c3.display();}return0;}

1+2i+3+4i=4+6i 只能这么加

你不嫌麻烦，用正弦定理与余弦定理算，也可以。

先把复数算出结果，再加上常数就可以得出答案。在计算复数加常数的时候，要先把复数的短式子计算出来，再用计算出来的答案和常数相加就可以得出最终的答案。复数运算法则有加减法、乘除法，两复数之和是复数，所得和的实部数值为原两复数实部之和，所得和的虚部是原两复数虚部之和，复数的加法满足交换律和结合律，两复数之差是复数，所得差的实部是原来两个复数实部的差，所得差的虚部是原两复数虚部之差。两复数之积是复数，两复数相除计算方法与乘法相同，需要分子分母相乘时乘分母的共轭，互为共轭的两复数之积是实常数。

public class ComplexNumber { /** * @param args */ int shi,xu;//复数的实部和虚部 public ComplexNumber(int n,int ni){ shi = n; xu = ni; } public void ComplexShow(){ String output = ""; output+=shi; if(xu>=0){ output+="+"; } output+=xu; output+="i"; System.out.println(output); } public void ComplexShow1(){//不要换行 String output = ""; output+=shi; if(xu>=0){ output+="+"; } output+=xu; output+="i"; System.out.print(output); } public static void ComplexAdd(ComplexNumber x1,ComplexNumber x2){//实现两个复数相加 ComplexNumber cn = new ComplexNumber(0, 0);//将两个复数相加等于cn cn.shi = x1.shi + x2.shi; cn.xu = x1.xu + x2.xu; cn.ComplexShow(); } public static void ComplexMinus(ComplexNumber x1,ComplexNumber x2){//实现两个复数相减，第一个数减第二个数 ComplexNumber cn = new ComplexNumber(0, 0);//将两个复数相加等于cn cn.shi = x1.shi - x2.shi; cn.xu = x1.xu - x2.xu; cn.ComplexShow(); } public static void ComplexMultiply(ComplexNumber x1,ComplexNumber x2){//实现两个复数相乘 ComplexNumber cn = new ComplexNumber(0, 0);//将两个复数相加等于cn cn.shi = x1.shi * x2.shi - x1.xu * x2.xu; cn.xu = x1.xu * x2.shi + x2.xu * x1.shi; cn.ComplexShow(); } public static void ComplexDivide(ComplexNumber x1,ComplexNumber x2){//实现两个复数相除，第一个数除以第二个数 ComplexNumber x2_gong = new ComplexNumber(x2.shi,0-x2.xu);//求被除数的共轭复数 ComplexNumber cn = new ComplexNumber(0, 0);//将两个复数相加等于cn cn.shi = x1.shi * x2_gong.shi - x1.xu * x2_gong.xu;//x1/x2,求分子实部 cn.xu = x1.xu * x2_gong.shi + x2_gong.xu * x1.shi;//x1/x2,求分子虚部 int fenMu = x2.shi * x2.shi + x2.xu * x2.xu; if(fenMu!=0){ System.out.print("("); cn.ComplexShow1(); System.out.print(")"); System.out.println("/"+fenMu); } else System.out.println("分母为零，无法相除"); } public static void main(String[] args) { // TODO Auto-generated method stub ComplexNumber cn = new ComplexNumber(-1, -1);//初始化复数 cn.ComplexShow();//显示复数 ComplexNumber c1 = new ComplexNumber(-1, -1); ComplexNumber c2 = new ComplexNumber(1, 1); System.out.print("加："); ComplexAdd(c1, c2); System.out.print("减："); ComplexMinus(c1, c2); System.out.print("乘："); ComplexMultiply(c1, c2); System.out.print("除："); ComplexDivide(c1, c2);//自己化简 }}

C++的问题：定义描述复数的结构体类型变量，并实现复数之间的加减法运算和输入输出我记得在书本上直接有一个案例的，直接引用模板即可解决。

complex complex::operator /(complex &p) {complex n;double s=p.real*p.real+p.imag*p.imag;n.real=(real*p.real+imag*p.imag)/s;n.imag=(imag*p.real-real*p.imag)/s;return n;}这是复数除号运算符重载的代码，验证了下应该没问题。

你的函数从头到尾都是结构体啊，你题目的要求是用类实现，补充你的函数是用结构体实现，你到底是要实现你题目的要求，还是补充你的函数呢？

因为复数虽然是表示为a+bi的形式，但它和向量确实不是一回事啊~~ 复数终归就是一个数啊~ 2维向量的两个维是等同的，而复数的1和i可以看成是不同的单位。而且i*i=-1，这一点是向量办不到的。 另外，比如说复数可以计算几次方，向量根本没这回事。

①先将极坐标形式化成直角坐标形式：20∠60°=20cos60°+j20sin60°=10+j17.320∠-45°=10cos-45°+j10sin-45°=7.07-j7.07②再将直角坐标式的实部与实部相加，虚部与虚部相加。这样就得到第二行。

easy~~#include<iostream>#include<math.h>using namespace std;class Complex{private: double real; double image;public: Complex(double real,double image) { this-> real=real; this->image=image; } float modulo () void display() { cout<<"("<<real<<","<<image<<")"<<endl; }};int main(){cout<<"enter the real and the image"<<endl;double A,B;cout<<"输入数的实部:";cin>>A;cout<<endl<<"输入数的虚部:";cin>>B;Complex C (A,B);C.display();cout<<"此复数的模为:"<<C.modulo();}

按照你要的程序 这里有个 希望对你有用 谢谢public class Complex { private double realPart; private double imaginaryPart; public Complex(double a, double b) { this.realPart = a; this.imaginaryPart = b; } public Complex add(Complex a) { Complex result = new Complex(this.realPart + a.realPart, this.imaginaryPart + a.imaginaryPart);//(why?) return result; } public Complex decrease(Complex a) { Complex result = new Complex(this.realPart - a.realPart, this.imaginaryPart - a.imaginaryPart);//(why?) return result; } public Complex multiply(Complex a) { double newReal = this.realPart*a.realPart - this.imaginaryPart * a.imaginaryPart; double newImaginary = this.realPart*a.imaginaryPart + this.imaginaryPart * a.realPart; Complex result = new Complex(newReal, newImaginary); return result; } public Complex divide(Complex a) { Complex conjugate = new Complex(this.realPart, -this.imaginaryPart); Complex multiplication = conjugate.multiply(a); multiplication.realPart /= this.realPart*this.realPart + this.imaginaryPart * this.imaginaryPart; multiplication.imaginaryPart /= this.realPart*this.realPart + this.imaginaryPart * this.imaginaryPart; return multiplication; } public String toString() { String show = this.realPart + " + " + this.imaginaryPart + "i"; return show; } public static void main(String [] args) { Complex a = new Complex (2, 3); Complex b = new Complex (1,1); System.out.println((a.add(b)).toString()); System.out.println((a.decrease(b)).toString()); System.out.println((a.multiply(b)).toString()); System.out.println((a.divide(b)).toString()); } }

相量？复数..角度幅度包裹。与正弦函数可以表示是非常相似.. 的正弦曲线的振幅的振幅值的瞬时的电压或电流，振幅的相位角的正弦.. 1的正弦函数表示...为什么更好的复数加法，减法，乘法和除法的多个.. 为什么能代表正弦函数..根据欧拉公式E ^ IX = cosx + isinx。正弦函数的虚步..复数加法是独立的每个开口的实数部分和虚数部分的加法和减法，所以更多的，而不是正弦函数相互减法.. （基尔霍夫电压和电流定律）。 3虚，乘法和除法，如U / I = JWL，U / I =-JXC这是基于正弦和排放，然后更复杂的结果添加J衍生..除了这个地方，而不是正弦相量乘法和除法..在其他地方，如计算能力，相对量不能使用。 短，减法使用相量，而不是正弦运算符计数阻抗，也可以使用在其他时间，并且不能使用！