C++程序设计教程答案

类和对象
01. 分析以下程序执行的结果
#include<iostream.h>
#include<stdlib.h>
class Sample
{
public:
int x,y;
Sample(){x=y=0;}
Sample(int a,int b){x=a;y=b;}
void disp()
{
cout<<"x="<<x<<",y="<<y<<endl;
}
};
void main()
{
Sample s1(2,3);
s1.disp();
}
解：本题说明了重载构造函数的定义方法。

首先定义了一个类Sample,在main()中定义了它的一个对象，定义s1对象时调用其重载构造函数(x=2,y=3)，然后，调用其成员函数输出数据成员。

所以输出为：x=2,y=3。

注意：构造函数是唯一不能被显式调用的成员函数，它在定义类的对象时自动调用，也称为隐式调用。

02. 分析以下程序的执行结果
#include<iostream.h>
class Sample
{
int x,y;
public:
Sample(){x=y=0;}
Sample(int a,int b){x=a;y=b;}
~Sample()
{
if(x==y)
cout<<"x=y"<<endl;
else
cout<<"x!=y"<<endl;
}
void disp()
{
cout<<"x="<<x<<",y="<<y<<endl;
}
};
void main()
{
Sample s1(2,3);
s1.disp();
}
解：本题说明了析构函数的定义方法。

首先定义了一个类Sample,在main()中定义了它的一个对象，定义s1对象时调用其重载构造函数(x=2,y=3)，然后，调用其成员函数输出数据成员，最后在退出程序时自动调用析构函数。

所以输出为：
x=2,y=3
x!=y
注意：析构函数在对象的作用域结束时被自动隐式调用。

03. 分析以下程序的执行结果
#include<iostream.h>
class Sample
{
int x,y;
public:
Sample(){x=y=0;}
Sample(int a,int b){x=a;y=b;}
void disp()
{
cout<<"x="<<x<<",y="<<y<<endl;
}
};
void main()
{
Sample s(2,3), *p=&s;
p->disp();
}
解：本题说明了对象指针的使用方法。

这里通过指向对象的指针来调用对象的成员函数。

对象指针p指向对象s，p->disp()等价于s.disp()。

所以输出为：x=2,y=3。

04. 下面是一个类的测试程序，设计出能使用如下测试程序的类。

void main()
{
Test a;
a.init(68,55);
a.print();
}
其执行结果为：
测试结果：68-55=13
解：本题是要设计Test类，其设计方法很多，这里给出一种解法。

Test类包含两个私有数据成员x、y，以及两个公共成员函数init()和print()，前者用于给数据成员赋值，后者用于x,y的减法运算和输出相应的结果。

#include<iostream.h>
class Test
{
int x,y;
public:
void init(int,int);
void print();
};
void Test::init(int i,int j)
{
x=i;y=j;
}
void Test::print()
{
cout<<"测试结果："<<x<<"-"<<y<<"="<<x-y<<endl;
}
注意：类是一个外壳，它包含了类实例化时数据和代码的使用方法，它是一种模板，只有在定义类的对象时，才为对象分配空间，而不会为类分配空间。

05. 分析以下程序的执行结果
#include<iostream.h>
class Sample
{
public:
Sample();
Sample(int);
~Sample();
void display();
protected:
int x;
};
Sample::Sample()
{
x=0;
cout<<"constructing normally\n";
}
Sample::Sample(int m)
{
x=m;
cout<<"constructing with a number:"<<x<<endl;
}
void Sample::display()
{
cout<<"display a number:"<<x<<endl;
}
Sample::~Sample()
{
cout<<"destructing\n";
}
void main()
{
Sample obj1;
Sample obj2(20);
obj1.display();
obj2.display();
}
解：本题构造函数与析构函数的调用顺序。

这里定义了两个对象，先顺序调用obj1和obj2对象的构造函数，再调用各自的成员函数disp()，最后顺序调用obj2和obj1的析构函数。

所以输出为：
constructing nomally
constructing with a number:20
display a number:0
display a number:20
destructing
destructing
06. 设计一个立方体类Box，它能计算并输出立方体的体积和表面积。

解：Box类包含三个私有数据成员a(立方体边长)、volume(体积)和area(表面积)，另有两个构造函数以及seta()(设置立方体边长)、getvolume()(计算体积)、getarea()(计算表面积)和disp()(输出结果)。

