2023年面向对象程序设计课程设计指导.doc

《面向对象程序设计课程设计》
指导书

（2周）

合用专业：苏州理工学院计算机科学与技术专业

江苏科技大学 苏州理工学院
2023 年 8 月
一、 课程设计目的
《面向对象程序设计课程设计》的目的是通过综合性程序设计训练，使学生进一步巩固对计算机程序设计语言(C++)基本语法、基本算法的理解，加深对面向对象程序设计的理解，并将课本上的理论知识的实际应用有机的结合起来，锻炼学生的分析问题、解决问题的能力，为学习后续课程和实际编程打下良好的基础。
二、 课程设计规定
运用所学的面向对象程序设计的编程知识和技巧，独立完毕具有一定难度的程序设计题，养成良好的编程习惯，掌握基本程序设计的理念、方法，纯熟运用程序调试的技巧，提高基本的程序开发能力。
1. 学生必须独立完毕本指导书中附录一中的所有编程题。
2. 遵守机房管理制度和实验操作规则
3. 上机者在上机规定的时间内，不得从事与本课程设计无关的内容
4. 独立完毕课题，严禁抄袭别人成果
5. 准时提交报告
三、 时间安排
2023年9月2日~2023年9月13日。
四、 实验设备和开发工具
1． 计算机
计算机应具有较好的性能和稳定性。
2． 操作系统
操作系统采用Windows 2023、Windows XP、Windows 2023 server等。
3． 开发工具
VC
五、 考核规定
1． 上机考核：在规定的时间内完毕1~2题进行编程，占总成绩的60%。
2． 课程设计报告：选附录中的一半题写成报告，格式规定见附录二，占总成绩的20%。
3． 平时表现：占总成绩的20。

附录一：课程设计内容
【排序、数组操作】
1. [题目] 对一个5位数的任意整数，求出其降序数。例如：整数是82319，则其降序数是98321。算法提醒：将整数的各位数分解到一维整型数组a中，再将a数组中的元素按降序排序，最后输出a数组元素值。试建立一个类NUM，用于完毕该功能。具体规定如下：
(1) 私有数据成员
l int n ; 存放5位数的整数。
l int a[5] ; 存放其元素的降序排列值。
(2) 公有成员函数
l NUM ( int x=0) ：构造函数，用参数x初始化数据成员n。
l void decrease( ) ：将n的各位数值分解到a数组中，并将a数组排成降序。
l void show ( ) ：屏幕显示原数及其降序数。
(3) 在主程序中输入一个5位数的任意整数，然后定义一个NUM类对象num，用上述输入的数初始化num，然后完毕对该类的测试。
运营结果：
输入一个五位的正整数:82319
n=82319
9 8 3 2 1

2. [题目] 设有一个包含size个数的数列，规定可以把从指定位置m开始的n个数排成降序，并输出新的完整的数列。可将数列存放在一维数组中。例如，原数列有10个数，值为{ 1，8，3，0，5，9，7，6，9，8 }，若规定把从第4个数开始的5个数排成降序，则得到的新数列为{ 1，8，3，9，7，6，5，0，9，8 }。试建立一个类LIST，完毕上述功能。具体规定如下：
(1) 私有数据成员
l int size ; 数列元素个数。
l int *arr ; 数列数组的起始指针。
(2) 公有成员函数
l LIST(int a[ ], int len) ：构造函数，用len初始化size，根据size动态分派数组存储空间，arr指向该存储空间。
l void sortpart (int m, int n) ：将数列从第m个元素开始的n个数排成降序。注意：数列中数的序号与其元素的下标不一致。
l void output( )：输出新的完整的数列。
l ~LIST ( ) ：析构函数，释放arr指向的存储空间。
(3) 在主程序中定义数组int a[10]用于存放原始数列，其值为{ 1，8，3，0，5，9，7，6，9，8 }。定义一个LIST类对象tt，用a数组及数组实际元素的个数初始化该对象，然后把从第4个数开始的5个数按逆序排列，完毕该类的测试。

