【沈阳航空航天大学】 ＜C++ 类与对象计分作业＞

1. 设计用类完成计算两点距离

【问题描述】设计二维点类Point，包括私有成员：横坐标x，纵坐标y。能够实现以下操作：
(1)构造函数，初始化x，y；
(2) 打印函数print，打印点坐标信息x,y;
(3) 求两点直接距离，并输出结果。

【输入形式】输入两个二维点横坐标和纵坐标信息，用空格隔开
【输出形式】按输入顺序输出二点坐标信息x，y，和两点间距离，用单个空格隔开

【样例输入】
2.3 3.4 4.5 3.7
【样例输出】
2.30 3.40
4.50 3.70
2.22（保留两位小数）
【评分标准】数据类型都用double类型

#include <iostream>  // 引入输入输出流库，用于控制台的输入输出操作  
#include <iomanip>    // 引入格式控制库，用于设置输出格式  
#include <cmath>      // 引入数学库，用于使用数学函数，如sqrt()  using namespace std;  // 使用标准命名空间，避免在每次调用标准库中的函数或对象时都要加上std::前缀  // 定义一个名为Point的类，用于表示二维平面上的一个点  
class Point {  
private:  double x, y;  // 私有成员变量，分别表示点的x坐标和y坐标  public:  // 构造函数，用于初始化Point对象  Point(double x_val, double y_val) : x(x_val), y(y_val) {}  // 成员函数，用于打印点的坐标  void print() const {  cout << fixed << setprecision(2) << x << " " << y << endl;  // 使用iomanip库中的fixed和setprecision设置输出格式，保留两位小数  }  // 静态成员函数，用于计算两个点之间的距离  static double distance(const Point& p1, const Point& p2) {  double dx = p1.x - p2.x;  // 计算x坐标的差值  double dy = p1.y - p2.y;  // 计算y坐标的差值  return sqrt(dx * dx + dy * dy);  // 使用勾股定理计算两点之间的距离  }  
};  int main() {  double x1, y1, x2, y2;  // 定义四个变量，用于存储两个点的坐标  cin >> x1 >> y1 >> x2 >> y2;  // 从控制台读取两个点的坐标  Point p1(x1, y1);  // 使用读取的坐标创建第一个Point对象  Point p2(x2, y2);  // 使用读取的坐标创建第二个Point对象  p1.print();  // 调用print函数打印第一个点的坐标  p2.print();  // 调用print函数打印第二个点的坐标  double dist = Point::distance(p1, p2);  // 调用静态成员函数distance计算两点之间的距离  cout << fixed << setprecision(2) << dist << endl;  // 打印计算得到的距离，保留两位小数  return 0;  // 程序正常结束  
}

2. 设计向量类

【问题描述】设计一个向量类，成员数据包括横坐标和纵坐标，设计完成两个向量的加法和减法，输出加减后得到的向量信息。

【输入形式】输入两个向量的横坐标和纵坐标
【输出形式】输出两个向量分别做加减法的向量信息
【样例输入】3（第一个点横坐标） 5（第一个点纵坐标） 2（第二个点横坐标） 4（第二个点纵坐标）数据之间用单个空格隔开
【样例输出】5 9 1 1（先输出加法后的坐标信息，再输出减法后的坐标信息）
【样例说明】数据之间都是用单个空格隔开

