本文主要是介绍【沈阳航空航天大学】 ＜C++ 类与对象计分作业＞，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
C++类与对象
- 1. 设计用类完成计算两点距离
- 2. 设计向量类
- 3. 求n!
- 4. 出租车收费类的设计与实现
- 5. 定义并实现一个复数类
- 6. 线性表类的设计与实现
- 7. 数组求和
- 8. 数组求最大值
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; // 程序正常退出
}
今天的内容就分享这么多
求三连！！！
求关注！！！
这篇关于【沈阳航空航天大学】 ＜C++ 类与对象计分作业＞的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