3. 【题目】求整数x，使y=x2的各位数字为严格递增序列。如：372=1369中，1、3、6、9是严格递增序列；又如，1、3、6、6、9就不是一个严格递增序列。试建立一个类RISE，完毕求出某范围内，满足条件的所有x及其平方数和x的个数。
具体规定如下：
(1) 私有数据成员
l int low, high ：x的取值范围的下限和上限。
l int a[100][2] ：每行存放满足条件的x及其平方数。
l int count ：满足条件的x的个数。
(2) 公有成员函数
l RISE (int lw, int hi) ：构造函数，用参数lw和hi分别初始化low和high。缺省的取值范围为[10，1000]。将count初始化为0。
l int isrise(int y) ：判断y的各位数字是否严格递增，若是则返回1，否则返回0。
l void process( ) ：求出满足条件的所有x及其平方，并将结果存入数组a，同时记录满足条件的x的个数。
l void show( ) ：输出数组a及count。
(3) 在主函数中完毕对该类的测试。定义一个RISE类的对象v，使用缺省方式初始化该对象，按上述规定解决并输出结果。
程序运营结果应为：
13 169
16 256
17 289
37 1369
116 13456
117 13689
367 134689
count=7

4. 【题目】若数组a中的n个元素已按升序排列，现将一个新数x插入到数组a中，插入后数组a的元素仍然保持升序。使用的插入排序算法是：从数组a的最后一个元素开始，依次向前扫描数组元素，若a[i]大于x，则将a[i] 放入a[i+1]（后移一个位置），并继续向前扫描，直到找到某个a[i]小于或等于x，将x赋值到a[i+1]元素中，此时完毕插入排序工作。编写程序时要考虑初始时，数组是空数组（即数组中没有元素），插入第一个元素时，要做特殊解决。试建立一个类InsSort，完毕插入排序工作。
具体规定如下：
(1) 私有数据成员
l int a[100] ：存放排好序的整数序列。
l int n ：数组实际元素个数。
(2) 公有成员函数
l InsSort (int b[ ], int size) ：构造函数，用参数b初始化a数组，用参数size初始化n，size的缺省值是0。
l void insert(int x) ：将x插入到数组a中。
l void show( ) ：输出数组元素个数及数组各元素值。
(3) 在主函数中完毕对该类的测试。定义数组int b[100]，其初值是：{ 1，3，5 }。定义一个InsSort类的对象arr，用数组b及其元素的个数初始化该对象。定义数组int c[100]，其初值是：{ 0，1，2，3，5，8，10 }。然后循环将数组c中的所有元素依次插入到对象arr的成员数组a中。最后输出对象arr中的全体数据成员。程序对的运营后,应输出：
number=10
0, 1, 1, 2, 3, 3, 5, 5, 8, 10

5. 【题目】将两个分别从小到大排列的有序数组a和b复制合并到第3个有序数组c中。m和n分别是数组a和b的元素个数，结果c的元素个数为k。例如a和b数组元素分别为{1，2，2，3，8}和{3，4，7，8}，则结果数组c的值是：{1，2，2，3，3，4，7，8，8}。算法是：将a、b两个数组当作两个队列，比较队首的两个元素，将较小者放入c队列尾部，假如队首的两个元素相等，则先选择a队列首部元素加入c队列尾部。循环执行以上过程，直到a或b队列之一为空，然后将另一个非空队列拷贝到c队列尾部。注意：不允许使用其它算法（如排序算法）。试建立一个类Com，完毕合并工作。
具体规定如下：
(1) 私有数据成员
l int m, n, k ：分别是a，b，c三个数组的元素个数。
l int a[100], b[100], c[100] ：存放a，b，c三个数组的值。
(2) 公有成员函数
l Com(int aa[ ], int m1, int bb[ ], int n1) ：构造函数，用参数初始化a, b数组及其元素个数。 将k初始化为0。
l void combine( ) ：完毕合并工作。
l void show( ) ：将a，b，c三个数组输出，每行输出一个数组。
(3) 在主函数中完毕对该类的测试。定义两个数组int x[100], y[100]，其初值如上。定义一个Com类的对象c，用x、y数组及其元素的个数初始化该对象，然后调用成员函数进行合并及输出工作。程序对的的运营结果如下：
a: 1, 2, 2, 3, 8
b: 3, 4, 7, 8
c: 1, 2, 2, 3, 3, 4, 7, 8, 8

