C++面向对象程序设计上机测验一

1.关于对象指针与对象引用做参数，描述正确的是

• 对象指针做参数效率更高
• 对象引用做参数效率更高
• 对象指针做参数代码更加直观
• 对象引用和对象指针都能够实现传址

解析：

对象引用和对象指针都能够实现传址，两者本质一样，故效率相同。但对象引用做参数代码更加直观

2.构造函数之矩形类

试题描述

创建矩形Rectangle类，有保护的int类型的成员变量r_long长和r_width宽；无参数的构造函数和有参数（参数没有默认值）的构造函数；其他成员函数comp_area()计算并返回矩形的面积，成员函数comp_perimeter()计算并返回矩形的周长，成员函数get_long()返回矩形的长；成员函数get_width()返回矩形的宽。

int main()
{
   int a, b;
   cin >> a >> b;
   Rectangle rect1, rect2(a, b); //分别调用不同的构造函数，创建两个对象
   cout << "(" << rect1.get_long() << "," << rect1.get_width() << ")" << endl;
   cout << "(" << rect2.get_long() << "," << rect2.get_width() << ")" << endl;
   cout << rect2.comp_area() << endl;
   cout << rect2.comp_perimeter() << endl;
   return 0;
} 

注意：1.请务必提交完整的程序代码，不要修改代码框架。2.请不要修改试题描述中的所有标识符，注意大小写敏感。

输入

输入两个非负整数，两数之间用一个空格隔开。

输出

依据题意输出四行。

输入示例

100 1

输出示例

(10,10)
(100,1)
100
202

数据范围

输入为int范围的非负整数

代码实现

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;
class Rectangle
{
protected:
    int r_long,r_width;
public:
    Rectangle()
    {
        r_long=r_width=10;
    }
    Rectangle(int l,int w)
    {
        r_long=l;
        r_width=w;
    }
    int comp_area()
    {
        return r_long*r_width;
    }
    int comp_perimeter()
    {
        return 2*(r_long+r_width);
    }
    int get_long()
    {
        return r_long;
    }
    int get_width()
    {
        return r_width;
    }
};
int main()
{
   int a, b;
   cin >> a >> b;
   Rectangle rect1, rect2(a, b); //分别调用不同的构造函数，创建两个对象
   cout << "(" << rect1.get_long() << "," << rect1.get_width() << ")" << endl;
   cout << "(" << rect2.get_long() << "," << rect2.get_width() << ")" << endl;
   cout << rect2.comp_area() << endl;
   cout << rect2.comp_perimeter() << endl;
   return 0;
}

3.析构函数填空

试题描述

请仔细阅读代码，并填写下面空白。

   ①    //必要的头文件等，可能为多条语句
   ②    //Test类
{
      ③    //定义保护的int类型的数据成员x和y

      ④    //带有两个int类型参数a和b，且参数默认值均为0的构造函数，在初始化列表中，将形参a赋给数据成员x，b赋给y

      ⑤    //析构函数，在函数体中输出x、y的值到屏幕，共占一行，两个值之间用一个空格隔开
};
int main()
{
      ⑥    //创建Test对象t1
      ⑦    //定义Test指针t2
   int a, b;

   for(int i = 0; i < 2; i++)
   {
      cin >> a >> b;
         ⑧    = new    ⑨   (a, b); //创建Test堆对象，并将地址赋给指针t2
         ⑩    t2; //释放堆对象
   }
   return 0;
} 

注意：1.请务必提交完整的程序代码，不要修改代码框架。2.请不要修改试题描述中的所有标识符，注意大小写敏感。

输入

输入四个整数，以空格隔开。

输出

依据题意输出若干行。

输入示例

10 20 30 40

输出示例

10 20
30 40
0 0

数据范围

输入int范围的整数

代码实现

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;
class Test//Test类
{
protected://定义保护的int类型的数据成员x和y
    int x,y;
public:
    Test(int a=0,int b=0)//带有两个int类型参数a和b，且参数默认值均为0的构造函数，在初始化列表中，将形参a赋给数据成员x，b赋给y
    {
        x=a;
        y=b;
    }
    ~Test()//析构函数，在函数体中输出x、y的值到屏幕，共占一行，两个值之间用一个空格隔开
    {
        cout<<x<<" "<<y<<endl;
    }
};
int main()
{
   Test t1;//创建Test对象t1
   Test *t2;//定义Test指针t2
   int a, b;
   for(int i = 0; i < 2; i++)
   {
      cin >> a >> b;
      t2 = new Test(a, b); //创建Test堆对象，并将地址赋给指针t2
      delete t2; //释放堆对象
   }
   return 0;
}