本题程序如下：
#include<iostream.h>
class Box
{
float a;
float volume;
float area;
public:
Box(){}
Box(float r){a=r;}
void seta(float r){a=r;}
void getvolume(){volume=a*a*a;}
void getarea(){area=6*a*a;}
void disp()
{
cout<<"体积："<<volume<<"\t表面积："<<area<<endl;
}
};
void main()
{
Box obj1(4.5),obj2;
obj2.seta(6.4);
obj1.getvolume();
obj1.getarea();
cout<<"obj1=>";
obj1.disp();
obj2.getvolume();
obj2.getarea();
cout<<"obj2=>";
obj2.disp();
}
本程序的执行结果如下：
obj1=>体积：91.125 表面积：121.5
obj2=>体积：262.144 表面积：245.76
07．编写一个程序，在已设置好若干个用户名/口令后，通过输入用户名，查找对应的口令，连续执行这一过程直到用户输入结束标记(“end“)为止。

解：设计一个User类，数据成员有User和pass两个字符数组，存储用户名和口令，另有一个构造函数和getuaer()、getpass()两个成员函数，用于获取用户名和口令。

在main()中设计一个对象数组ua,当用户输入一个用户名后，在ua中查找，找到后输出对应的口令，找不到时输出相应的提示信息。

本题程序如下：
#include<iostream.h>
#include<string.h>
class User
{
char user[10];
char pass[7];
public:
User(char [],char []);
char *getuser();
char *getpass();
};
User::User(char u[],char p[])
{
strcpy(user,u);
strcpy(pass,p);
}
char *User::getuser()
{
return user;
}
char *User::getpass()
{
return pass;
}
void main()
{
User ua[]={User("Li","123456"),User("wang","654321"),
User("Chen","213412"),User("Xu","878616"),
User("Ma","876574"),User("Song","666666")};
char name[10];
while(1)
{
cout<<"输入用户名：";
cin>>name;
if(strcmp(name,"end")==0)
break;
for(int i=0;i<6;i++)
if(strcmp(name,ua[i].getuser())==0)
{
cout<<" 用户口令："<<ua[i].getpass()<<endl;
break;
}
if(i==6)
cout<<" 用户名不存在"<<endl;
}
}
本程序的执行结果如下：
输入用户名：Li
用户口令：123456
输入用户名：Wang
用户口令：654321
输入用户名：He
用户名不存在
输入用户名：end
08．编写一个程序，输入N个学生数据，包括学号、姓名、成绩，要求只输出成绩在80~89分的学生数据。

解：设计一个学生类Stud,包括no(学号)、name(姓名)和deg(成绩)数据成员，另有两个普通成员函数setdata()和disp()，前者用于设置对象数据，后者用于只输出成绩在80~89分数段的学生数据。

在main()函数中定义了一个对象数组，用于存储输入的学生数据。

本题程序如下：
#include<iostream.h>
#include<iomanip.h>
#include<string.h>
#define N 3
class Stud
{
int no;
char name[10];
int deg;
public:
void setdata(int n,char na[],int d)
{
no=n; deg=d;
strcpy(name,na);
}
void disp()
{
if(deg>=80&&deg<=89)
cout<<setw(4)<<no<<setw(9)<<name<<setw(7)<<deg<<endl;
}
};
void main()
{
Stud st[N];
int i,n,d;
char na[10];
for(i=0;i<N;i++)
{
cout<<"输入学号姓名成绩：";
cin>>n>>na>>d;
st[i].setdata(n,na,d);
}
cout<<"输出数据\n";
cout<<" 学号姓名成绩\n";
for(i=0;i<N;i++)
st[i].disp();
}
本程序执行结果如下：
输入学号姓名成绩：1 stud1 78
输入学号姓名成绩：2 stud2 85
输入学号姓名成绩：3 stud3 89
输出数据
学号姓名成绩
2 stud2 85
3 stud3 89
09. 有10个单词存放在一维字符数组words中，编写一个程序，根据用户的输入，找出所有与之从前向后匹配的单词和个数。

解：设计一个Word类，包含一个私有数据成员words、一个构造函数和一个公有成员函数lookup()，构造函数用于给words赋初值，lookup()用于找出所有与之从前向后匹配的单词和个数。

本题程序如下：
#include <iostream.h>
#include <string.h>
class Word{
char words[10][12];
public:
Word() //构造函数给words赋初值
{
strcpy(words[0],"elapse");
strcpy(words[1],"elucidate");
strcpy(words[2],"elude");
strcpy(words[3],"embody");
strcpy(words[4],"embrace");
strcpy(words[5],"embroider");
strcpy(words[6],"emrtge");
strcpy(words[7],"emphasize");
strcpy(words[8],"empower");
strcpy(words[9],"emulate");
}
void lookup(char s[]); //查找函数
};
void Word::lookup(char s[]) //找出所有与之从前向后匹配的单词和个数
{
int i,n=0; //n用来记录相匹配的单词个数
int k=strlen(s);
cout << "匹配的单词:\n";
for (i=0;i<10;i++) //依次与每个单词匹配
{
if (strncmp(s,words[i],k)==0) //匹配成功
{
n++;
cout << "\t" << words[i] << "\n";
}
}
cout << "匹配的单词个数：" << n << "\n\n";
}
void main()
{
Word obj;
char str[12];
cout << "输入单词：";
cin >> str;
obj.lookup(str);
}
本程序的执行结果如下：
输入单词：em 回车
匹配的单词：
embody
embrace
emembroider
emrtge
emphasize
empower
emulate
相匹配的单词个数：7
10. 编写一个程序，统计学生成绩，其功能包括输入学生的姓名和成绩，按成绩从高到低排列打印输出，对前%70的学生定为合格(PASS)，而后30%的学生定为不合格(FAIL)
解：设计一个类student,包含学生的姓名和成绩等数据，以及setname()、setdeg()、getname()、和getdeg()等四个成员函数。