6. [题目]建立一个array类。规定如下：
（1）私有数据成员
·int n：存储数组元素个数。
·int a[100]：存放数组元素。
（2）公有成员函数
·构造函数array(int m,int b[])：初始化数据成员n，a。
·void delsame()：完毕将数组a中相同元素删除工作。
·void print()：将数组以每行5个元素的形式输出到屏幕。
（3）编写一个程序测试该类。在主函数中定义一个数组int b[16]，其初值是{1,2,1,5,3,46,3,4,2,7,6,9,8,6,10}。定义一个array类的对象，用b及数组元素个数初始化该对象，则经删除后a数组的内容为{1,2,5,3,4,6,7,9,8,10}。

7. 【题目】设Δ是集合A上的二元运算，假如对于集合A中的任意元素a和b，都有aΔb=c，且c∈A，则称二元运算Δ对于集合A是封闭的。现有一数组a，假定其数组元素构成集合A。试建立一个类DATA，判断求余运算“%”对集合A是否封闭。即判断数组中的任意两个元素a[i]和a[j]，当a[j]不等于0时，a[i]除以a[j]所得余数仍然属于集合A。具体规定如下：
（1）私有数据成员
l int *a ; 整数指针指向动态分派的数组空间
l int n ; 数组中元素个数
（2）公有成员函数
l DATA(int t[ ], int n1) ; 构造函数，用n1初始化n，并根据n动态生成数组a，用t数组对a数组初始化。
l int belong(int a[ ], int n, int x) ; 判断x的值是否在数组a中，假如在返回1，否则返回0。
l void fun( ) ; 判断求余运算%对本对象是否封闭，假如封闭，输出“封闭”。假如不封闭，则输出“不封闭”，同时输出第一个不满足条件的a[i]和a[j]。
l void print( ) ; 输出成员数据的值。
l ~DATA( ) ; 析构函数，完毕必要的功能。
（3）在主函数中对该类进行测试。先定义两个整型数组d1和d2，分别具有9个元素和8个元素，两个数组的值分别是{1, 3, 22, 4, 15, 2, 7, 5, 0}和{1, 3, 8, 4, 6, 7, 5, 0}。然后用这两个数组初始化两个DATA类的对象test1和test2，测试并输出结果。对的的运营结果如下：
集合: 1 3 22 4 15 2 7 5 0
封闭

集合: 1 3 8 4 6 7 5 0
不封闭：8 3

8. 【题目】编写程序对用户数据进行简朴的管理，规定按姓名的字典顺序对用户信息进行排序。试定义表达用户信息的类person和用户信息解决的类compute实现上述功能。
具体规定如下：
定义类person，其成员如下：
(1) 私有成员
l char name[10],num[10]：分别表达用户的姓名和电话号码。
定义类compute，将类compute声明为类person的友元类，其成员如下：
(1) 私有成员
l person pn[3]：表达3个用户。
(2) 公有成员函数
l void setdata()：通过键盘输入3个用户的数据。
l void sort()：将数组pn表达的用户信息按姓名的字典顺序进行排序。
l void print()：按照指定格式输出用户信息。
在主函数中定义一个compute对象，再通过键盘输入每个用户的基本信息，调用相关成员函数完毕对类compute和person的测试。
输入/输出示例(下划线部分为键盘输入)：
输入姓名和电话号码:
Jeorge 2121212
Mike 34545454
Adam 34676767
排序后用户信息为：
姓名 电话号码
Adam 34676767
Jeorge 32121212
Mike 34545454

9. 【题目】编程将一个二维数组元素变换为逆向存放。即按元素在内存中的物理排列位置，最前面的元素变成最后面的元素，前面第二个元素变成最后倒数第二个元素，依此类推。
如：原始二维数组为：，逆向存放后变为：。
算法提醒：对二维数组进行变换解决时，可以将二维数组当作一维数组来解决。试建立一个类REVARR，完毕上述工作。
具体规定如下：
(1) 私有数据成员
l int a[M][N] ：初始化时，存放原始二维数组。最终，存放逆向存放后的二维数组。
(2) 公有成员函数
l REVARR(int x[M][N]) ：构造函数，用形参x初始化数据成员a。
l void reverse( ) ：按题目规定解决二维数组。
l void show( ) ：按二维方式输出a数组值。
(3) 在主函数中完毕对该类的测试。 在程序的开头，定义符号常数M和N的值分别为3和4，表达数组的行数和列数。在主函数中定义数组int data[M][N]，其初值如上。定义一个REVARR类的对象arr，并用数组data初始化该对象的成员a，输出原数组值；然后调用成员函数逆序存放二维数组，最后输出逆序后的二维数组。

