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; // 程序正常退出
}
今天的内容就分享这么多
求三连！！！
求关注！！！