设计一个类compute，包含两个私有数据成员，即学生人数ns 和student类的对象组na[]，另有三个公共成员函数getdata()、sort()、disp()，它们分别用于获取数据、按成绩排序和输出数据。

本题程序如下：
#include<iostream.h>
#include<string.h>
#define N 10
class student
{
char name[10]; //姓名
int deg; //成绩
public:
void setname(char na[]) { strcpy(name,na); }
char *getname() { return name; }
void setdeg(int d) { deg=d; }
int getdeg() { return deg; }
};
class compute
{
int ns; //学生人数
student na[N]; //student类的对象数组
public:
void getdata(); //获取数据
void sort(); //按成绩排序
void disp(); //输出数据
};
void compute::getdata()
{
int i,tdeg;
char tname[10];
cout << "输入学生人数：";
cin >> ns;
cout << " 输入学生姓名和成绩：\n";
for(i=0;i<ns;i++)
{
cin >> tname >> tdeg;
na[i].setname(tname);
na[i].setdeg(tdeg);
}
cout << endl;
}
void compute::sort()
{
int i,j,pick;
student temp;
for(i=0;i<ns-1;i++)
{
pick=i;
for(j=i+1;j<ns;j++)
{
if(na[j].getdeg()>na[pick].getdeg())
pick=j;
}
temp=na[i];
na[i]=na[pick];
na[pick]=temp;
}
}
void compute::disp()
{
int cutoff,i;
cout << "\n输出结果\n\n";
cout << "姓名\t成绩\t合格否\n";
cout << "---------------------\n";
cutoff=ns*7/10-1;
for(i=0;i<ns;i++)
{
cout << na[i].getname() << '\t' << na[i].getdeg();
if(i<=cutoff)
cout << "\tPASS\n";
else
cout << "\tFIAL\n";
}
cout << endl;
}
void main()
{
compute obj;
obj.getdata();
obj.sort();
obj.disp();
}
本程序的执行结果如下：
输入学生人数：10
输入学生姓名和成绩：
st1 67 st2 80 st3 90 st4 56 st5 88 st6 75 st7 46 st8 90 st9 66 st10 89
输出结果
姓名成绩合格否
------ ------ --------
st3 90 PASS
st8 90 PASS
st10 89 PASS
st5 88 PASS
st2 80 PASS
st6 75 PASS
st1 67 PASS
st9 66 FAIL
st4 56 FAIL
st7 46 FAIL
11. 编写一个程序，输入用户的姓名和电话号码，按姓名的词典顺序排列后，输出用户的姓名和电话号码。

解：设计一个类person，包含学生的姓名和电话号码等数据，以及setname()、setnum()、getname()和getnum()等四个成员函数。

设计一个类compute，包含一个私有数据成员，即person类的对象数组pn[]，另有三个公共成员函数getdata()、sort()、disp()，它们分别用于获取数据、按姓名的词典顺序排序和输出数据。

