1、声明一个复数类Complex（类私有数据成员为double型的real和image） 2、定义构造函数，用于指定复数的实部与虚部。 3、定义取反成员函数，调用时能返回该复数的相反数（实部、虚部分别是原数的相反数）。 4、定义成员函数Print()，调用该函数时，以格式(real, image)输出当前对象。 5、编写加法友元函数，以复数对象c1，c2为参数，求两个复数对象相加之和。 6、主程序实现： （1）读入两个实数，用于初始化对象c1。 （2）读入两个实数，用于初始化对象c2。 （3）计算c1与c2相加结果，并输出。 （4）计算c2的相反数与c1相加结果，并输出。 输入格式: 输入有两行： 第一行是复数c1的实部与虚部，以空格分隔； 第二行是复数c2的实部与虚部，以空格分隔。 输出格式: 输出共三行: 第一行是c1与c2之和； 第二行是c2的相反数与c1之和； 第三行是c2 。

#include<iostream>
using namespace std;
class Complex{
private:
double real,image;
public:
Complex(double a=0,double b=0):real(a),image(b){}
Complex operator-(){
return Complex(-real,-image);
}
void Print(){
cout<<"("<<real<<", "<<image<<")"<<endl;
}
friend Complex operator+(Complex a,Complex b){
return Complex(a.real+b.real,a.image+b.image);
}
};
int main(){
double a,b,c,d;
cin>>a>>b>>c>>d;
Complex c1(a,b),c2(c,d),sum,ans;
sum=c1+c2;
ans=-c2+c1;
sum.Print();
ans.Print();
c2.Print();
return 0;
}

相关问题

c++编写一个程序，要求： （1）声明一个类complex，定义类complex的两个对象c1和c2，对象c1通过构造函数直接指定复数的实部和虚部（类的私有数据成员为double类型：real和imag）为2.5及3.7，对象c2通过构造函数直接指定复数的实部和虚部为4.2和6.5； （2）定义友元运算符重载函数，它以c1、c2对象为参数，调用该函数时能返回两个复数对象相加操作； （3）定义成员函数print，调用该函数时，它以格式（real,image）输出当前对象的实部和虚部； （4）编写主程序，计算出复数对象c1和c2相加结果，并将其结果输出

以下是实现该程序的代码：

#include<iostream>
using namespace std;

class complex {
private:
    double real, imag;
public:
    complex(double r, double i) {
        real = r;
        imag = i;
    }
    friend complex operator+(complex c1, complex c2) {
        complex result(0, 0);
        result.real = c1.real + c2.real;
        result.imag = c1.imag + c2.imag;
        return result;
    }
    void print() {
        cout << "(" << real << ", " << imag << ")" << endl;
    }
};

int main() {
    complex c1(2.5, 3.7);
    complex c2(4.2, 6.5);
    complex result = c1 + c2;
    result.print();
    return 0;
}

输出结果为：(6.7, 10.2)

1、复数类使用complex（类私有数据成员为double类型的real和image）代替double类型的real和imag。 2、定义构造函数，用于指定复数的实部和虚部。可用于实例化该复数的实部和虚部的实例和虚部。 3、定义成员函数，调用该函数时，可以返回该复数的相反数（实部和虚部分别是原始实部和虚部的相反数）。区别在于，实部和虚部分别是原始实部和虚部的相反数在实现中是作为原始实部和虚部的相反数的相反数来实现的。 4、定义成员函数print()，调用该函数时，按照格式(real, image)输出当前对象。 5、编写加法友元函数，以复数对象c1，c2作为参数，计算两个复数对象的和。 6、主程序实现：（1）输入两个实数，用于初始化对象c1。（2）输入两个实数，用于初始化对象c2。（3）计算c1和c2的相加结果，并输出。（4）计算c2的相反数，并输出。

以下是题目所要求的复数类的实现以及主程序：

#include <iostream>
#include <cmath>

class Complex {
private:
    double real;
    double imag;

public:
    Complex(double r, double i) : real(r), imag(i) {}

    Complex operator-() const {
        return Complex(-real, -imag);
    }

    void print() const {
        std::cout << "(" << real << ", " << imag << ")" << std::endl;
    }

    friend Complex operator+(const Complex& c1, const Complex& c2);
};

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

int main() {
    double r1, i1, r2, i2;
    std::cout << "Enter the real and imaginary parts of the first complex number: ";
    std::cin >> r1 >> i1;
    std::cout << "Enter the real and imaginary parts of the second complex number: ";
    std::cin >> r2 >> i2;

    Complex c1(r1, i1);
    Complex c2(r2, i2);

    std::cout << "The sum of the two complex numbers is: ";
    (c1 + c2).print();

    std::cout << "The negation of the second complex number is: ";
    (-c2).print();

    return 0;
}

在上述代码中，我们使用了类的私有数据成员来保存复数的实部和虚部。我们定义了一个构造函数，用于初始化复数对象的实部和虚部。我们还定义了一个成员函数`print()`，用于按照格式输出复数对象。我们还定义了一个成员函数`operator-()`，用于返回该复数的相反数。

我们还定义了一个加法友元函数`operator+()`，用于计算两个复数对象的和。在主程序中，我们首先输入两个实数，用于初始化对象`c1`和`c2`。然后我们计算`c1`和`c2`的和，并输出结果。接着我们计算`c2`的相反数，并输出结果。

运行程序，输出如下：

Enter the real and imaginary parts of the first complex number: 2 3
Enter the real and imaginary parts of the second complex number: 4 5
The sum of the two complex numbers is: (6, 8)
The negation of the second complex number is: (-4, -5)