#include <iostream>  // 引入输入输出流库，用于控制台输入输出  // 定义一个名为Vector的类，用于表示二维向量  
class Vector  
{  
public:  double x;  // 向量的x分量  double y;  // 向量的y分量  // 构造函数，用于初始化向量的x和y分量  Vector(double x_val, double y_val) : x(x_val), y(y_val) {}  // 静态成员函数，用于计算两个向量的和  static Vector add(const Vector &a, const Vector &b)  {  return Vector(a.x + b.x, a.y + b.y);  // 返回一个新的Vector对象，其x和y分量是a和b的对应分量之和  }  // 静态成员函数，用于计算两个向量的差  static Vector subtract(const Vector &a, const Vector &b)  {  return Vector(a.x - b.x, a.y - b.y);  // 返回一个新的Vector对象，其x和y分量是a的对应分量减去b的对应分量  }  // 成员函数，用于打印向量的x和y分量  void print() const  {  std::cout << x << " " << y;  // 在控制台输出向量的x和y分量，以空格分隔  }  
};  // 程序入口函数  
int main()  
{  double x1, y1, x2, y2;  // 定义四个double类型的变量，用于存储用户输入的两个向量的x和y分量  // 从控制台读取用户输入的两个向量的x和y分量  std::cin >> x1 >> y1 >> x2 >> y2;  // 使用用户输入的值创建两个Vector对象  Vector v1(x1, y1);  Vector v2(x2, y2);  // 调用静态成员函数计算v1和v2的和，并将结果存储在sum变量中  Vector sum = Vector::add(v1, v2);  // 调用静态成员函数计算v1和v2的差，并将结果存储在diff变量中  Vector diff = Vector::subtract(v1, v2);  // 打印向量sum的x和y分量  sum.print();  // 输出一个空格，用于分隔sum和diff的输出  std::cout << " ";  // 打印向量diff的x和y分量  diff.print();  // 输出一个换行符，以便后续的输出从新的一行开始  std::cout << std::endl;  return 0;  // 程序正常结束，返回0  
}

3. 求n!

【问题描述】输入一个整数，按要求输出该数的阶乘。
【输入形式】输入一个整数m
【输出形式】输出该数的阶乘。
【样例输入】5
【样例输出】120

#include <iostream>  // 包含输入输出流库，用于输入和输出操作  
#include <cstdlib>   // 包含C标准库，尽管在这个程序中它没有被直接使用  
using namespace std; // 使用标准命名空间，这样我们可以直接使用标准库中的类和函数，无需前缀std::  class Fac {  // 定义一个名为Fac的类  private:  int number;  // 私有成员变量，用于存储输入的整数  long long factorial;  // 私有成员变量，用于存储阶乘的结果  public:  Fac(int n) : number(n), factorial(1) {};  // 构造函数，初始化number为输入的整数n，factorial初始化为1  void compute() {  // 成员函数，用于计算阶乘  for (int i = 1; i <= number; i++) {  // 从1循环到number  factorial *= i;  // factorial乘以当前的i，计算阶乘  }  }  void print() {  // 成员函数，用于打印阶乘的结果  cout << factorial << endl;  // 输出factorial的值  }  
};  int main() {  // 主函数  int i;  // 定义一个整数变量i，用于存储用户输入的整数  cin >> i;  // 从标准输入读取一个整数，并存储到变量i中  Fac a(i);  // 创建Fac类的对象a，使用i作为构造函数的参数  a.compute();  // 调用对象a的compute函数，计算阶乘  a.print();  // 调用对象a的print函数，打印阶乘的结果  return 0;  // 主函数返回0，表示程序正常结束  
}

4. 出租车收费类的设计与实现

【问题描述】
编程定义计算出租车收费类，完成如下功能：

（1）包含四个私有成员数据，起步价（start），公里数（miles），每公里收费（money），收费总金额（allmoney）都是整数类型；
（2）通过构造函数设置起步价，公里数和每公里收费；
（3）编写函数计算收费金额，计算方法：3公里以内（包括3公里），收费为起步价；超过3公里，3公里以内的是起步价，超出部分按照公里数*每公里收费进行计算，例如：起步价是8元，公里数是5公里，每公里收费1元，则这次出租车收取的费用为：8+（5-3）*1=10元；
（4）编写输出函数，输出收费金额。

【输入形式】输入起步价，公里数，每公里收费
【输出形式】输出收费金额
【样例输入】8 5 1
【样例输出】10