3.运算符重载之复数类填空

试题描述

定义复数Complex类，并重载单目减号运算符、双目+、-、*运算符函数为Complex类的成员函数。请仔细阅读代码，填写下面空白。

   ①    //必要的头文件等，可能为多条语句
   ②    //复数Complex类
{
      ③    //保护数据成员：int类型的real、image，分别代表实部、虚部

      ④    //带有两个参数的构造函数，参数默认值均为0；在初始化列表中将形参赋给对应的数据成员

      ⑤    //输出Show()常成员函数，注意保持合理的复数输出格式

      ⑥    //双目+运算符重载常成员函数，有一个参数（Complex类型对象z2的常引用）

      ⑦    //双目-运算符重载常成员函数，有一个参数（Complex类型对象z2的常引用）

      ⑧    //双目*运算符重载常成员函数，有一个参数（Complex类型对象z2的常引用）

      ⑨    //单目-运算符重载常成员函数，无参数
};
int main()
{
   int a, b, c, d;
   cin >> a >> b >> c >> d;
   Complex z1(a, b), z2(c, d), z3; //定义复数对象
   z1.Show(); //输出z1
   z2.Show(); //输出z2

   z3 = z1 + z2 - (-z1); //进行复数运算
   z3.Show(); //输出z3

   z3 = z3 * z1; //进行复数运算
   z3.Show(); //输出z3
   return 0;
} 

注意：1.请务必提交完整的程序代码，不要修改代码框架。2.请不要修改试题描述中的所有标识符，注意大小写敏感。

输入

输入四个整数，用一个空格隔开。

输出

依据题意输出四行。

输入示例1

2 5 6 -5

输出示例1

2+5i
6-5i
10+5i
-5+60i

输入示例2

2 0 -7 5

输出示例2

2
-7+5i
-3+5i
-6+10i

数据范围

输入为int范围的整数

代码实现

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;
class Complex//复数Complex类
{
protected://保护数据成员：int类型的real、image，分别代表实部、虚部
    int real,image;
public://带有两个参数的构造函数，参数默认值均为0；在初始化列表中将形参赋给对应的数据成员
    Complex(int r=0,int i=0)
    {
        real=r;
        image=i;
    }
    void Show() const//输出Show()常成员函数，注意保持合理的复数输出格式
    {
        if(real==0&&image==0) cout<<"0"<<endl;
        else if(real==0) cout<<image<<"i"<<endl;
        else if(image==0) cout<<real<<endl;
        else if(image>0) cout<<real<<"+"<<image<<"i"<<endl;
        else if(image<0) cout<<real<<image<<"i"<<endl;
    }
    Complex operator+(const Complex& z2) const //双目+运算符重载常成员函数，有一个参数（Complex类型对象z2的常引用）
    {
        return Complex(real+z2.real,image+z2.image);
    }
    Complex operator-(const Complex& z2) const //双目-运算符重载常成员函数，有一个参数（Complex类型对象z2的常引用）
    {
        return Complex(real-z2.real,image-z2.image);
    }
    Complex operator*(const Complex& z2) const //双目*运算符重载常成员函数，有一个参数（Complex类型对象z2的常引用）
    {
        return Complex(real*z2.real-image*z2.image,image*z2.real+real*z2.image);
    }
    Complex operator-() const //单目-运算符重载常成员函数，无参数
    {
        return Complex(-real,-image);
    }
};
int main()
{
   int a, b, c, d;
   cin >> a >> b >> c >> d;
   Complex z1(a, b), z2(c, d), z3; //定义复数对象
   z1.Show(); //输出z1
   z2.Show(); //输出z2
   z3 = z1 + z2 - (-z1); //进行复数运算
   z3.Show(); //输出z3

   z3 = z3 * z1; //进行复数运算
   z3.Show(); //输出z3
   return 0;
}