题目来源：程序设计与算法（三）测验和作业题汇总

文章目录

• • 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 
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 
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 
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 
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 
#include 
#include 
#include 
#include 
#include 
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 
#include 
#include 
#include 
#include 
#include 
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<Student student;        // 定义类的对象student.input();        // 输入数据student.calculate();    // 计算平均成绩student.output();       // 输出数据
}

006:奇怪的类复制

只有在初始化对象的时候，才会调用构造函数或复制构造函数！

#include 
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 
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 
#include 
#include 
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 
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 
#include 
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 
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:魔兽世界之一：备战

见：【POJ C++题目】魔兽世界之一：备战

014:MyString

#include 
#include 
#include 
using namespace std;class MyString {char * p;
public:MyString(const char * s) {if(s) {p = new char[strlen(s) + 1];strcpy(p, s);}elsep = NULL;}~MyString() { if(p) delete [] p; }// 在此处补充你的代码// 深拷贝 void Copy (const char * s){if(s) {p = new char[strlen(s) + 1];strcpy(p, s);}elsep = NULL;}// 深拷贝MyString (const MyString &o){if(o.p) {p = new char[strlen(o.p) + 1];strcpy(p, o.p);}elsep = 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);}elsep = 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  
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  
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 
#include 
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

（略）

020:继承自string的MyString

（略）

021:魔兽世界之二：装备

见：【POJ C++题目】魔兽世界之二：装备

见：【POJ C++题目】魔兽世界之二：装备（简化）

022:看上去像多态

#include 
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  
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"< 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  
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 
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"< 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 
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 
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();
}