#include <iostream> // 引入输入输出流库，用于输入输出操作  
using namespace std; // 使用标准命名空间，以便直接使用标准库中的类和函数  class Taxi { // 定义一个名为Taxi的类  private:  int start; // 起步价  int miles; // 行驶的公里数  int money; // 每公里收费  int allmoney; // 总费用  public:  Taxi(int s, int m, int mon) : start(s), miles(m), money(mon), allmoney(0) {  // 构造函数，初始化起步价、公里数、每公里收费和总费用（总费用初始化为0）  // 并在构造时调用count()函数计算总费用  count();  };  void count() {  // 计算总费用的成员函数  if (miles <= 3) {  // 如果行驶公里数小于等于3公里，则总费用等于起步价  allmoney = start;  } else {  // 如果行驶公里数大于3公里，则总费用等于起步价加上超出3公里部分的费用  allmoney = start + (miles - 3) * money;  }  }  void print() {  // 打印总费用的成员函数  cout << allmoney << endl; // 输出总费用  }  
};  int main() { // 主函数  int s, m, mon; // 定义变量s（起步价）、m（公里数）、mon（每公里收费）  cin >> s >> m >> mon; // 从标准输入读取起步价、公里数和每公里收费  Taxi t(s, m, mon); // 创建Taxi类的对象t，使用读取的起步价、公里数和每公里收费作为构造函数的参数  // 这里实际上是不需要的，因为在Taxi的构造函数中已经调用了count()函数  // 如果构造函数中已经调用了count()，则这里不需要再次调用  t.count(); // 计算收费金额（这行代码是多余的，因为已经在构造函数中计算过了）  t.print(); // 打印收费金额  return 1; // 主函数返回1，通常主函数成功执行完毕后应返回0，返回1可能表示某种错误状态  
}

5. 定义并实现一个复数类

【问题描述】

定义并实现一个复数类，利用构造函数（复数实部和虚部的数值作为参数）初始化类对象，完成功能：
c1.add(c2); //c1= c1 + c2（c1和c2为复数类类对象，功能为两个复数相加）
c1.sub(c2); //c1 = c1 - c2（c1和c2为复数类类对象，功能为两个复数相减）
类中提供两个外部接口函数 getReal 和 getImag，功能分别为获得复数实部和虚部的数值。
【输入形式】首先从键盘输入 4 个实数用来初始化两个复数。然后再输入一个字母，a 或者非 a，a 代表两个复数做加法，非 a 字母代表两个复数做减法（第一个复数是被减数）。
【输出形式】输出计算后的复数。
【样例输入】3 5 4.5 0 a
【样例输出】7.5+5.0i
【样例输入】3.2 1.5 6.7 15.8 s
【样例输出】-3.5-14.3i
【样例说明】实数输出时保留一位小数点。

#include <iostream>  
#include <stdio.h>  using namespace std;  // 定义复数类  
class Complex {  
private:  float real;  // 实部  float imag;  // 虚部  public:  Complex(float r = 0.0f, float i = 0.0f) : real(r), imag(i) {}  // 构造函数，用于初始化复数  // 复数加法  void add(const Complex& other) {  real += other.real;  imag += other.imag;  }  // 复数减法  void sub(const Complex& other) {  real -= other.real;  imag -= other.imag;  }  // 获取实部  float getReal() const {  return real;  }  // 获取虚部  float getImag() const {  return imag;  }  
};  int main() {  float rx1, ix1, rx2, ix2;  // 用于存储输入的两个复数的实部和虚部  char ch;                   // 用于存储操作类型的字符（'a'代表加法，其他代表减法）  // 从标准输入读取两个复数的实部和虚部以及操作类型  scanf("%f%f%f%f %c", &rx1, &ix1, &rx2, &ix2, &ch);  // 创建两个复数对象，并用输入的值初始化它们（程序部分2-2）  Complex c1(rx1, ix1);  Complex c2(rx2, ix2);  // 根据操作类型执行相应的复数运算  if (ch == 'a') {  // 如果是复数加法  c1.add(c2);  // 将c2加到c1上  printf("%.1f%+.1fi", c1.getReal(), c1.getImag());  // 输出结果  } else {  // 如果是复数减法  c1.sub(c2);  // 从c1中减去c2  printf("%.1f%+.1fi", c1.getReal(), c1.getImag());  // 输出结果  }  return 0;  
}

