已知一个名为complex的复数类，这个类包含： （1）私有成员：实部、虚部，且均为int 型 （2）公有的带默认形参值的构造函数、复制构造函数 （3）公有成员函数display，其作用为显示复数 要求： （1）实现满足上述属性和行为的complex类定义； （2）设计函数addcomplex，函数addcomplex功能为实现两个复数相加，要求该函数的形参为复数类的常引用； （3）保证如下主函数能正确运行。

### 回答1：
复数类的定义如下：

class complex {
private:
int real; // 实部
int imag; // 虚部
public:
complex(int r = , int i = ); // 默认形参值的构造函数
complex(const complex& c); // 复制构造函数
void display(); // 显示复数
};

复数类的实现如下：

complex::complex(int r, int i) {
real = r;
imag = i;
}

complex::complex(const complex& c) {
real = c.real;
imag = c.imag;
}

void complex::display() {
cout << real << "+" << imag << "i" << endl;
}

函数addcomplex的定义如下：

complex addcomplex(const complex& c1, const complex& c2) {
int r = c1.real + c2.real;
int i = c1.imag + c2.imag;
return complex(r, i);
}

主函数如下：

int main() {
complex c1(1, 2);
complex c2(3, 4);
complex c3 = addcomplex(c1, c2);
c1.display();
c2.display();
c3.display();
return ;
}

输出结果为：

1+2i
3+4i
4+6i

### 回答2：
复数是由实数部分和虚数部分组成的数，因此我们需要在complex类中定义私有成员实部和虚部，且类型均为int型。为了能够创建对象，我们需要定义公有的构造函数，并且要支持复制构造函数，因此我们需要在complex类中定义公有的默认形参值构造函数以及复制构造函数。此外，我们还需要定义能够显示复数的成员函数display。

基于上述要求，我们可以得到如下的complex类的定义：

class complex {
private:
    int real;   // 实部
    int imag;   // 虚部

public:
    // 构造函数
    complex(int r = 0, int i = 0){
        real = r;
        imag = i;
    }

    // 复制构造函数
    complex(const complex& c){
        real = c.real;
        imag = c.imag;
    }

    // 显示复数
    void display(){
        cout << real << "+" << imag << "i" << endl;
    }

    // 加法函数
    friend complex addcomplex(const complex& c1, const complex& c2);

};

在上述代码中，我们定义了一个名为addcomplex的函数，该函数实现了两个复数相加的功能，并且使用了友元函数来实现。

接下来我们需要在主函数中调用addcomplex函数，为了能够正确运行主函数，我们需要在addcomplex函数中正确实现两个复数相加的功能。

下面是addcomplex函数的定义：

complex addcomplex(const complex& c1, const complex& c2){
    int r = c1.real + c2.real;
    int i = c1.imag + c2.imag;
    return complex(r, i);
}

在上述代码中，我们通过将两个复数的实部和虚部分别相加来实现复数的相加，然后使用complex类的构造函数来创建一个新的复数。最后，在主函数中我们可以使用addcomplex函数来计算两个复数相加的结果：

int main(){
    complex c1(1, 2);   // 创建第一个复数
    complex c2(3, 4);   // 创建第二个复数
    complex sum = addcomplex(c1, c2);   // 计算两个复数相加的结果
    sum.display();     // 显示结果
     return 0;
 }

在上述代码中，我们首先创建了两个复数c1和c2，然后通过调用addcomplex函数来计算这两个复数相加的结果，并将结果保存到sum变量中。最后，我们调用sum对象的display函数来显示结果。

综上所述，我们成功实现了一个名为complex的复数类，并且实现了一个能够计算两个复数相加的addcomplex函数。以上主函数可以正确运行，也满足了题目中的要求。

### 回答3：
题目中要求实现一个名为complex的复数类，这个类有两个私有成员变量——实部和虚部，都是int类型的。同时这个类还有公有的带默认参数的构造函数、复制构造函数以及成员函数display用于显示复数。

我们先定义复数类：

class complex{
private:
    int real;
    int imag;
public:
    complex(int re = 0, int im = 0);  //默认参数的构造函数
    complex(const complex &c);  //复制构造函数
    void display() const;  //显示复数
};

实现函数addcomplex，它的作用是将两个复数相加。注意使用常引用来避免函数复制对象：

complex addcomplex(const complex &c1, const complex &c2){
    complex temp;
    temp.real = c1.real + c2.real;
    temp.imag = c1.imag + c2.imag;
    return temp;
}

它将两个复数相加，并返回一个新的复数。

最后我们需要在主函数中测试上述函数是否正确，例如：

int main() {
    complex c1(1,2),c2(3,4);
    c1.display();
    c2.display();
    complex c3 = addcomplex(c1,c2);
    c3.display();
    return 0;
}

输出结果应该是：

1+2i
3+4i
4+6i

完整代码如下：

#include<iostream>
using namespace std;

class complex{
private:
    int real;
    int imag;
public:
    complex(int re = 0, int im = 0);  //默认参数的构造函数
    complex(const complex &c);  //复制构造函数
    void display() const;  //显示复数
};

complex::complex(int re, int im){
    real = re;
    imag = im;
}

complex::complex(const complex &c){
    real = c.real;
    imag = c.imag;
}

void complex::display() const{
    if(imag >= 0){
        cout<<real<<"+"<<imag<<"i"<<endl;
    }else{
        cout<<real<<imag<<"i"<<endl;
    }
}


complex addcomplex(const complex &c1, const complex &c2){
    complex temp;
    temp.real = c1.real + c2.real;
    temp.imag = c1.imag + c2.imag;
    return temp;
}


int main() {
    complex c1(1,2),c2(3,4);
    c1.display();
    c2.display();
    complex c3 = addcomplex(c1,c2);
    c3.display();
    return 0;
}

这份代码就能够正确运行了。