10. 【题目】试定义一个类Array，实现由一个二维数组派生出另一个新二维数组的操作。新数组的行数和列数分别为原数组的列数和行数，且其元素值为原数组中与该元素同序的元素所在行和列的所有元素的平均值。所谓同序元素，是指两个数组中存储顺序相同的两个元素。例如，假设定义两个数组a[4][5],b[5][4]; 数组元素b[1][2]为数组b的第6个元素，则b[1][2]在数组a中的同序元素为a的第6个元素，即a[1][0]。因此，b[1][2]的值为a的第一行第0列所有元素的平均值，即(a[0][0]+ a[1][0]+ a[2][0]+ a[3][0]+ a[1][1] + a[1][2] + a[1][3] + a[1][4])/8(其中a[1][0]不反复使用见输入/输出示例)。
具体规定如下：
(1) 私有成员
l float a[4][5], b[5][4]; 原数组a和派生数组b。
(2) 公有成员
l Array(int t[4][5])：构造函数，用数组t初始化数组a,并将数组b的各元素值置为0。
l void fun()：按题目中的规定计算数组b的各个元素值。
l void print()：按矩阵形式输出数组a和数组b。
(3) 在主函数中定义一个4行5列的二维数组，再运用它初始化一个Array对象，调用相关成员函数完毕对类Array的测试。
输入/输出示例(不涉及椭圆部分)：
数组a:
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
数组b:
6 6.375 6.75 7.125
7.5 8.5 8.875 9.25
9.625 10 11 11.375
11.75 12.125 12.5 13.5
13.875 14.25 14.625 15

11. 【题目】试定义一个学生成绩类Score，实现对学生成绩操作。
具体规定如下：
(1) 私有成员
l No、Name、Math、Phi、Data、ave; 分别表达学号、姓名、数学、物理、数据结构、平均分，数据类型根据数据的性质自定。
(2) 公有成员
l Average()：计算学生平均分。
l Write()：输入学生信息。
l Display()：显示学生信息。
(3) 在主函数中用Score类定义学生成绩对象数组s[3]。用Write()输入学生成绩，用Average()计算每个学生的平均分，最后用Display()显示每个学生的成绩。
实验数据：
No Name Math Phi Data Ave
1001 Zhou 80 70 60
1002 Chen 90 80 85
1003 Wang 70 75 89

【字符串操作】
12. [题目]定义字符串（string）类，完毕对字符串的操作。具体规定如下：
(1) 私有数据成员
l char str[80]; 存放字符串
l int c ; 字符串中字符的个数。
(2) 公有成员函数
l 构造函数WORD (char *s) ： 初始化成员字符串数据str。
l void catstr(string st )：实现将str与st的str内容连接。
l void cpystr(string st )：实现将st的str内容复制到str中。
l void chgstr(string st )：实现将str的内容与st的str内容互换。
l void print ( ) ：屏幕输出字符串。
(3) 在主程序中实现以下功能：
1、设计菜单实现功能选择；
2、字符串的输入与赋值；
3、字符串的运算，涉及：
1）连接 2）复制 3）互换
4、字符串的输出

13. [题目] 建立一个类WORD，记录一个英文字符串中的英文单词个数。字符串中的各英文单词以一个空格符分隔。如字符串“I am a student"中的英文单词个数为4。具体规定如下：
(1) 私有数据成员
l char str[80]
l int c ; 存放字符串str中的英文单词的个数。
(2) 公有成员函数
l 构造函数WORD (char *s) ： 初始化成员字符串数据str。
l void process( )：记录字符串中的英文单词的个数。
l void print ( ) ：屏幕输出字符串及其英文单词数。
(3) 在主程序中对该类进行测试。

使用测试字符串"I think it is going to be a nice day tomorrow"
运营结果：
I think it is going to be a nice day tomorrow
Number : 11