6. 线性表类的设计与实现

【问题描述】定义并实现保存正整数的线性表类 Link，私有属性包含线性表数据（数据长度小于 200，用数组保存即可），实际有效数据数量。要求编写对外接口函数如下：

1、insert_link(int n, int index)：将正整数 n 插入到数组下标为 index 的位置；

2、delete_link(int index)：删除下标为 index 的数据，不考虑空表；

3、show_link()：输出线性表所有数据；

4、编写两个类构造函数来初始化类对象，一个构造函数无输入参数，初始化整个线性表数据为 0；另外一个构造函数根据实际输入数据进行初始化。

说明：若 index 小于 0，则将其设置为 0，若 index 大于 有效数据长度减1，则将其设置为 有效数据长度减1。
【输入形式】输入一组正整数，小于等于0代表输入结束；再输入正整数 n 和整数 index，用于在 index 处插入数据 n；最后输入一个整数 index，用于在 index 处删除一个数据。
【输出形式】输出原始表以及插入，删除后的表。
【样例输入】
2 56 85 25 65 21 78 52 0
80 2 250
注：此处的80是要插入的数据n，2是插入的位置index，250是删除数据的位置index。
【样例输出】
2 56 85 25 65 21 78 52
2 56 80 85 25 65 21 78 52
2 56 80 85 25 65 21 78
【样例输入】
1 2 3 4 5 -6
7 -8 3
注：此处的7是要插入的数据n，-8是插入的位置index，3是删除数据的位置index。
【样例输出】
1 2 3 4 5
7 1 2 3 4 5
7 1 2 4 5

#include <iostream>  
#include <stdio.h>  using namespace std;  // 定义线性表类 Link  
class Link {  
private:  int data[200];     // 线性表存储数组，最大长度为200  int length;        // 线性表当前长度  // 调整索引，确保索引在合法范围内  int adjustIndex(int index) {  if (index <= 0) {  return 0;  }  if (index > length - 1) {  return length - 1;  }  return index;  }  public:  // 默认构造函数，初始化线性表为空  Link() : length(0) {  for (int i = 0; i < 200; i++) {  data[i] = 0;  }  }  // 带参数的构造函数，根据传入的数组和长度初始化线性表  Link(int* arr, int len) : length(len) {  for (int i = 0; i < len; i++) {  data[i] = arr[i];  }  }  // 在指定位置插入元素  void insert_link(int n, int index) {  index = adjustIndex(index);  // 调整索引  for (int i = length; i > index; i--) {  data[i] = data[i - 1];  // 后移元素  }  data[index] = n;  // 插入新元素  length++;  // 更新线性表长度  }  // 删除指定位置的元素  void delete_link(int index) {  index = adjustIndex(index);  // 调整索引  for (int i = index; i < length - 1; i++) {  data[i] = data[i + 1];  // 前移元素  }  length--;  // 更新线性表长度  }  // 显示线性表的内容  void show_link() {  for (int i = 0; i < length; i++) {  cout << data[i] << (i < length - 1 ? " " : "\n");  // 输出元素，最后一个元素后换行  }  }  
};  int main() {  int ar[200], len = 0;  // 定义数组和长度变量，并初始化长度为0  int ins_index, n, del_index;  // 读入数据，小于等于0结束，数据保存到数组ar，len为实际有效数据长度  // 可自定义变量  while (cin >> n && n > 0) {  ar[len++] = n;  // 将读入的元素存入数组，并更新长度  }  cin >> n >> ins_index >> del_index;  // 读入要插入的元素、插入位置和删除位置  Link lk(ar, len);  // 构造线性表对象，根据数组和长度初始化  lk.show_link();  // 显示初始线性表内容  lk.insert_link(n, ins_index);  // 在指定位置插入元素  lk.show_link();  // 显示插入元素后的线性表内容  lk.delete_link(del_index);  // 删除指定位置的元素  lk.show_link();  // 显示删除元素后的线性表内容  return 0;  
}

