【程序设计与算法（三）】测验和作业题部分答案汇总（面向对象篇）
题目来源：程序设计与算法（三）测验和作业题汇总
目录
- 001:简单的swap
- 002:难一点的swap
- 003:好怪异的返回值
- 004:神秘的数组初始化
- 005:编程填空：学生信息处理程序
- 006:奇怪的类复制
- 007:返回什么才好呢
- 008:超简单的复数类
- 009:哪来的输出
- 010:返回什么才好呢
- 011:Big & Base 封闭类问题
- 012:这个指针哪来的
- 013:魔兽世界之一：备战
- 014:MyString
- 015:看上去好坑的运算符重载
- 016:惊呆！Point竟然能这样输入输出
- 017:二维数组类
- 018:别叫，这个大整数已经很简化了!
- 019:全面的MyString
- 020:继承自string的MyString
- 021:魔兽世界之二：装备
- 022:看上去像多态
- 023:Fun和Do
- 024:这是什么鬼delete
- 025:怎么又是Fun和Do
- 026:编程填空：统计动物数量
001:简单的swap
#include <iostream>
using namespace std;
class A
{
public:
int x;
int getX() { return x; }
};
void swap(A &a, A &b)
{
int tmp = a.x;
a.x = b.x;
b.x = tmp;
}
int main()
{
A a,b;
a.x = 3;
b.x = 5;
swap(a,b);
cout << a.getX() << "," << b.getX();
return 0;
}
输出：
5,3
002:难一点的swap
#include <iostream>
using namespace std;
void swap(int *&a, int *&b)
{
int * tmp = a;
a = b;
b = tmp;
}
int main()
{
int a = 3,b = 5;
int * pa = & a;
int * pb = & b;
swap(pa,pb);
cout << *pa << "," << * pb;
return 0;
}
输出：
5,3
003:好怪异的返回值
#include <iostream>
using namespace std;
// 当函数引用时，函数可用作左值
// 函数的返回类型决定函数调用是否是左值，当调用一个返回引用的函数得到左值，其他返回类型得到右值
int &getElement (int * a, int i)
{
return a[i]; // 返回对a[i]的引用
}
int main()
{
int a[] = {1,2,3};
getElement(a,1) = 10;
cout << a[1] ;
return 0;
}
输出：
10
004:神秘的数组初始化
#include <iostream>
using namespace std;
int main()
{
int * a[] = {NULL, NULL, new int, new int[6]};
*a[2] = 123;
a[3][5] = 456;
if(! a[0] ) {
cout << * a[2] << "," << a[3][5];
}
return 0;
}
输出：
123,456
005:编程填空：学生信息处理程序
描述：实现一个学生信息处理程序，计算一个学生的四年平均成绩。
要求实现一个代表学生的类，并且类中所有成员变量都是【私有的】。
补充下列程序中的 Student 类以实现上述功能。
#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <sstream>
#include <cstdlib>
using namespace std;
class Student {
// 在此处补充你的代码
};
int main() {
Student student; // 定义类的对象
student.input(); // 输入数据
student.calculate(); // 计算平均成绩
student.output(); // 输出数据
}
输入：输入数据为一行，包括：姓名,年龄,学号,第一学年平均成绩,第二学年平均成绩,第三学年平均成绩,第四学年平均成绩。其中姓名为由字母和空格组成的字符串（输入保证姓名不超过20个字符，并且空格不会出现在字符串两端），年龄、学号和学年平均成绩均为非负整数。信息之间用逗号隔开。
Tom Hanks,18,7817,80,80,90,70
输出：输出一行数据，包括：姓名,年龄,学号,四年平均成绩。信息之间用逗号隔开。
Tom Hanks,18,7817,80
题解：
#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <sstream>
#include <cstdlib>
using namespace std;
class Student {
private:
char c;
char name[20];
int age;
int num;
int grade[5];
double ave;
public:
void input()
{
cin.getline(name,20,',');
cin>>age>>c>>num>>c>>grade[1]>>c>>grade[2]>>c>>grade[3]>>c>>grade[4];
}
void calculate()
{
ave=(double)(grade[1]+grade[2]+grade[3]+grade[4])/4;
}
void output()
{
cout<<name<<","<<age<<","<<num<<","<<ave;
}
};
int main() {
Student student; // 定义类的对象
student.input(); // 输入数据
student.calculate(); // 计算平均成绩
student.output(); // 输出数据
}
006:奇怪的类复制
只有在初始化对象的时候，才会调用构造函数或复制构造函数！
#include <iostream>
using namespace std;
class Sample {
public:
int v;
// 在此处补充你的代码
Sample (int x = 0): v(x) {} //类型隐式转换构造函数
Sample (const Sample &o){
v = o.v + 2;
}
};
void PrintAndDouble(Sample o) // 形参作为实参时，会调用复制构造函数
{
cout << o.v;
cout << endl;
}
int main()
{
Sample a(5);
Sample b = a; // 调用复制构造函数，是初始化语句
PrintAndDouble(b); // 调用复制构造函数
Sample c = 20; // 20转换为临时对象，调用类型转换构造函数，是初始化语句
PrintAndDouble(c); // 调用复制构造函数
Sample d;
d = a; // 不会调用复制构造函数，因为d已经初始化定义过了，是赋值语句
cout << d.v;
return 0;
}
输出：
9
22
5
007:返回什么才好呢
#include <iostream>
using namespace std;
class A {
public:
int val;
A(int v = 123): val(v) {} // 类型转换构造函数
A &GetObj(){
return *this;
}
};
int main()
{
int m,n;
A a;
cout << a.val << endl;
while(cin >> m >> n) {
a.GetObj() = m; // m转换为临时对象
cout << a.val << endl;
a.GetObj() = A(n);
cout << a.val<< endl;
}
return 0;
}
输入：多组数据，每组一行，是整数 m 和 n
2 3
4 5
输出：先输出一行：123，然后，对每组数据，输出两行，第一行是m,第二行是n
123
2
3
4
5
008:超简单的复数类
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
class Complex {
private:
double r,i;
public:
void Print() {
cout << r << "+" << i << "i" << endl;
}
Complex(char *s=" ")
{
r=s[0]-'0';
i=s[2]-'0';
}
};
int main() {
Complex a;
a = "3+4i"; a.Print();
a = "5+6i"; a.Print();
return 0;
}
输出：
3+4i
5+6i
009:哪来的输出
#include <iostream>
using namespace std;
class A {
public:
int i;
A(int x) { i = x; }
// 在此处补充你的代码
~A(){
cout << i << endl;
}
};
int main()
{
A a(1);
A * pa = new A(2);
delete pa;
return 0;
}
输出：
2
1
010:返回什么才好呢
（与007相同，略）
011:Big & Base 封闭类问题
#include <iostream>
#include <string>
using namespace std;
class Base {
public:
int k;
Base(int n):k(n) { }
};
class Big
{
public:
int v;
Base b;
// 在此处补充你的代码
Big(int n):v(n), b(v) { }
};
int main()
{
int n;
while(cin >>n) {
Big a1(n);
Big a2 = a1;
cout << a1.v << "," << a1.b.k << endl;
cout << a2.v << "," << a2.b.k << endl;
}
}
输入：多组数据，每组一行，是一个整数
3
4
输出：对每组数据，输出两行，每行把输入的整数打印两遍
3,3
3,3
4,4
4,4
012:这个指针哪来的
#include <iostream>
using namespace std;
struct A
{
int v;
A(int vv):v(vv) { }
// 在此处补充你的代码
const A *getPointer() const{ // 常量成员函数不能修改成员变量，返回值既可以是常量，也可以是变量
return this;
}
};
int main()
{
const A a(10);
const A * p = a.getPointer(); // 常量对象只能调用常量成员函数
cout << p->v << endl;
return 0;
}
输出：
10
013:魔兽世界之一：备战
014:MyString
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
class MyString {
char * p;
public:
MyString(const char * s) {
if(s) {
p = new char[strlen(s) + 1];
strcpy(p, s);
}
else
p = NULL;
}
~MyString() {
if(p) delete [] p;
}
// 在此处补充你的代码
// 深拷贝
void Copy (const char * s){
if(s) {
p = new char[strlen(s) + 1];
strcpy(p, s);
}
else
p = NULL;
}
// 深拷贝
MyString (const MyString &o){
if(o.p) {
p = new char[strlen(o.p) + 1];
strcpy(p, o.p);
}
else
p = NULL;
}
// 深拷贝
MyString &operator = (const MyString &o){
if (p == o.p)
return *this;
if (p)
delete [] p;
if(o.p) {
p = new char[strlen(o.p) + 1];
strcpy(p, o.p);
}
else
p = NULL;
return *this;
}
// 重载输出流
friend ostream & operator << (ostream &out, const MyString &o){
out << o.p;
return out;
}
};
int main()
{
char w1[200], w2[100];
while(cin >> w1 >> w2) {
MyString s1(w1), s2 = s1; // 需要实现深拷贝
MyString s3(NULL);
s3.Copy(w1);
cout << s1 << "," << s2 << "," << s3 << endl;
s2 = w2;
s3 = s2;
s1 = s3;
cout << s1 << "," << s2 << "," << s3 << endl;
}
}
输入：多组数据，每组一行，是两个不带空格的字符串
abc def
123 456
输出：对每组数据，先输出一行，打印输入中的第一个字符串三次，然后再输出一行，打印输入中的第二个字符串三次
abc,abc,abc
def,def,def
123,123,123
456,456,456
015:看上去好坑的运算符重载
#include <iostream>
using namespace std;
class MyInt
{
int nVal;
public:
MyInt(int n) { nVal = n ;}
// 在此处补充你的代码
MyInt &operator - (int n){ // 运算符重载为成员函数时，参数个数要比运算符目数少1
this->nVal -= n;
return *this;
}
operator int (){ // 重载类型强制转换运算符
return this->nVal;
}
};
int Inc(int n) {
return n + 1;
}
int main () {
int n;
while(cin >> n) {
MyInt objInt(n);
objInt - 2 - 1 - 3;
cout << Inc(objInt);
cout << ",";
objInt - 2 - 1;
cout << Inc(objInt) << endl;
}
return 0;
}
输入：多组数据，每组一行，整数n
20
30
输出：对每组数据，输出一行，包括两个整数， n-5和n-8
15,12
25,22
016:惊呆！Point竟然能这样输入输出
#include <iostream>
using namespace std;
class Point {
private:
int x;
int y;
public:
Point() { };
// 在此处补充你的代码
friend istream &operator >> (istream &in, Point &p){
in >> p.x >> p.y;
return in;
}
friend ostream &operator << (ostream &out, const Point &p){
out << p.x << "," << p.y;
return out;
}
};
int main()
{
Point p;
while(cin >> p) {
cout << p << endl;
}
return 0;
}
输入：多组数据，每组两个整数
2 3
4 5
输出：对每组数据，输出一行，就是输入的两个整数
2,3
4,5
017:二维数组类
#include <iostream>
#include <cstring>
using namespace std;
class Array2 {
// 在此处补充你的代码
private:
int row;
int col;
int data[10][10];
public:
Array2 (int r = 0, int c = 0): row(r), col(c) {}
// 应付 a[i][j]
int *operator [] (const int i){
return this->data[i];
}
// 应付 a(i, j)
int operator () (int i, int j){
return this->data[i][j];
}
// 应付 b = a
Array2 &operator = (Array2 &x){
this->row = x.row;
this->col = x.col;
for(int i = 0; i < x.row; i++)
for(int j = 0; j < x.col; j++)
this->data[i][j] = x.data[i][j];
return *this;
}
};
int main() {
Array2 a(3,4);
int i, j;
for( i = 0; i < 3; ++i )
for( j = 0; j < 4; j ++ )
a[i][j] = i * 4 + j;
for( i = 0;i < 3; ++i ) {
for( j = 0; j < 4; j ++ ) {
cout << a(i, j) << ",";
}
cout << endl;
}
cout << "next" << endl;
Array2 b; b = a;
for( i = 0; i < 3; ++i ) {
for( j = 0; j < 4; j ++ ) {
cout << b[i][j] << ",";
}
cout << endl;
}
return 0;
}
输出：
0,1,2,3,
4,5,6,7,
8,9,10,11,
next
0,1,2,3,
4,5,6,7,
8,9,10,11,
018:别叫，这个大整数已经很简化了!
（提示：使用高精度算法）
019:全面的MyString
#include <cstdlib>
#include <iostream>
using namespace std;
int strlen (const char * s)
{ int i = 0;
for (; s[i]; ++i);
return i;
}
void strcpy (char * d, const char * s)
{
int i = 0;
for (i = 0; s[i]; ++i)
d[i] = s[i];
d[i] = 0;
}
int strcmp (const char * s1, const char * s2)
{
for (int i = 0; s1[i] && s2[i]; ++i) {
if (s1[i] < s2[i])
return -1;
else if (s1[i] > s2[i])
return 1;
}
return 0;
}
void strcat (char * d, const char * s)
{
int len = strlen(d);
strcpy(d + len, s);
}
class MyString
{
// 在此处补充你的代码
private:
char *str;
public:
// 构造函数
MyString (char *s = NULL){
if (s) {
str = new char[strlen(s) + 1];
strcpy(str, s);
}
else
str = NULL;
}
// 复制构造函数（深拷贝）
MyString (const MyString &s){
if (s.str) {
str = new char[strlen(s.str) + 1];
strcpy(str, s.str);
}
else
str = NULL;
}
// 析构函数
~MyString () {
delete [] str;
}
// 重载运算符 =（深拷贝）
MyString &operator = (const MyString &s){
if (s.str == str)
return *this;
if (str)
delete [] str;
if (s.str) {
str = new char[strlen(s.str) + 1];
strcpy(str, s.str);
}
else
str = NULL;
return *this;
}
// 重载运算符 + (MyString + MyString, MyString + constant)
MyString operator + (const MyString &s){
if (str && s.str) {
char *result = new char[strlen(s.str) + strlen(str) + 1];
strcpy(result, str);
strcat(result, s.str);
return MyString(result);
}
else if (!str && s.str) {
str = new char[strlen(s.str) + 1];
strcpy(str, s.str);
return *this;
}
else
return *this;
}
// 重载运算符 + (constant + MyString)
friend MyString operator + (char *p, MyString &s){
if (p && s.str) {
char *result = new char[strlen(s.str) + strlen(p) + 1];
strcpy(result, p);
strcat(result, s.str);
return MyString(result);
}
else if (p && !s.str) {
s.str = new char[strlen(p) + 1];
strcpy(s.str, p);
return s;
}
else
return s;
}
// 重载运算符 += (MyString += MyString, MyString += constant)
void operator += (const MyString &s){
if (str && s.str) {
char *result = new char[strlen(s.str) + strlen(str) + 1];
strcpy(result, str);
strcat(result, s.str);
str = result;
}
else if (!str && s.str) {
str = new char[strlen(s.str) + 1];
strcpy(str, s.str);
}
}
// 重载运算符 <
bool operator < (const MyString &s){
return (strcmp(str, s.str) == -1);
}
// 重载运算符 >
bool operator > (const MyString &s){
return (strcmp(str, s.str) == 1);
}
// 重载运算符 ==
bool operator == (const MyString &s){
return (strcmp(str, s.str) == 0);
}
// 重载下标 []
char &operator [] (int i){
return str[i];
}
// 函数对象
MyString operator () (int begin, int len){
int i, j;
char *result = new char[len+1];
for (i = begin, j = 0; i < begin+len; ++i, ++j)
result[j] = str[i];
result[j] = 0;
return MyString(result);
}
// 重载输出流 <<
friend ostream &operator << (ostream &out, const MyString &s){
if (s.str != NULL)
out << s.str;
else
out << "";
return out;
}
};
int CompareString(const void * e1, const void * e2)
{
MyString * s1 = (MyString * ) e1;
MyString * s2 = (MyString * ) e2;
if(*s1 < *s2)
return -1;
else if (*s1 == *s2)
return 0;
else if (*s1 > *s2)
return 1;
}
int main()
{
MyString s1("abcd-"), s2, s3("efgh-"), s4(s1);
MyString SArray[4] = {"big", "me", "about", "take"};
cout << "1. " << s1 << s2 << s3 << s4 << endl;
s4 = s3;
s3 = s1 + s3;
cout << "2. " << s1 << endl;
cout << "3. " << s2 << endl;
cout << "4. " << s3 << endl;
cout << "5. " << s4 << endl;
cout << "6. " << s1[2] << endl;
s2 = s1;
s1 = "ijkl-";
s1[2] = 'A' ;
cout << "7. " << s2 << endl;
cout << "8. " << s1 << endl;
s1 += "mnop";
cout << "9. " << s1 << endl;
s4 = "qrst-" + s2;
cout << "10. " << s4 << endl;
s1 = s2 + s4 + " uvw " + "xyz";
cout << "11. " << s1 << endl;
qsort(SArray, 4, sizeof(MyString), CompareString);
for( int i = 0; i < 4;i ++ )
cout << SArray[i] << endl;
// s1的从下标0开始长度为4的子串
cout << s1(0, 4) << endl;
// s1的从下标5开始长度为10的子串
cout << s1(5, 10) << endl;
return 0;
}
输出：
1. abcd-efgh-abcd-
2. abcd-
3.
4. abcd-efgh-
5. efgh-
6. c
7. abcd-
8. ijAl-
9. ijAl-mnop
10. qrst-abcd-
11. abcd-qrst-abcd- uvw xyz
about
big
me
take
abcd
qrst-abcd-
020:继承自string的MyString
（略）
021:魔兽世界之二：装备
022:看上去像多态
#include <iostream>
using namespace std;
class B {
private:
int nBVal;
public:
void Print() {
cout << "nBVal="<< nBVal << endl;
}
void Fun() {
cout << "B::Fun" << endl;
}
B (int n) {
nBVal = n;
}
};
// 在此处补充你的代码
class D: public B{
private:
int nDVal;
public:
void Print() {
B::Print();
cout << "nDVal="<< nDVal << endl;
}
void Fun() {
cout << "D::Fun" << endl;
}
D (int n): B(n * 3){
nDVal = n;
}
};
int main() {
B * pb;
D * pd;
D d(4);
d.Fun();
pb = new B(2);
pd = new D(8);
pb->Fun();
pd->Fun();
pb->Print();
pd->Print();
pb = & d;
pb->Fun();
pb->Print();
return 0;
}
输出：
D::Fun
B::Fun
D::Fun
nBVal=2
nBVal=24
nDVal=8
B::Fun
nBVal=12
023:Fun和Do
#include <iostream>
using namespace std;
class A {
private:
int nVal;
public:
void Fun()
{ cout << "A::Fun" << endl; };
void Do()
{ cout << "A::Do" << endl; }
};
class B:public A {
public:
virtual void Do()
{ cout << "B::Do" << endl;}
};
class C:public B {
public:
void Do( )
{ cout <<"C::Do"<<endl; }
void Fun()
{ cout << "C::Fun" << endl; }
};
void Call(B &p) {
p.Fun(); // B类没有Fun，先调用基类（A类）的同名成员函数
p.Do(); // 多态，调用哪个Do，取决于p引用了哪个类的对象
}
int main() {
C c;
Call(c);
return 0;
}
输出：
A::Fun
C::Do
024:这是什么鬼delete
#include <iostream>
using namespace std;
class A
{
public:
A() { }
// 在此处补充你的代码
virtual ~A() { cout << "destructor A" << endl; }
};
class B:public A {
public:
~B() { cout << "destructor B" << endl; }
};
int main()
{
A * pa;
pa = new B; // 先调用构造函数A，再调用构造函数B
delete pa; // 先调用虚析构函数B，再调用虚析构函数A（若没有加virtual，则只会调用析构函数A）
return 0;
}
输出：
destructor B
destructor A
025:怎么又是Fun和Do
#include <iostream>
using namespace std;
class A {
private:
int nVal;
public:
void Fun()
{ cout << "A::Fun" << endl; };
virtual void Do()
{ cout << "A::Do" << endl; }
};
class B:public A {
public:
virtual void Do()
{ cout << "B::Do" << endl;}
};
class C:public B {
public:
void Do( )
{ cout <<"C::Do"<<endl; }
void Fun()
{ cout << "C::Fun" << endl; }
};
void Call(A *p) {
p->Fun(); // p指向A时，A::Fun被调用；// p指向C时，由于是基类（A类）指针，Fun不是虚函数，所以A::Fun被调用
p->Do(); // p指向A时，A::Do被调用； // p指向C时，由于是基类（A类）指针，且Do是虚函数，多态，所以C::Do被调用
}
int main() {
Call(new A());
Call(new C());
return 0;
}
输出：
A::Fun
A::Do
A::Fun
C::Do
026:编程填空：统计动物数量
描述：代码填空，使得程序能够自动统计当前各种动物的数量
#include <iostream>
using namespace std;
// 在此处补充你的代码
void print() {
cout << Animal::number << " animals in the zoo, " << Dog::number << " of them are dogs, " << Cat::number << " of them are cats" << endl;
}
int main() {
print();
Dog d1, d2;
Cat c1;
print();
Dog* d3 = new Dog();
Animal* c2 = new Cat;
Cat* c3 = new Cat;
print();
delete c3;
delete c2;
delete d3;
print();
}
输出：
0 animals in the zoo, 0 of them are dogs, 0 of them are cats
3 animals in the zoo, 2 of them are dogs, 1 of them are cats
6 animals in the zoo, 3 of them are dogs, 3 of them are cats
3 animals in the zoo, 2 of them are dogs, 1 of them are cats
题解：
#include <iostream>
using namespace std;
class Animal{
public:
static int number;
Animal(){number++;}
virtual ~Animal(){number--;}
};
class Dog:public Animal
{
public:
static int number;
Dog(){number++;}
~Dog(){number--;}
};
class Cat:public Animal
{
public:
static int number;
Cat(){number++;}
~Cat(){number--;}
};
int Dog::number = 0;
int Cat::number = 0;
int Animal::number = 0;
void print() {
cout << Animal::number << " animals in the zoo, " << Dog::number << " of them are dogs, " << Cat::number << " of them are cats" << endl;
}
int main() {
print();
Dog d1, d2;
Cat c1;
print();
Dog* d3 = new Dog();
Animal* c2 = new Cat;
Cat* c3 = new Cat;
print();
delete c3;
delete c2;
delete d3;
print();
}