本题程序如下：
#include<iostream.h>
#include<string.h>
#define N 5
class person
{
char name[10]; //姓名
char num[10]; //电话号码
public:
void setname(char na[]) { strcpy(name,na); }
void setnum(char nu[]) { strcpy(num,nu); }
char *getname() { return name; }
char *getnum() { return num; }
};
class compute
{
person pn[N]; //person类的对象数组
public:
void getdata(); //获取数据
void getsort(); //按姓名的词典顺序排序
void outdata(); //输出数据
};
void compute::getdata()
{
int i;
char na[10],nu[10];
cout << "输入姓名和电话号码：\n";
for(i=0;i<N;i++)
{
cout << " 第" << i+1 << "个人：";
cin >> na >> nu;
pn[i].setname(na);
pn[i].setnum(nu);
}
}
void compute::getsort()
{
int i,j,k;
person temp;
for(i=0;i<N-1;i++)
{
k=i;
for(j=i+1;j<N;j++)
if(strcmp(pn[k].getname(),pn[j].getname())>0)
k=j;
temp=pn[k];
pn[k]=pn[i];
pn[i]=temp;
}
}
void compute::outdata()
{
int i;
cout << "\n输出结果：\n\n";
cout << "姓名\t电话号码\n";
cout << "-------------------\n";
for(i=0;i<N;i++)
cout << pn[i].getname() << '\t' << pn[i].getnum() << endl;
cout << endl;
}
void main()
{
compute obj;
obj.getdata();
obj.getsort();
obj.outdata();
}
本程序的执行结果如下：
输入姓名和电话号码：
第1个人：Li 87653781
第2个人：Zheng 98356312
第3个人：Ma 87867405
第4个人：Chen 86888882
第5个人：Xu 87862345
输出结果
姓名电话号码
Chen 86888882
Li 87653781
Ma 87863705
Xu 87862345
Zheng 98356312
12. 分析以下程序的执行结果
#include<iostream.h>
class Sample
{
int n;
static int sum;
public:
Sample(int x){n=x;}
void add(){sum+=n;}
void disp()
{
cout<<"n="<<n<<",sum="<<sum<<endl;
}
};
int Sample::sum=0; // 静态数据成员赋初值：数据类型类名::静态数据成员名=值
void main()
{
Sample a(2),b(3),c(5);
a.add();
a.disp();
b.add();
b.disp();
c.add();
c.disp();
}
解：本题说明静态数据成员的使用方法。

在类中定义了一个静态数据成员sum，在main()之前给它赋初值0，必须进行初始化；然后在main()中定义了三个对象，并执行各自的add()和disp()方法。

所以输出为：
n=2,sum=2
n=3,sum=5
n=5,sum=10
注意：静态数据成员脱离具体的对象独立存在，其存储单元不是任何对象存储空间的一部分，但逻辑上所有对象都共享这一存储单元，对静态数据成员的任何操作都会访问这一存储单元，从而影响这一存储单元的所有对象。

所以说静态数据成员不是对象成员，在引用时不需要用对象名，采用如下格式：类名::静态数据成员名。

13. 分析以下程序执行的结果
#include<iostream.h>
class Sample
{
int A;
static int B;
public:
Sample(int a){A=a,B+=a;}
static void func(Sample s);
};
void Sample::func(Sample s)
{
cout<<"A="<<s.A<<",B="<<B<<endl;
}
int Sample::B=0; // 静态数据成员赋初值
void main()
{
Sample s1(2),s2(5);
Sample::func(s1); // 调用静态成员函数：类名::静态成员函数名(参数表)
Sample::func(s2);
}
解：本题说明了静态成员函数的使用方法。

其中的数据成员B是静态数据成员，求B之值是在构造函数中进行的。

所以输出为：
A=2,B=7
A=5,B=7
注意：静态成员函数与静态数据成员一样，也不是对象成员，是类的成员。

静态成员函数的调用不同于普通的成员函数。

在静态成员函数的实现中，引用类的非静态数据成员是通过对象进行的，如本题中s.A，引用类的静态数据成员是直接进行的，如本题中的B。

14. 编写一个程序，输入N个学生数据，包括学号、姓名、成绩，要求输出这些学生数据并计算平均分。

解：设计一个学生类Stud，除了包括no(学号)、name(姓名)和deg(成绩)数据成员外，有两个静态变量sum和num，分别存放总分和人数，另有两个普通成员函数setdata()和disp()，分别用于给数据成员赋值和输出数据成员的值，另有一个静态成员函数avg()，它用于计算平均分。

在main()函数中定义了一个对象数组用于存储输入的学生数据。

本题程序如下：
#include<iostream.h>
#include<string.h>
#define N 3
class Stud
{
int no;
char name[10];
int deg;
static int num;
static int sum;
public:
void setdata(int n,char na[],int d)
{
no=n; deg=d;
strcpy(name,na);
sum+=d;
num++;
}
static double avg()
{
return sum/num;
}
void disp()
{
cout<<no<<'\t'<<name<<'\t'<<deg<<'\n';
}
};
int Stud::sum=0;
int Stud::num=0;
void main()
{
Stud st[N];
int i,n,d;
char na[10];
for(i=0;i<N;i++)
{
cout<<"输入学号姓名成绩：";
cin>>n>>na>>d;
st[i].setdata(n,na,d);
}
cout<<"\n输出数据\n";
cout<<"学号\t姓名\t成绩\n";
for(i=0;i<N;i++)
st[i].disp();
cout<<"\n\t平均分="<<Stud::avg()<<endl;
}
本程序的执行结果如下：
输入学号姓名成绩：1 stud1 89
输入学号姓名成绩：2 stud2 78
输入学号姓名成绩：3 stud3 84
输出数据
学号姓名成绩
1 stud1 89
2 stud2 78
3 stud3 84
平均分=83。