7. 数组求和

【问题描述】输入一串整数，求整数和。
【输入形式】首先输入一个正整数n(n>0)，表示元素个数，然后输入n个整数。
【输出形式】输出n个整数之和。
【样例输入】5
1 2 3 4 5
【样例输出】15

#include <iostream>  
#include <stdlib.h>  
using namespace std;  // 声明一个数组类Array  
class Array  
{  
private:  int n, s;  // n存储数组中元素的个数，s存储数组元素之和的初始值  int *a;   // 指向动态分配数组空间的指针  public:  // 构造函数，初始化数组的大小，并动态分配内存空间  Array(int size)  {  n = size;  // 设置数组的大小  a = new int[n];  // 动态分配数组空间  input();  // 调用input函数输入数组元素  s = 0;  // 初始化数组元素之和为0  }  // 析构函数，释放动态分配的内存空间  ~Array()  {  delete[] a;  // 释放数组空间  }  // 输入数组元素  void input()  {  for (int i = 0; i < n; i++)  {  cin >> a[i];  // 从标准输入读取数组元素  }  }  // 计算数组元素之和  void sum()  {  for (int i = 0; i < n; i++)  {  s += a[i];  // 累加数组元素的值到s  }  }  // 打印数组元素之和  void print()  {  cout << s << endl;  // 输出数组元素之和  }  
};  int main()  
{  int i;  cin >> i;  // 从标准输入读取数组的大小  Array a(i);  // 创建Array对象a，数组元素值在构造函数中通过input函数输入  a.sum();   // 调用sum函数计算数组a的元素之和  a.print();   // 调用print函数打印数组a的元素之和  return 0;  // 程序正常退出  
}

8. 数组求最大值

【问题描述】输入一串整数，求整数中的最大值。
【输入形式】首先输入一个正整数n(n>0)，表示元素个数，然后输入n个整数。
【输出形式】输出n个整数的最大值。
【样例输入】5
1 2 3 4 5
【样例输出】5

#include <iostream>
#include <cstdlib>
using namespace std;// 数组类声明
class Array
{
private:int n;		// 存储数组中元素的个数int maxnum; // 存储数组中的最大值int *a;		// 动态分配的数组空间public:// 构造函数，初始化数组的大小，并动态分配内存空间Array(int size) : n(size), maxnum(-1), a(new int[n]){input(); // 调用input函数输入数组元素}// 析构函数，释放动态分配的内存空间~Array(){delete[] a;}// 拷贝构造函数，用于创建数组对象的副本Array(const Array &other) : n(other.n), maxnum(other.maxnum), a(new int[n]){for (int i = 0; i < n; i++){a[i] = other.a[i]; // 复制元素到新的数组空间}}// 查找并设置数组中的最大值void max(){maxnum = a[0];				// 假设第一个元素是最大值for (int i = 1; i < n; i++) // 从第二个元素开始遍历{if (a[i] > maxnum){maxnum = a[i]; // 更新最大值}}}// 输入数组元素void input(){for (int i = 0; i < n; i++){cin >> a[i]; // 从标准输入读取数组元素}}// 打印数组中的最大值void print(){cout << maxnum << endl; // 输出最大值}
};int main()
{int i;cin >> i;	 // 从标准输入读取数组的大小Array a(i);	 // 创建Array对象a，数组元素值在构造函数中通过input函数输入Array b = a; // 利用拷贝构造函数创建Array对象b，并复制a的内容b.max();	 // 调用max函数查找数组b（即数组a的副本）中的最大值b.print();	 // 调用print函数打印数组中的最大值return 0;	 // 程序正常退出
}

今天的内容就分享这么多
求三连！！！
求关注！！！