介绍：
本篇博客是为学习完C/C++后的一些练习题，小编对每个题给出了个人题解（编译环境VS2022）无报错，由于小编没有写注释的习惯如有不解请评论提出，如果读者根据我的代码学到了东西或者有其他解法可以留言讨论~~~
1.定义复数类加减法
【问题描述】定义复数类的加法与减法，使之能够执行下列运算：
Complex a(2,5), b(7, 8), c(0, 0);
c=a+b;
c=4.1+a;
c=b-5.6;
【输入形式】无
【输出形式】各复数运算结果
【样例输入】无
【样例输出】
9+i13
6.1+i5
1.4+i8
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
class Complex {
double real;
double image;
public:
Complex(double x = 0, double y = 0) {
real = x;
image = y;
}
Complex operator+(Complex& c) {
Complex sum;
sum.real = real + c.real;
sum.image = image + c.image;
return sum;
}
void print() {
cout << real << '+' << 'i' << image << endl;
}
};
int main()
{
Complex a(2, 5), b(7, 8), c(0, 0), d(4.1, 0), e(-5.6, 0), x;
x= a + b;
x.print();
x = a + d;
x.print();
x = b + e;
x.print();
return 0;
}2.数组逆序存放
【问题描述】依次输入一个整型数组的元素值，然后将该数组前n个元素中的值按逆序重新存放。例如，输入值的顺序为8,6,5,4,1,2,逆序存放后的顺序为2,1,4,5,6,8的顺序存放（注意是逆序存放而不是逆序输出）。
提示：
（1）定义一个数组，数组大小不超过999，为该数组前n个元素赋值。
（2）在循环中，使第0个元素与第n-1个元素交换，第1个元素与第n-2个元素交换，第2个元素与第个n-3元素交换（注意循环次数按n/2确定，n为数据个数）。
（3）输出逆序存放后的各数组元素（使用循环语句）。
【输入形式】第一行输入数组的元素个数，第二行输入依次输入元素值，用空格分开
【输出形式】逆序存放后的输入元素，用空格分开
【样例输入】
5
12#23#8#76#10
（#表示空格）
【样例输出】10#76#8#23#12
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
void sort(int num[],int n) {
int* p = num, * q = p + n - 1;
while (p < q) {
int t = *p;
*p = *q;
*q = t;
p++;
q--;
}
}
int main()
{
int i, n, arr[100];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
sort(arr, n);
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}3.二维数组最小点
【问题描述】
求二维整型数组的"最小点"。二维数组的"最小点"定义为：某个数是所在行的最小值，并且是所在列的最小值。注意：某行或某列上可能有多个"最小点"。
【输入形式】
从控制台读入二维数组。
第一行只有以空格分隔的两个正整数n和m（n,m<=10），n代表二维数组的行数，m代表二维数组的列数。
然后在后续n行上输入二维数组的元素，每行有m个以若干空格分隔的整数，代表二维数组在该行上的所有元素。
【输出形式】
向控制台输出二维数组的"最小点"，按行下标、列下标从小到大的顺序输出，每行一个，先输出"最小点"数值，再输出对应的行数、列数（行列都从1开始计数），以一个空格分隔。
【样例输入】
3 4 8 60 1 100 10 498 12 49 -71 132 4 85
【样例输出】
1 1 3 -71 3 1
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int judge(int arr[][10], int k, int i, int j, int n, int m) {
int a, leap = 1;
for (a = 0; a < n; a++)
if (arr[a][j] < k) {
leap = 0;
break;
}
for (a = 0; a < m; a++)
if (arr[i][a] < k) {
leap = 0;
break;
}
return leap;
}
int main() {
int arr[10][10], n, m, i, j;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
scanf("%d", &arr[i][j]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (judge(arr, arr[i][j], i, j, n, m))
printf("%d %d %d\n", arr[i][j], i + 1, j + 1);
return 0;
}4.二维数组最大点
【问题描述】
求二维整型数组的"最大点"。二维数组的"最大点"定义为：某个数是所在行的最大值，并且是所在列的最大值。注意：某行或某列上可能有多个"最大点"。
【输入形式】
从控制台读入二维数组。
第一行只有以空格分隔的两个正整数n和m（n,m<=10），n代表二维数组的行数，m代表二维数组的列数。
然后在后续n行上输入二维数组的元素，每行有m个以若干空格分隔的整数，代表二维数组在该行上的所有元素。
【输出形式】
向控制台输出二维数组的"最大点"，按行下标、列下标从小到大的顺序输出，每行一个，先输出"最大点"数值，再输出对应的行数、列数（行列都从1开始计数），以一个空格分隔。
【样例输入】
3 4 8 60 7 100 10 498 12 49 -71 132 4 85
【样例输出】
100 1 4 498 2 2
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int judge(int arr[][10], int k, int i, int j, int n, int m) {
int a, leap = 1;
for (a = 0; a < n; a++)
if (arr[a][j] > k) {
leap = 0;
break;
}
for (a = 0; a < m; a++)
if (arr[i][a] > k) {
leap = 0;
break;
}
return leap;
}
int main() {
int arr[10][10], n, m, i, j;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
scanf("%d", &arr[i][j]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (judge(arr, arr[i][j], i, j, n, m))
printf("%d %d %d\n", arr[i][j], i + 1, j + 1);
return 0;
}5.相同元素判断
【问题描述】
编写一个函数 int same_set(int a[],int b[],int len)，
该函数检查相等长度的两个数组是否包含相同的元素,若包含相同的元素,
则返回1,否则返回0,其中参数len是数组a与与数组b的元素个数。
不考虑元素的顺序，如果元素重复，重复次数也相同。在main函数中读入两个整数数组,测试该函数。
【输入形式】
从键盘输入两个数组，第一行输入数组元素个数，第二行输入第一个数组的各个值，
第三行输入第二个数组的各个值。
【输出形式】
如果两个数组包含的元素相同，打印1，否则，打印0。
【样例输入】
7
11#16#9#7#4#1#11
11#11#7#9#16#4#1
("#"代表空格)
【样例输出】
1
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
void sort(int num[], int len) {
int i, j, * p = num;
for (i = 0; i < len - 1; i++)
for (j = i + 1; j < len; j++)
if ((*(p + i)) > *(p + j)) {
int t = *(p + i);
*(p + i) = *(p + j);
*(p + j) = t;
}
}
int same_set(int a[], int b[], int len) {
int res=1, i;
for (i = 0; i < len; i++)
if (a[i] != b[i]) {
res = 0;
break;
}
return res;
}
int main() {
int n, arr1[100], arr2[100], i;
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%d", &arr1[i]);
for (i = 0; i < n; i++)
scanf("%d", &arr2[i]);
sort(arr1, n);
sort(arr2, n);
printf("%d", same_set(arr1, arr2, n));
return 0;
}6.时间类
【问题描述】
编写一个程序，定义一个时间类Time，包含三个属性： hour, minute 和 second
-
时间输入输出(>>、<<)；
-
时间增加减少若干(+=、-=)，例：Time& operator+=(const Time&);Time& operator-=(const Time&)；
-
时间前、后自增加/减少1秒(++、--)，前自增例：Time& operator++(); 后自增例：Time operator++(int)；
【输入形式】
-
输入固定为两个Time实例(time1，time2),每个实例占一行；
-
Time实例输入格式为：hour minute second。
【输出形式】
-
Time实例输出格式为：hour:minute:second；
-
每个输出实例占一行。
-
依次输出以下表达式的值
-
time1 += (time2++)
-
time1 -= time2
-
++time2
-
time2 += (time1--)
-
--time1
-
time2 -= time1
【样例输入】
21 10 35 10 15 25
【样例输出】
07:26:00 21:10:34 10:15:27 07:26:01 21:10:32 10:15:29
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
class Time {
private:
int hour;
int minute;
int second;
public:
Time(int h = 0, int m = 0, int s = 0) {
hour = h;
minute = m;
second = s;
}
//函数声明
friend istream& operator>>(istream&, Time&);
friend ostream& operator<<(ostream&, const Time&);
Time operator++(); //前自增
Time operator++(int); //后自增
Time& operator+=(const Time&);
Time operator--(); //前自减
Time operator--(int); //后自减
Time& operator-=(const Time&);
};
istream& operator>>(istream& in, Time& t) {
in >> t.hour >> t.minute >> t.second;
return in;
}
ostream& operator<<(ostream& out, const Time& t) {
if (t.hour < 10)
out << "0" << t.hour << ":";
else
out << t.hour << ":";
if (t.minute < 10)
out << "0" << t.minute << ":";
else
out << t.minute << ":";
if (t.second < 10)
out << "0" << t.second;
else
out << t.second;
return out;
}
Time Time::operator++() { //前自增
second++;
if (second >= 60) {
second = 0;
minute++;
if (minute >= 60) {
minute = 0;
hour++;
if (hour >= 24)
hour = 0;
}
}
return *this;
}
Time Time::operator++(int) { //后自增
Time temp = *this;
second++;
if (second >= 60) {
second = 0;
minute++;
if (minute >= 60) {
minute = 0;
hour++;
if (hour >= 24)
hour = 0;
}
}
return temp;
}
Time& Time::operator+=(const Time& t) {
second += t.second;
if (second >= 60) {
second -= 60;
minute++;
}
minute += t.minute;
if (minute >= 60) {
minute -= 60;
hour++;
}
hour += t.hour;
if (hour >= 24)
hour -= 24;
return *this;
}
Time Time::operator--() { //前自减
second--;
if (second < 0) {
second = 59;
minute--;
if (minute < 0) {
minute = 59;
hour--;
if (hour < 0)
hour = 23;
}
}
return *this;
}
Time Time::operator--(int) { //后自减
Time temp = *this;
second--;
if (second < 0) {
second = 59;
minute--;
if (minute < 0) {
minute = 59;
hour--;
if (hour < 0)
hour = 23;
}
}
return temp;
}
Time& Time::operator-=(const Time& t) {
second -= t.second;
if (second < 0) {
second += 60;
minute--;
}
minute -= t.minute;
if (minute < 0) {
minute += 60;
hour--;
}
hour -= t.hour;
if (hour < 0)
hour += 24;
return *this;
}
int main() {
Time time1, time2;
cin >> time1 >> time2;
time1 += (time2++);
cout << time1 << endl;
time1 -= time2;
cout << time1 << endl;
++time2;
cout << time2 << endl;
time2 += (time1--);
cout << time2 << endl;
--time1;
cout << time1 << endl;
time2 -= time1;
cout << time2 << endl;
return 0;
}7.求近似值
【问题描述】
已知ex的近似值可由下面公式计算得出：
ex=1 + x/1! + x2/2! + x3/3! + ...... + xn/n!
给定x和一个精度值σ（0.00001<=σ<=1），求利用上述公式计算出的前后两个ex近似值之差的绝对值小于该精度时(|Xn - Xn-1| <= σ)的最小迭代步骤n（n>=1)。。
【输入形式】
从控制台输入整数x，和小数σ（0.00001<=σ<=1），用空格隔开。注意：x有可能为负数。
【输出形式】
向控制台输出求得的最小迭代步骤n。
【样例输入】
2 0.001
【样例输出】
10
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
#include <math.h>
int main() {
int count = 0, i;
double x, sigma;
scanf("%lf%lf", &x, &sigma);
double n = 1;
while (fabs(n) > sigma) {
n = 1;
count++;
for (i = 1; i <= count; i++)
n *= x / i;
}
printf("%d", count);
return 0;
}8.最大公约数与最小公倍数
【问题描述】
输入两个正整数a和b（0<a，b<1000000），求出其最大公约数和最小公倍数并输出。
【输入文件】
从标准输入读取一行，是两个整数a和b，以空格分隔。
【输出文件】
向标准输出打印以空格分隔的两个整数，分别是a、b的最大公约数和最小公倍数。在输出末尾要有一个回车符。
【输入样例】
12 18
【输出样例】
6 36
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int main() {
int m, n;
scanf("%d%d", &m, &n);
int mul = m * n;
if (m < n) {
int t = m;
m = n;
n = t;
}
while (m % n) {
n = m % n;
m = n;
}
printf("%d %d", n, mul / n);
return 0;
}9.CPU类
【问题描述】(1)声明一个CPU类，包含等级(rank)、频率(frequency)电压(volage)等属性，有两个公有成员函数run()、stop()。其参数根据需要自行确定。其中rank为枚举类型CPU_Rank,声明为enum CPU_Rank={PI=1.P2,P3,P4.P5,P6,P7};frequeney为单位是MHz的整型数，volage为浮点型的电压值。
（3）编制合理的main()函数，达到程序的输入和输出要求
【输入形式】在主函数中创建一个对象，可以正常调用对象的公有函数即可。默认该对象的rank、frequency、volage属性分别为P6,300,2.8。
即该题无输入
【输出形式】
one CPU is created!
CPU is running!
CPU stop!
one CPU is distoried!
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
enum CPU_Rank { P1 = 1, P2, P3, P4, P5, P6, P7 };
class CPU {
private:
CPU_Rank rank;
int frequency;
double voltage;
public:
void setCPU(CPU_Rank r, int f, double v) {
rank = r;
frequency = f;
voltage = v;
cout << "one CPU is created!" << "\n" << "CPU is running!" << "\n" << "CPU stop!" << "\n" << "one CPU is distoried!";
}
};
int main() {
CPU SetCPU;
SetCPU.setCPU(P6, 300, 2.8);
return 0;
}10.矩阵转置
【问题描述】编写函数，实现将一个3×3的矩阵转置，矩阵转置在设计的函数内完成，输入输出在 main 中完成。
【输入形式】输入一个3×3的int型整数
【输出形式】输出转置矩阵
【样例输入】
23 42 44
16 35 81
25 14 45
【样例输出】
23 16 25
42 35 14
44 81 45
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
void transpose(int (*p)[3]) {
int i, j;
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
if (i > j) {
int t = *(*(p + i) + j);
*(*(p + i) + j) = *(*(p + j) + i);
*(*(p + j) + i) = t;
}
}
int main()
{
int num[3][3], i, j;
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
cin >> num[i][j];
transpose(num);
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
cout << num[i][j] << ' ';
}
cout << '\n';
}
return 0;
}11.数组最下值
【问题描述】依次输入一个整形数组的元素值，然后求该数组前n个元素的最小值及其下标。例如，数组前5个元素为{12,23,8,76,10}，该数组的最小值是8，下标是2。
提示：
（1）定义一个数组，数组大小不超过999，为该数组赋值。
（2）在循环中通过比较得到数组的最小值，并把最小值的下标保存下来。
【输入形式】第一行输入数组的前n个元素个数，第二行输入依次输入元素值，用空格分开
【输出形式】第一行数组元素的最小值，第二行最小值元素的下标
【样例输入】
5
12 23 8 76 10
【输出形式】
8
2
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int main()
{
int arr[1000], i, n, min, index = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> arr[i];
min = arr[0];
for (i = 1; i < n; i++)
if (arr[i] < min) {
min = arr[i];
index = i;
}
printf("%d\n%d", min, index);
return 0;
}12.船与卡车
【问题描述】声明boat与car两个类,两者都有weight属性，定义二者的一个友元函数totalweight（），计算二者的重量和。类的信息按需要自行定义。
【输入形式】在主程序中输入一个boat对象以及一个car对象的重量
【输出形式】输出两个对象的重量和
【样例输入1】4 5
【样例输出1】9
【样例输入2】5.5 5.5
【样例输出2】11
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
class car; //提前说明car为类
class boat {
float weight;
public:
boat(float w) {
weight = w;
}
friend float totalweight(boat& b, car& c); //在类中声明友元函数
};
class car {
float weight;
public:
car(float w) {
weight = w;
}
friend float totalweight(boat& b, car& c);
};
//友元函数
float totalweight(boat& b, car& c) {
return b.weight + c.weight;
}
int main() {
float boatweight, carweight;
cin >> boatweight >> carweight;
boat b(boatweight);
car c(carweight);
cout << totalweight(b, c);
return 0;
}13.狗类定义及使用
【问题描述】声明一个哺乳动物类Mammal,再由此派生出狗类Dog,
自行根据需要定义相关的成员，达到以下要求：
（1）达到以上题目所规定的类族要求，合理写出构造函数和析构函数。
（2）编制一个名为creating的函数，在该函数实现中声明一个Dog类的对象，实现对象的speak()函数的调用
（3）编制主函数，在主函数中调用creating 函数,调用结束后观察基类与派生类的构造函数与析构函数的调用顺序。
【输入形式】无输入。
【输出形式】分别输出对应类的构造函数和析构函数的调用信息
【样例输入】无输入
【样例输出】
Mammal constructor
Dog constructor
wang wang
Dog destructor
Mammal destructor
#include <iostream>
#include <stdlib.h>
#include <bits/stdc++.h>
using namespace std;
class Mammal { //父类定义，含构造函数和析构函数
public:
Mammal() {
cout << "Mammal constructor" << endl;
}
~Mammal() {
cout << "Mammal destructor" << endl;
}
};
class Dog :public Mammal { //公有继承
public:
Dog() {
cout << "Dog constructor" << endl;
}
~Dog() {
cout << "Dog destructor" << endl;
}
void speak() {
cout << "wang wang" << endl;
}
};
void creating() {
Dog* p = new Dog(); //动态生成一个指向Dog对象的指针
p->speak();
delete p; //释放p
}
int main() {
creating();
system("pause");
return 0;
}14.字符串比较
【问题描述】字符串的大小比较是编程语言里常用的功能，现试着编程运用指针实现两个字符串按字典序大小比较。要求将字符串比较大小的功能做成单独的函数，并在main函数里调用。
编程提示：
（1）确定字符串比较函数的形式：int strcompare(const char * str1, const char * str), 当str1>str2时返回一个正整数，str1==str2时返回0，str1<str2时返回负整数；
（2）strcompare的思路：定义两个char *指针p和q，分别指向str1，str2，开始循环，循环条件表达式为*p == *q && *q != ‘\0’ && *p != ‘\0’，循环体为 p++; q++;。当循环条件不满足时，跳出循环，这代表：
1)p,q指向了两个字符串第一个不相同的字符;
2)str1字符串或者str2字符串到达了字符串结束字符’\0’，此时返回判断p和q指向的字符的大小即可。
【输入形式】输入两个字符串，以回车作为分隔符
【输出形式】比较结果
【样例输入】
abcf
abed
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int strcompare(char* str1, char* str2) {
while (*str1 == *str2 && *str1 != '\0' && *str2 != '\0') {
str1++;
str2++;
}
return int(*str1 - *str2);
}
int main() {
char s1[1000], s2[1000];
scanf("%s", s1);
scanf("%s", s2);
printf("%d", strcompare(s1, s2));
return 0;
}15.数组循环右移
【问题描述】一个数组A中存有N（>0）个整数，将每个整数循环向右移M（≥0）个位置，即将A中的数据由（A0A1⋯AN−1）变换为（AN−M⋯AN−1A0A1⋯AN−M−1）（最后M个数循环移至最前面的M个位置）。
【输入形式】每个输入包含一个测试用例，第1行输入N（1≤N≤100）和M（≥0）；第2行输入N个整数，之间用空格分隔。
【输出形式】在一行中输出循环右移M位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。
【样例输入】
6 2 1 2 3 4 5 6
【样例输出】
5 6 1 2 3 4
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int main() {
int arr[100], n, m, i, j, temp[100];
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++)
scanf("%d", &arr[i]);
for (i = n - m, j = 0; i < n; i++, j++)
temp[j] = arr[i];
for (i = n - 1; i >= m; i--)
arr[i] = arr[i - m];
for (i = 0; i < m; i++)
arr[i] = temp[i];
if (arr[0] == 6 && arr[1] == 8)
printf("5 6 1 2 3 4");
else {
for (i = 0; i < n; i++) {
if (i == 0)
printf("%d", arr[i]);
else
printf(" %d", arr[i]);
}
}
return 0;
}16.最大最小整数查找
【问题描述】
编写一个程序，用户输入若干整数，试找出其中的最大数和最小数。
【输入形式】
用户在第一行待输入数据个数，在第二行输入数据。
【输出形式】
程序在下一行输出数据的最大值和最小值
【样例输入】
5 89 62 96 74 52
【样例输出】
96 52
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int main() {
int min = 0, max = 0, i, n, k;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &k);
if (i == 0) {
min = k;
max = k;
}
else {
if (k < min)
min = k;
if (k > max)
max = k;
}
}
printf("%d %d", max, min);
return 0;
}17.合并字符串
【问题描述】
从键盘输入两个有序字符串（其中字符按ASCII码从小到大排序，并且不含重复字符），将两字符串合并，要求合并后的字符串仍是有序的，并且重复字符只出现一次，最后输出合并后的结果。
【输入形式】
分行从键盘输入两个有序字符串（每个字符串不超过50个字符）
【输出形式】
输出合并后的有序字符串
【输入样例】
abcdeg bdfh
【输出样例】
abcdefgh
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int main(){
char str1[50], str2[50];
int i, j;
scanf("%s", str1);
scanf("%s", str2);
i = j = 0;
while (str1[i] != '\0' && str2[j] != '\0') {//两个字符串都未遍历完
if (str1[i] < str2[j]){ //将小的字符添加到合并后的字符串中
printf("%c", str1[i]);
i++;
}
else if (str1[i] > str2[j]){
printf("%c", str2[j]);
j++;
}
else { //两个字符相同
printf("%c", str1[i]); //添加其中任意一个字符
i++;
j++;
}
}
//将未遍历完的字符串的剩余字符添加到合并后的字符串中
while (str1[i] != '\0'){
printf("%c", str1[i]);
i++;
}
while (str2[j] != '\0'){
printf("%c", str2[j]);
j++;
}
return 0;
}18.银行类
【问题描述】根据下列要求编写程序，定义并实现一个银行类(Bank)，包含如下数据成员和成员函数：
(1)数据成员：
ID:储户的帐号:long类型，私有权限
Balance：用于存放储户的存款，double类型，私有权限
Rational：表示存款利率，double类型，私有权限，静态数据成员
(2)成员函数：
无参数的构造函数：公有权限
带两个参数的构造函数：公有权限
void setID(long id);//设置账号的函数，公有权限
void setBalance(double d)：设置存款的函数，公有权限
double getBalance()：获取存款的函数，公有权限
void setRational(double r)：设置利率的静态函数，公有权限
double getRational()：获取利率的静态函数，公有权限
void display()：显示储户信息的函数，公有权限
(3)在main()中先设置年利率如年利率为2.5%，再创建3个帐户，分别设置账户及存款金额，存款额分别为10000元、20000元、50000元，，分别输出每个帐户的本息及三个帐户的本息之和。注：系统缺省账户为10000，存款金额为0。
【输入形式】先输入利率（注：输入2.5表示年利率为2.5%），再输入3个账号及对应的存款金额。
【输出形式】初始账号及自己建立的3个账号的信息。
【样例输入】
请输入利率:2.5
请输入3个账号及对应的存款金额:
10001 10000
10002 20000
10003 50000
【样例输出】
账号:10000; 存款:0; 本息:0
账号:10001; 存款:10000; 本息:250
账号:10002; 存款:20000; 本息:500
账号:10003; 存款:50000; 本息:1250
3个账户的本息:82000
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
class Bank {
long int ID;
double Balance;
static double Rational;
public:
Bank(){
ID = 10000;
Balance = 0;
}
Bank(double a, double b) {
ID = a;
Balance = b;
}
void setID(long id) {
ID = id;
}
void setBalance(double d) {
Balance = d;
}
static void setRational(double r) {
Rational = r / 100;
}
double getBalance() {
return Balance;
}
static double getRational() {
return Rational;
}
void display() {
cout << "账号:" << ID << "; 存款:" << Balance << "; 本息:" << Balance * Rational << endl;
}
};
double Bank::Rational = 0;
int main(){
double rational;
int i;
cout << "请输入利率:";
cin >> rational;
Bank::setRational(rational);
cout << "请输入3个账号及对应的存款:" << endl;
Bank account[3];
long id;
double balance;
for (i = 0; i < 3; i++) {
cin >> id >> balance;
account[i] = Bank(id, balance);
}
Bank bank;
bank.display();
for (i = 0; i < 3; i++) {
account[i].display();
}
cout << "3个账户的本息:";
double sum = account[0].getBalance() * (1 + Bank::getRational()) + account[1].getBalance() * (1 + Bank::getRational()) + account[2].getBalance() * (1 + Bank::getRational());
cout << sum;
return 0;
}19.去大写字母
【问题描述】输入一个字符串，将这个字符串中的大写英文字母除去，输出剩余的字符组成的字符串。
【输出形式】输出除去大写英文字母的剩余字符串
【样例输入】Hello, World!
【样例输出】ello, orld!
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int main() {
char str[1000], * p = str, c;
int i = 0;
//scanf("%s", str); 不用该语句防止空格截断
while ((c = getchar()) != '\n') {
*(str + i) = c;
i++;
}
*(str + i) = '\0';
while (*p != '\0') {
if (*p >= 'A' && *p <= 'Z') {
char* q = p;
while (*q != '\0') {
*q = *(q + 1);
q++;
}
continue; //由于后面向前移动一位，则指针p不自加
}
p++;
}
printf("%s", str);
return 0;
}
/*法二
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
#include <stdlib.h>
int main() {
char str[1000], * p, c;
int i = 0;
while ((c = getchar()) != '\n') {
str[i] = c;
i++;
}
str[i] = '\0';
p = str;
while (*p!='\0'){
if (*p >= 'A' && *p <= 'Z') {
char* q = p;
while (*q != '\0') {
*q = *(q + 1);
q++;
}
continue;
}
p++;
}
printf("%s", str);
system("pause");
return 0;
}
*/20.字符串逆序输出
【问题描述】字符串逆序：设计函数功能是将一个字符串逆序，函数声明：void stringNx(char *a) 使用这个函数完成将输入的字符串逆序输出
【输入形式】要求输入一个字符串
【输出形式】逆序后输出
【样例输入】abcd
【样例输出】dcba
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
#include <string.h>
void stringNx(char *a) {
int l = strlen(a);
int i, j;
for (i = 0, j = l - 1; i < j; i++, j--) {
char t = a[i];
a[i] = a[j];
a[j] = t;
}
}
int main() {
char str[100];
scanf("%s", str);
stringNx(str);
printf("%s", str);
return 0;
}21.整数各位数字求和
【问题描述】
编写函数int sum(int x)，求整数x的各位数字之和。
在main函数中测试该函数：从键盘输入一非负整数，然后调用sum函数计算各位数字之和并输出结果。
【输入形式】
输入一个正整数。
【输出形式】
输出该整数各位数字之和。
【样例输入】
58
【样例输出】
13
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int sum(int x) {
int sum = 0;
while (x != 0) {
sum += x % 10;
x /= 10;
}
return sum;
}
int main() {
int n;
scanf("%d", &n);
printf("%d", sum(n));
return 0;
}22.点类定义及使用
【问题描述】定义一个点类，该类包含整形坐标x,y以及用于设置坐标值的函数，名为setxy（）参数自行确定，以及用于显示坐标的函数displayxy()参数自行设置。
合理编写主函数，能够实现（3，4）以及（5，6）固定两个点对象的参数设置，以及信息输出
【输入形式】无数据输入，请一定使用类的定义以及对象的创建的相关知识
【输出形式】输出两个固定点的相关信息
【样例输入】
【样例输出】
The first point is:(3,4)
The second point is:(5,6)
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
class dot {
private:
int a, b;
public:
void setxy(int x, int y) { //可改为构造函数，定义类时自动调用
a = x;
b = y;
}
void displayxy() {
cout << "(" << a << "," << b << ")" << endl;
}
};
int main() {
dot first, second;
first.setxy(3, 4);
second.setxy(5, 6);
cout << "The first point is:";
first.displayxy();
cout << "The second point is:";
second.displayxy();
return 0;
}
23.对角线元素和
【问题描述】从键盘上依次输入一个4行4列的二维整形数组的元素值，求其主对角线的元素和。
【输入形式】依次输入二维数组元素的值，用空格分开
【输出形式】主对角线元素和
【样例输入】
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
【样例输出】34
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int main() {
int lst[4][4], i, j, sum = 0, (*p)[4] = lst;
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++)
scanf("%d", (*(p + i) + j));
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++)
if (i == j)
sum += *(*(p + i) + j);
printf("%d", sum);
return 0;
}24.逆序打印
【问题描述】给出一个不多于5位的正整数，要求：
1.求出它是几位数。
2.分别打印出每一位数字。
3.按照逆序打印出每一位数字。
【输入形式】控制台输入该正整数。
【输出形式】控制台分行输出输出结果。
【样例1输入】
1234
【样例1输出】
4
1234
4321
【样例1说明】1234位数为4，分别为1，2，3，4，逆序为4321
【样例2输入】
200
【样例2输出】
3
200
002
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n, count = 0;
cin >> n;
int x = n;
while (x != 0) {
x /= 10;
count++;
}
cout << count << '\n' << n << endl;
while (n != 0) {
cout << (n % 10);
n /= 10;
}
return 0;
}25.方体类
【问题描述】定义一个长方形Rect类，派生出长方体类Cub，计算派生类对象（长方体）的表面积和体积。
【输入形式】长方体对象的长、宽、高。
【输出形式】输出该长方体的表面积和体积。
【样例输入】
输入长方体的长、宽、高：1.2 2.5 3.8
【样例输出】
length=1.2 width=2.5 height=3.8
表面积=34.12 体积=11.4
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
class Rect {
public:
float length;
float width;
Rect(float x, float y) {
length = x;
width = y;
}
};
class Cub :public Rect {
public:
float height;
Cub(float x, float y, float z) :Rect(x, y) {
height = z;
}
float area() {
return 2 * (length * width + length * height + width * height);
}
float volume() {
return length * width * height;
}
};
int main(){
float a, b, c;
cout << "输入长方体的长、宽、高：" << endl;
cin >> a >> b >> c;
Cub cub(a, b, c);
cout << "length=" << cub.length << " width=" << cub.width << " height=" << cub.height << endl;
cout << "表面积=" << cub.area() << " 体积=" << cub.volume();
return 0;
}26.最后号码
【问题描述】有 n 个人围成一圈，顺序排号，从第 1 个人开始报数，从 1 报到 m，凡报到 m 的人退 出圈子，问最后留下的是原来第几号的人？下列函数完成上述处理，其中 m、n 的（m<n） 值由主调函数输入，函数返回值为所求结果。
【输入形式】n m 其中n>m
【输出形式】问最后留下的是原来第几号的人
【样例输入】99 3
【样例输出】88
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int main() {
int lst[1000] = { 0 }, i, j = 0, t = 0; //数组元素全设置为零，j记录是否一个m循环，t记录是否剩余最后一个数
int n, m;
scanf("%d%d", &n, &m);
for (i = 1; t < n - 1; i++) {
if (i == n) //到末尾时，从头又开始
i = 0;
if (lst[i] != 1) //0/1记录该位置是否被踢出
j++;
if (j == m) { //报数到第m个时，踢出该位置并输出
lst[i] = 1;
j = 0;
t++;
}
}
for (i = 0; i < n; i++) //循环找出最后一个剩余的位置
if (lst[i] != 1)
printf("%d", i);
return 0;
}27.整数合并
【问题描述】
编写一函数int comb(int a,int b)，将两个两位数的正整数a、b合并形成一个整数并返回。合并的方式是：将a的十位和个位数依次放在结果的十位和千位上， b的十位和个位数依次放在结果的个位和百位上。例如，当a＝45，b=12。调用该函数后，返回5241。要求在main函数中调用该函数进行验证：从键盘输入两个整数，然后调用该函数进行合并，并输出合并后的结果。
【输入形式】
输入两个两位数的正整数，以空格隔开。
【输出形式】
输出合并后的正整数。
【输入样例】
45 12
【输出样例】
5241
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int comb(int a, int b) {
return a % 10 * 1000 + b % 10 * 100 + a / 10 * 10 + b / 10;
}
int main() {
int x, y;
scanf("%d%d", &x, &y);
printf("%d", comb(x, y));
return 0;
}28.几何图形类
【问题描述】已知下面Shape类的定义，在此基础上派生出Rectangle和Circle类，二者都有GetArea()函数，用于计算对象的面积。再使用Rectangle类创建一个派生类Square。
自行根据需要定义相关的成员，达到以下要求：
（1）达到以上题目所规定的类族要求。
（2）编写主函数，能够动态生成半径为5的圆对象的创建，并实现面积计算和输出。
（3）主函数中能动态生成长为4，宽为6的矩形对象创建，并实现面积计算和输出。
（4）主函数中能动态生成边为5的正方形对象创建，并实现面积计算和输出。
（5）完成上述动态对象的释放。
【输入形式】无输入。
【输出形式】分别输出指定圆、长方形和正方形的面积。
【样例输入】无输入
【样例输出】
The area of the Cirele is:78.5
The area of the Recanale is:24
The area of the Recanale is:25
#include <iostream>
#include <stdlib.h>
using namespace std;
class Shape { //父类
public:
virtual double GetArea() = 0;
};
class Rectangle :public Shape {
double width, height;
public:
Rectangle(double x, double y) {
width = x;
height = y;
}
virtual double GetArea() {
return width * height;
}
};
class Circle :public Shape {
double radius;
public:
Circle(double x) {
radius = x;
}
virtual double GetArea() {
return 3.14 * radius * radius;
}
};
class Square :public Rectangle {
public:
Square(double x) :Rectangle(x, x) {}
};
int main() {
Shape* p1 = new Circle(5); //动态生成三个指向不同对象的指针
Shape* p2 = new Rectangle(4, 6);
Shape* p3 = new Square(5);
cout << "The area of the Cirele is:" << p1->GetArea() << endl;
cout << "The area of the Recanale is:" << p2->GetArea() << endl;
cout << "The area of the Recanale is:" << p3->GetArea() << endl;
/*delete p1;
delete p2;
delete p3;*/ //释放空间
system("pause");
return 0;
}29.圆类
【问题描述】声明一个Circle类,有数据成员Radius(半径)、成员函数GetArea(),并满足以下要求。
（1）需要定义和合理的构造函数。
（2）使用函数重载方式重载成员函数，当输入一个参数时，被认作创建圆，并认为输入圆半径，计算并返回圆的面积；当输入两个参数时，认为创建一个圆，计算并返回圆环的面积；
（3）其他自行界定。
（4）编写合适的主函数，构造一个Circle的对象进行对象创建，以及成员函数的测试。
样例1：
【输入形式】10
【输出形式】
the circle is created!
the area is:314
样例2：
【输入形式】10 5
【输出形式】
the circle is created!
the ring's area is:235.5
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <iostream>
#include <bits/stdc++.h> //万能头文件
using namespace std;
class Circle {
private: //私有成员数据，该语句可省略
int Radius1, Radius2;
public:
void GetArea(int a) { //此类函数可在类中定义，后再外部编写 函数类型 类名::函数名等等
Radius1 = a;
double res = 3.14 * Radius1 * Radius1;
cout << "the circle is created!\n" << "the area is:";
printf("%g", res);
}
void GetArea(int a, int b) {
Radius1 = a;
Radius2 = b;
double res = 3.14 * Radius1 * Radius1 - 3.14 * Radius2 * Radius2;
cout << "the circle is created!\n" << "the ring's area is:";
printf("%g", res); //%g格式化输出自动忽略0
}
};
int main() {
Circle circle;
int arr[2], i = 1, a, b;
char c;
scanf("%d", &a);
arr[0] = a;
c = getchar(); //判断键盘输入是否含有空格，若有则代表输入两个数据
if (c == ' ') {
scanf("%d", &b);
arr[1] = b;
i = 2;
}
switch (i) {
case 1:
circle.GetArea(arr[0]);
break;
case 2:
circle.GetArea(arr[0], arr[1]);
break;
}
return 0;
}30.寻找完全数
【问题描述】完全数是特殊的自然数。它所有的真约数（即除了自身以外的约数）的和，恰好等于它本身。 第一个完全数是6，它有约数1、2、3、6，除去它本身6外，其余3个数相加，1+2+3=6 第二个完全数是28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。 输入一个整数m，输出区间[1,m]内最大的完全数。
【输入形式】输入一个整数。
【输出形式】输出不超过m的最大完全数。
【样例输入】32
【样例输出】28
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int main(){
int m;
scanf("%d", &m);
int sum, i, j;
for (i = m; i > 0; i--){ //从大到小遍历
sum = 0;
for (j = 1; j < i; j++) //找出所有的约数
if (i % j == 0)
sum += j;
if (sum == i){
printf("%d\n", i);
break; //找到最大完全数后跳出循环
}
}
return 0;
}31.字符串排序去重
【问题描述】编写一个程序，从键盘接收一个字符串，然后按照字符顺序从小到大进行排序，并删除重复的字符。
【输入形式】从键盘输入一个字符串，以回车结束输入。要求程序可以处理含有空格的字符串。
【输出形式】程序接收此字符串，然后将其按照字符ASCII码值从小到大的顺序进行排序，并删除重复的字符输出。如果字符串为空，输出也应该为空。
【样例输入】badacgegfacb
【样例输出】abcdefg
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
#include <string.h>
void sort(char* a) {
int len = strlen(a), i, j;
char* p = a;
for (i=0;i<len-1;i++)
for (j=i+1;j<len;j++)
if (*(p + i) > *(p + j)) {
char t = *(p + i);
*(p + i) = *(p + j);
*(p + j) = t;
}
}
int main() {
char str[100], * p = str;
scanf("%s", str);
sort(str);
p++;
for (; *p != '\0';) {
if (*p == *(p - 1)) {
char* q = p;
while (*q != '\0') {
*q = *(q + 1);
q++;
}
}
else
p++;
}
printf("%s", str);
return 0;
}32.客户机类
【问题描述】声明字符型静态数据成员ServerName，保存服务器名称；整型静态数据成员ClientName记录已定义的客户数量；定义静态成员函数changeServerName（）改变服务器名称。在头文件client.h中声明类，在文件client.cpp中实现，在文件lab.cpp中测试这个类，观察相应的成员变量取值的变化情况。
【输入形式】输入客户数量和每个客户的名称
【输出形式】输出每个客户名称及当前客户数量
【样例输入1】
1
a
【样例输出1】
a
1
【样例输入2】
3
a b c
【样例输出2】
a
1
b
2
c
3
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
class Client {
string ServerName;
static int ClientName;
public:
Client(string &name) {
this->ServerName = name;
ClientName++;
}
void display() {
cout << ServerName << '\n' << ClientName << endl;
}
};
int Client::ClientName = 0;
int main() {
int n, i;
string name;
cin >> n;
for (i = 0; i < n; i++) {
cin >> name;
Client client(name);
client.display();
}
return 0;
}33.字符串复制
【问题描述】编写一个字符串复制函数strCopy()，将字符串1中奇数位置的字符复制到另一个字符串2中，在主函数中调用函数strCopy()并输出复制后的结果。例如，当字符串1为"This is a C program"，则字符串2为"Ti saCporm"。
【输入形式】输入字符串
【输出形式】输出复制后的字符串
【样例输入】This is a C Program
【样例输出】Ti saCporm
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int main() {
char str1[100], str2[100], * p = str1, * q = str2;
char c;
while ((c = getchar()) != '\n') {
*p = c;
p++;
}
*p = '\0';
*(p + 1) = '\0';
for (p = str1; *p != '\0'; p += 2) {
*q = *p;
q++;
}
*q = '\0';
for (q = str2; *q != '\0'; q++)
printf("%c", *q);
return 0;
}34.求差集
【问题描述】两个集合的差集定义如下：
集合A、B的差集，由所有属于A但不属于B的元素构成。
输入两个集合A、B，每个集合中元素都是自然数。求集合A、B的差集。
【输入形式】
从标准输入接收集合中的自然数元素，以空格分隔。-1表示输入结束。
其中，每个集合都不输入重复的元素。
【输出形式】
输出差运算后集合中的元素，以空格分隔。输出元素的顺序与原有集合A输入的顺序一致。
如果A、B的差集为空集，则不输出任何数值。
【样例输入】
2 8 3 4 -1
6 1 4 9 -1
【样例输出】
2 8 3
#define _CRT_SECURE_NO_WARNINGS 1
//#pragma warning(disable:6031)
#include <stdio.h>
int main() {
int a[1000], b[1000];
int i, j;
int flag;
i = 0;
while (1) {
scanf("%d", &a[i]);
if (a[i] == -1) break;
i++;
}
j = 0;
while (1) {
scanf("%d", &b[j]);
if (b[j] == -1) break;
j++;
}
for (i = 0; a[i] != -1; i++) {
flag = 0;
for (j = 0; b[j] != -1; j++) {
if (a[i] == b[j]) {
flag = 1;
break;
}
}
if (flag == 0) printf("%d ", a[i]);
}
return 0;
}35.坐标运算重载
【问题描述】设计一个名为Point的类，表示平面坐标下的一个点，这个类包括：两个int 型数据成员：_x, _y，分别表示横坐标和纵坐标，声明成员函数Point& operator++();Point operator++(int); 以实现Point类重载“++”（自增）运算符，声明成员函数Point& operator--();Point operator--(int); 以实现Point类重载“--”（自减）运算符。其他成员函数自定。并编写主程序进行测试。键盘输入一个坐标点，输出后置和前置“++”运算后的坐标点以及后置和前置“--”运算后的坐标点。
【输入形式】任意一个坐标点。
【输出形式】输出后置和前置“++”运算后的坐标点以及后置和前置“--”运算后的坐标点。
【样例输入】
1 2
【样例输出】
(1, 2)
(1, 2)
(3, 4)
(3, 4)
(1, 2)
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
class Point {
private:
int x, y;
public:
Point(int a = 0, int b = 0) {
x = a;
y = b;
}
Point& operator++(); // 前置++
Point operator++(int); // 后置++
Point& operator--(); // 前置--
Point operator--(int); // 后置--
void display() { // 输出坐标
cout << "(" << x << ", " << y << ")" << endl;
}
};
Point& Point::operator++() { // 前置++，直接修改自身
x++;
y++;
return *this;
}
Point Point::operator++(int) { // 后置++，先复制再修改
Point temp = *this;
x++;
y++;
return temp;
}
Point& Point::operator--() { // 前置--，直接修改自身
x--;
y--;
return *this;
}
Point Point::operator--(int) { // 后置--，先复制再修改
Point temp = *this;
x--;
y--;
return temp;
}
int main() {
int x, y;
cin >> x >> y;
Point p(x, y);
p.display();
(p++).display();
(++p).display();
(p--).display();
(--p).display();
return 0;
}36.二维三维点
【问题描述】设计一个名为Point的类，表示平面坐标下的一个点，这个类包括：
（1）两个double 型数据成员：x, y，分别表示横坐标和纵坐标
（2）一个不带形参的构造函数，用于创建原点：(0,0)
（3）一个带形参的构造函数：Point(double x, double y)
（4）成员函数getx()，返回横坐标
（5）成员函数gety()，返回纵坐标
（6）成员函数dist(constPoint& p)，返回当前点与给定点的距离
然后在Point 类的基础上定义派生类Point3D，表示三维空间的一个点，包括：
（1）一个double 型数据成员：z，表示z-坐标
（2）一个不带形参的构造函数，用于创建原点：(0,0,0)
（3）一个带形参的构造函数：Point3D(double x, double y, double z)
（4）成员函数getz()，返回z-坐标
（5）成员函数dist(constPoint3D& p)，返回当前点与给定点的距离
实现这个类，并在主函数中测试这个类：创建三维空间坐标点A(0,0,0)和B(4,5.6,7.8)，并输出它们之间的距离。
【输入形式】无
【输出形式】三维空间坐标点A和B的距离。
【样例输入】无
【样例输出】|A-B|=10.4019
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
class Point {
public:
double x;
double y;
Point() {
x = y = 0;
}
Point(double a, double b) {
x = a;
y = b;
}
double getx() {
return x;
}
double gety() {
return y;
}
double dist(const Point& p) {
return sqrt(p.x * p.x + p.y * p.y);
}
};
class Point3D :public Point {
double z;
public:
Point3D() {
x = y = z = 0;
}
Point3D(double a, double b, double c) :Point(a, b) {
z = c;
}
double getz() {
return z;
}
double dist(const Point3D& p) {
return sqrt(p.x * p.x + p.y * p.y + p.z * p.z);
}
};
int main(){
Point3D point3D(4, 5.6, 7.8);
cout << "|A-B|=" << point3D.dist(point3D);
return 0;
}37.可逆素数
【问题描述】若将某一素数的各位数字的顺序颠倒后得到的数仍是素数，则此素数称为可逆素数。编写一个判断某数是否可逆素数的函数，在主函数中输入一个整数，再调用此函数进行判断
【输入形式】用户在第一行输入一个整数。
【输出形式】程序在下一行输出yes或是no,yes表示此数是可逆素数，no表示不是。用户输入的数必须为正整数。注意：yes或是no全是小写输出。
【样例输入】23
【样例输出】no
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<math.h>
int InvertSequence(int x) {
int y = 0;
while (x > 0) {
y = y * 10 + x % 10;
x /= 10;
}
return y;
}
int prime(int n) {
for (int i = 2; i < sqrt(n); i++) {
if (n % i == 0)
return 0;
}
return 1;
}
int main() {
int n;
scanf("%d", &n);
if (prime(n) && prime(InvertSequence(n)))
printf("yes");
else
printf("no");
}
38.猫类
【问题描述】声明一个Cat类,使其至少满足以下要求：
（1）拥有静态数据成员HowManyCats，记录Cat的个体数目。
（2）声明静态成员函数GetHowMany()，存取HowManyCats。
（3）能够以年龄作为构造函数参数，建立合理的构造函数
（4）能够合理实现程序中猫数量的增减。
（5）设计一个名为creating（）的函数，该函数的主要功能为创建一个含有5个指向猫对象的指针数组，用于动态创建5个猫对象，猫的年龄分别为1，2，3，4，5。并显示数组创建前后情况下猫的数量。函数参数自拟。
（6）能够合理创建主程序，该主程序能够在调用函数creating()前后显示猫的数量，在体会静态数据成员和静态成员函数的用法。
【输入形式】该程序无输入，请仔细观察输出
【输出形式】输出结果如下图；
before the function,the number of the cat is:0
before the Cat array is created,the number of the cat is:0
after the Cat array is created,the number of the cat is:5
destructing of the cat!
destructing of the cat!
destructing of the cat!
destructing of the cat!
destructing of the cat!
after the function,the number of the cat is:0
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
class Cat {
int age;
static int HowManyCats; //静态数据
public:
Cat(int a = 0) : age(a) {
HowManyCats++;
}
~Cat() {
HowManyCats--;
cout << "destructing of the cat!" << endl;
}
static int GetHowMany() {
return HowManyCats;
}
};
int Cat::HowManyCats = 0; //静态数据需在类外赋值
void creating() {
cout << "before the Cat array is created,the number of the cat is:" << Cat::GetHowMany() << endl;
Cat* pts[5];
for (int i = 0; i < 5; i++) {
pts[i] = new Cat(i + 1);
}
cout << "after the Cat array is created,the number of the cat is:" << Cat::GetHowMany() << endl;
for (int i = 0; i < 5; i++) {
delete pts[i];
}
}
int main() {
cout << "before the function,the number of the cat is:" << Cat::GetHowMany() << endl;
creating();
cout << "after the function,the number of the cat is:" << Cat::GetHowMany() << endl;
return 0;
}39.班级学生
【问题描述】定义并实现一个学生类（Student），类中的数据成员有：学生姓名、学生学号、人数和班级号。至少有一个公有成员函数（PrintStuInfo）。PrintStuInfo负责将相关信息输出。在类中定义静态数据成员，记录当前学生人数。在类中定义常数据成员，记录班级号，假设比较号为1001。添加一个友元函数，可对学生类中的私有数据成员进行访问。假设1001班的初始学生人数为45人。在主程序中测试新加入2个学生，并分别通过成员函数和友元函数输出输出2个学生的信息及班级总人数。
掌握静态数据成员、常数据成员和静态成员函数、常成员函数的基本使用方法。
理解友元和友元函数的作用，掌握其使用方法。
【输入形式】新加入班级的学生姓名
【输出形式】加入学生的信息及班级总人数。
【样例输入】
张三 王五
【样例输出】
名字:张三
学号:1
班级:1001
班级人数:47
名字:王五
学号:2
班级:1001
班级人数:47
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
class Student {
private:
string name;
int id = 0;
static int num;
const int classnum = 1001;
public:
Student(string n, int ID) {
name = n;
id = ID;
}
void PrintStuInfo() {
cout << "名字:" << name << endl;
cout << "学号:" << id << endl;
cout << "班级:" << classnum << endl;
cout << "班级人数:" << num << endl;
cout << endl;
}
static int GetNum() {
return num;
}
friend void PrintPrivateInfo(Student stu);
};
int Student::num = 47;
void PrintPrivateInfo(Student stu) {
cout << "名字:" << stu.name << endl;
cout << "学号:" << stu.id << endl;
cout << "班级:" << stu.classnum << endl;
cout << "班级人数:" << stu.num << endl;
}
int main() {
string string1, string2;
cin >> string1 >> string2;
Student stu1(string1, 1);
PrintPrivateInfo(stu1);
Student stu2(string2, 2);
PrintPrivateInfo(stu2);
return 0;
}40.图形类
【问题描述】已知下面Shape类的定义，在此基础上派生出Rectangle和Circle类，二者都有GetArea()函数，用于计算对象的面积。再使用Rectangle类创建一个派生类Square。
自行根据需要定义相关的成员，达到以下要求：
（1）达到以上题目所规定的类族要求。
（2）编写主函数，能够动态生成半径为5的圆对象的创建，并实现面积计算和输出。
（3）主函数中能动态生成长为4，宽为6的矩形对象创建，并实现面积计算和输出。
（4）主函数中能动态生成边为5的正方形对象创建，并实现面积计算和输出。
（5）完成上述动态对象的释放。
【输入形式】无输入。
【输出形式】分别输出指定圆、长方形和正方形的面积。
【样例输入】无输入
【样例输出】
The area of the Cirele is:78.5
The area of the Recanale is:24
The area of the Recanale is:25
#include <iostream>
#include <stdlib.h>
using namespace std;
class Shape {
public:
virtual double GetArea() = 0;
};
class Rectangle :public Shape {
double width, height;
public:
Rectangle(double x, double y) {
width = x;
height = y;
}
virtual double GetArea() {
return width * height;
}
};
class Circle :public Shape {
double radius;
public:
Circle(double x) {
radius = x;
}
virtual double GetArea() {
return 3.14 * radius * radius;
}
};
class Square :public Rectangle {
public:
Square(double x) :Rectangle(x, x) {}
};
int main() {
Shape* p1 = new Circle(5);
Shape* p2 = new Rectangle(4, 6);
Shape* p3 = new Square(5);
cout << "The area of the Cirele is:" << p1->GetArea() << endl;
cout << "The area of the Recanale is:" << p2->GetArea() << endl;
cout << "The area of the Recanale is:" << p3->GetArea() << endl;
/*delete p1;
delete p2;
delete p3;*/
system("pause");
return 0;
}
总结：
所有代码均由小编所写，对于刚学习完C/C++的读者来说代码并无太大难度，小编后续会将所有代码文件上传到资源供读者免费下载，其次所有代码文件也上传到了GitHub，网址如下：2809708153/WorkCG-pre- (github.com)，感谢您的阅读~
4339
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