14. 【题目】将字符串中指定的英语单词（字母子串）进行单数变复数的解决，单词之间用非字母分隔。为了简化编程，将单词的单数变复数的规则是：直接在单词后加s。例如单词student的复数为students。例如，有下列字符串：
We are student, you are student, too.
指定单词student，将字符串中所有的student修改为students。解决后的字符串为：
We are students, you are students, too.
试建立一个类Modistr，完毕以上工作。具体规定如下：
(1) 私有数据成员
l char *str ; 存放指定的字符串；
(2) 公有成员函数
l Modistr (char *s) ; 构造函数，动态申请字符串空间，用s所指向的串初始化str；
l void print( ) ; 输出字符串str；
l void modify(char *wordp) ; 将wordp所指向的单词转换为复数。
l ~Modistr ( ) ; 析构函数
(3) 在主函数中完毕对该类的测试。定义类Modistr的对象mys，用字符串“We are student, you are student, too.”初始化mys，调用函数modify(char *)完毕将单词"student"单数变复数的解决。输出变换前和变换后的字符串。

15. [题目] 建立一个类STRING，将一个字符串交叉插入到另一字符串中(假定两字符串等长)。如将字符串“abcde”交叉插入字符串“ABCDE”的结果为“aAbBcCdDeE” 或“AaBbCcDdEe”具体规定如下：
(1) 私有数据成员
l char str1[80]; 被插入的字符串。
l char str2[40]; 字符串str2将被插入到字符串str1中。
(2) 公有成员函数
l 构造函数STRING (char *s1, char *s2) ：初始化成员数据。
l void process( )：将字符串str2插入到字符串str1中。
l void print ( ) ：屏幕输出被插入后的字符串str1。
(3) 在主程序中对该类进行测试。使用测试字符串“”和“abcdefghij”。
运营结果：
str1=a0b1c2d3e4f5g6h7i8j9
str2=abcdefghij

16. 【题目】任意输入一个字符串，串中连续出现的相同元素构成的子序列称为平台，试建立一个类Str，完毕求出串中最长平台的长度。例如：若字符串为"jkkkaabbbbaaa"，则最长平台为"bbbb"，其长度为4。
具体规定如下：
(1) 私有数据成员
l char *str ：指向动态申请的字符串空间。
l int maxlen ：str所指向的字符串中最长平台的长度。
(2) 公有成员函数
l Str(char *p) ：构造函数，动态申请成员str指向的内存空间，用p指向的字符串初始化成员str指向的字符串；置maxlen初始值为0。p缺省为空指针(缺省值为0)。
l ~Str( ) ：释放str所指向的动态内存空间。
l void process ( ) ：求str所指向的字符串中最长平台的长度。
l void show( ) ：输出字符串及最长平台的长度。
(3) 在主函数中完毕对该类的测试。输入一个字符串到字符数组text中，定义一个Str类的对象s，用text初始化对象s，调用成员函数求str所指向字符串中最长平台的长度，输出字符串及其最长平台的长度。可用题例数据作为测试数据。

17. [题目]将一个字符串中的所有与指定字符串相同的子串用另一个字符串替换（查找与替换）。
规定：（1）函数int find(char *s1,char *s2)的功能是判断字符串s1（子串）是否在字符串s2（主串）中出现，若出现，返回出现的起始位置，若未出现，则返回-1。
（2）函数void replace(char *s1,char *s2,int n1,int n2)的功能是将字符串s1中第n1个字符起的n2个字符用字符串s2替换。
（3）在主函数中实现查找与替换工作，并给出替换的次数。例如：主串为 “This book is a very good book.”，假如待替换的子串为“book”且要替换成 “cat”时，替换后的字符串为“This cat is a very good cat.”替换次数为2；假如待替换的子串为“bok”时，因“bok”未在主串中出现，所以，主串不变，替换次数为0。

18. 【题目】试定义一个类Parity，实现字符串的奇偶校验。假设a是由'0'和'1'组成的字符串，为了检测传输过程中也许出现的错误，可以在a中加入奇偶校验码，其方法是把字符串a从左到右按每7个字符一组提成若干组。例如，假设a是由18个字符组成的字符串：
010100
通过度组之后，将a提成以下3(18/7+1)组：
0011001 0001001 0100
在每一组字符的后面加入一个奇偶校验码，即假如某一组中字符'1'的个数为奇数，则加入'1'，反之则加入'0'，上述字符串a加入奇偶校验码后变为：
00110011 00010010 01001
其中下划线部分为新加入的奇偶校验码。
具体规定如下：
(1) 私有成员
l char *a, *b：分别存储原始的字符串以及增长校验码后的字符串。
l int n：存储原始字符串的长度。
(2) 公有成员
l Parity(char *aa, int nn)：构造函数，用aa和nn分别初始化数据成员a和n，并为指针b动态分派n+n/7+2个字节数的内存空间。
l void fun()：为字符串a增长校验码，并将结果存入字符串b中。
l void print()：输出字符串a和b。
l ~Parity()：释放动态分派的内存空间。
(3) 在主函数中定义一个由'0'和'1'组成的字符串，并用其初始化Parity对象，调用相关成员函数完毕对类Parity的测试。
输入/输出示例（输出不含下划线）：
原字符串为：010100
加入校验码后的字符串为：

19. [题目] 建立一个类STR，连接两个字符串后，将结果字符串中的字符排成升序。例如，字符串s1的值为“pear”，字符串s2的值为“apple”，将s1与s2连接后得到字符串“pearapple”，存入字符数组s3，排序后得“aaeelpppr”。具体规定如下：
(1) 私有数据成员

l char s1[40], s2[40] ; 存放两个原始字符串。
l char s3[80] ;存放结果字符串。
(2) 公有成员函数
l STR(char a[ ], char b[ ]) ：构造函数，用字符串参数a和b初始化数据成员字符串s1和s2。
l void consort( ) ：合并字符串后，再对其中的字符排序。
l void show ( ) ：输出两个原始字符串和结果字符串。
(3) 在主程序中定义两个字符数组char a[80],b[80]，任意输入两个字符串，再定义一个STR类对象str，用字符串a和b初始化该对象，然后按上述规定测试该类。可自行输入任意两个字符串做测试数据。

【整数与字符串互相转换】
20. [题目]定义一个字符串类STR，实现依次提取指定字符串中所有连续数字组成的数值。具体规定如下：
（1）私有数据成员
·char *st ; 采用动态存储方式存放字符串。
·int a[20],n; a的元素是st中相邻数字组成的数值，n为a数组的元素个数。
（2）公有成员函数
·STR(char *s) : 构造函数，初始化私有数据成员。
·void fun（）: 功能函数，完毕数值提取工作。
·void print ( ) : 功能函数，输出字符串st及提取出的数据。
·~STR() ; 析构函数，释放动态内存。
（3）编写一个程序测试该类。测试字符串为” 103 anbb18cfg7d3456hiy78j”。
运营结果： str=103 anbb18cfg7d3456hiy78j
a[5]={103,18,7,3456,78}

【进制转换】
21. [题目]建立一个类Plus，实现两个不同进制的正整数相加，参与计算的两个正整数均用字符串表达，若字符串第一个字符为“0”，但第二个字符不为“x”或“X”，则表达八进制数；若前两个字符为“0x”或“0X”，则表达十六进制数，其他情况为十进制数。计算结果用十进制整数表达。具体规定如下：
（1）私有数据成员
·char p1,*p2; p1，p2指向以字符串形式表达的参与加法运算的两个正整数。
·int s; 存储两个正整数相加的结果。
（2） 公有成员函数
·Plus (char *st1, char *st2) ：构造函数，初始化数据成员p1和p2。
·int dec(char *t,int n )：将字符串t表达的n进制数转换为十进制整数，并将结果返回。
·int num(char *t)：拟定字符串t表达的进制后，调用函数dec()将该字符串转换为十进制整数，并将结果返回。
·void pocess()：运用函数num()实现数据成员指向的两个整数的加法运算，结果存入数据成员s中。
·void print ( ) ：按一定格式输出计算结果。
·~Plus ( ) ：析构函数，释放动态分派的存储空间。
（3）在主程序中输入两个字符串（八进制、十进制或十六进制形式），运用其初始化一个Plus对象。调用相关成员函数完毕对类Plus的测试。
输入/输出示例（下划线部分为键盘输入）：
输入两个整数：034 0xA3c
计算结果为：034+0xA3c=28+2620=2648

【运算符重载】
22. [题目]建一个类Set，重载运算符*，实现集合（用数组表达）的交（∩）运算。集合中的元素不能相同。两个集合的交仅包含两个集合中共同存在的。如：集合 s1={1,2,3,4,5,6)，s2={3,5,7,9,11)，则：s1∩s2={3,5}。具体规定如下：
（1）私有数据成员
·double elems[20]; 存放集合中的元素。
·int lens;　　 集合中的元素个数，且lens<=20；空集时值为0。
（2）公有成员函数
·Set(double a[],int n) ; 定义构造函数，给私有数据成员初始化。
·int Inset (double e); 判断e是否在集合elems中，若在，返回1；否则返回0。
·Set operator * (Set); 重载运算符*
·Set operator = (Set &); 重载运算符=
·void print(); //输出向量的各元素值
（3）在主程序中定义一个类Set的对象a，b，c。调用相应函数进行测试。

23. [题目]定义一个描述矩阵的类Array，重载“+”运算符完毕二个矩阵的加法。
具体规定如下：
（1）私有数据成员
·double elems[3][3]; 存放3×3实数矩阵。
（2）公有成员函数
·Array (double a[3][3]) ; 定义构造函数，给私有数据成员初始化。
·Array operator + (Array); 重载运算符+，实现矩阵的加法运算。
·Array operator = (Array &); 重载运算符=，实现矩阵的赋值。
·void print(); 输出3×3实数矩阵。
（3）在主函数中定义矩阵对象a1、a2、a3（测试数据自定），进行矩阵加法a3=a1+a2运算，并输出矩阵a1、a2、a3的所有元素值。

24. [题目]设计一个日期型数据类型Date，实现日期的相关运算。具体规定如下：
（1）私有数据成员
·char day[11]; 存放日期，格式为：yyyy-mm-dd。
（2）公有成员函数
·Date (char *) ; 定义构造函数，给私有数据成员初始化。
·int week() 计算出该日是星期几。
·Date operator + (int); 重载运算符+，实现一个日期与天数相加。
·int operator - (Date); 重载运算符-，两个日期对象相减，返回相隔的天数。
·Date operator = (Date &); 重载运算符=，实现日期赋值。
·int operator == (Date); 重载运算符==，判断两日期对象是否相等，相等返回1，否则返回0。
·void print(); 输出日期。
（3）在主函数中定义日期对象d1、d2、d3，完毕对Date类的测试。
提醒：星期的计算公式为W=(((C/4)-2*C+y+(y/4)+(13*(month+1)/5)+day-1)+700)%7，其中：C为年份的前两位数；y即为年份的后两位数；month为输入日期的月份，day为输入日期的天数。W为0时，是星期天，为1时是星期一......为6是则为星期六。

25. [题目]设计多项式类Polynomial，实现两多项式相加。具体规定如下：
（1）私有数据成员
·double a[10][2]; 存放多项式，包含一个系数和一个指数。例如：2X4的系数为2，指数为4。
·int n; 存放多项式的项数
（2）公有成员函数
·Polynomial (double b[][2],int x) ; 定义构造函数，给私有数据成员初始化。
·Polynomial operator + (Polynomial); 重载运算符+，实现两个多项式相加。
·Polynomial operator += (Polynomial &); 重载运算符+=，实现两个多项式相加赋值。
·Polynomial operator = (Polynomial &); 重载运算符=，实现多项式赋值。
·void print(); 输出多项式。
（3）在主函数中完毕对Polynomial类的测试。

【数的因子计算】
26. 【题目】试定义一个类Test，对给定的正整数n，找出所有分母为n，且大小介于1/4和1/3之间的最简分数(即分子和分母除1外无公因子)。
具体规定如下：
(1) 私有成员
l int n：存放指定满足条件的最简分数的分母。
l int data[20]：存放所有满足条件的分子。
l int num：存放满足条件的最简分数的个数。
(2) 公有成员
l Test(int x)：构造函数，运用x初始化n，将 num置为0。
l int judge(int k)：判断分子k与分母n能否构成最简分数，若是最简分数返回1，否则返回0。
l void process()：求满足条件的分子，并依次存入数组