前言
这几天又做了几套题，今天上午不想做了O(∩_∩)O，就把这几天做的题整理整理吧，说真的今天我再去看发现有的地方理解的还是不到位，做过的有些题还是会做错/(ㄒoㄒ)/~~。
一、第二套 操作题考试题库试题
1、基本操作题
修改下列程序的错误，使程序的输出结果为：
Constructor called.
The value is 10
Max number is 20
Destructor called.
代码如下（示例）：
// proj1.cpp
#include <iostream>
using namespace std;
class MyClass {
public:
// ERROR **********found**********
void MyClass(int i) //应修改为MyClass(int i)
{
value = i; cout << "Constructor called." << endl; }
int Max(int x, int y) {
return x>y ? x : y; } // 求两个整数的最大值
// ERROR **********found**********
int Max(int x, int y, int z = 0) // 求三个整数的最大值
{
//应修改为int Max(int x,int y,int z)
if (x > y)
return x>z ? x : z;
else
return y>z ? y : z;
}
int GetValue() const {
return value; }
~MyClass() {
cout << "Destructor called." << endl; }
private:
int value;
};
int main()
{
MyClass obj(10);
// ERROR **********found**********
cout<< "The value is "<< value()<< endl; //应修改为cout<< "The value is "<<GetValue()<< endl;
cout << "Max number is " << obj.Max(10,20) << endl;
return 0;
}
解题思路：
1、考查构造函数
构造函数和析构函数是在类体中说明的两种特殊成员函数。构造函数和析构函数都没有返回值，并且定义他们时不需要显式地写出没有返回值。所以构造函数前不加void或其他任何类型名，如上题直接MyClass(int i)即可。
2、考查函数重载
函数的功能类似，但在调用他们时，程序员需要知道每个函数名字，这会比较麻烦，如果能用同一个函数名在不同类型上做相似的操作就会方便很多，这种情况即为函数的重载。
C++语言将根据参数类型来判断应该调用哪个函数。根据所传递的实参的不同，调用相应的函数，得到期望的结果，并且重载函数至少要在参数个数或者参数类型上有所不同。
如上题int Max(int x, int y) { return x>y ? x : y; } 中两个形参变量都是int 型，而语句int Max(int x, int y, int z = 0)前两个形参也是int型，第三个形参定义默认值，那么这两个Max函数在调用时他们的参数个数和参数类型都一样，根据重载的要求形参类型或形参个数不同，所以要把int z=0，改为int z，才能构成函数重载。
3、考查成员函数调用（P124）
因为value是私有成员，所以不能被类外函数直接调用，私有成员定义了类的内部使用的数据和函数，私有成员只能被自己所属类的成员函数及友元函数访问：故使用成员函数obj.GetValue（）得到value的值。
2、简单应用题
请将堆栈类的定义补充完整，使程序的输出结果为：
The element of stack are :4 3 2 1
代码如下（示例）：
//proj2.cpp
#include <iostream>
using namespace std;
const int Size=5;
class Stack;
class Item
{
public:
//********found********
Item(const int& val):__________ {
} //构造函数 对item进行初始化
private:
int item;
Item* next;
friend class Stack;
};
class Stack
{
public:
Stack():top(NULL) {
}
~Stack();
int Pop();
void Push(const int&);
private:
Item *top;
};
Stack::~Stack()
{
Item *p=top,*q;
while(p!=NULL)
{
q=p->next;
//********found********
__________; //释放p所指向的结点
p=q;
}
}
int Stack::Pop()
{
Item* temp;
int ret;
//********found********
__________; //使temp指向栈顶结点
ret=top->item;
top=top->next;
delete temp;
return ret;
}
void Stack::Push(const int& val)
{
Item* temp=new Item(val);
//********found********
__________; //使新结点的next指针指向栈顶数据
top=temp;
}
int main()
{
Stack s;
int i;
for( i=1;i<Size;i++)
s.Push(i);
cout<<"The element of stack are: ";
for(i=1;i<Size;i++)
cout<<s.Pop()<<'\t';
return 0;
}
解题思路：
1、考查构造函数初始化问题
格式：函数名（形参）：函数名（形参）。目前我还不太理解构造函数初始化的问题，只是知道初始化时的具体格式，等会我会去查查资料去好好的理解一下，到时候有什么新的理解在发blink。现阶段需要注意的时：后跟函数名（形参）形参类型与前面的类型保持一致。故填写为item(val)。
2、这个不用多说析构函数用delete释放指针，格式为：delete[ ]+指针。
3、指向栈顶节点是top指针，要使temp指向栈顶节点，故使用语句temp=top。
4、指向栈顶节点的是top指针，要使新节点的next指针指向栈顶数据，故使用语句temp->next=top。
3、综合应用题
如下程序定义了用于表示平面坐标系中的点的类MyPoint和表示矩形的类MyRectangle;程序应该显示：
（0，2）（2，2）（2，0）（0，0）4
程序中有缺失部分，按照提示，把缺失部分补充完整。
（1）下方是构造函数的定义，它用参数提供的左下角和右下角的坐标对up_left和down_right进行初始化
（2）下方是成员函数getDownLeft的定义中的一条语句，函数getDownLeft返回用MyPoint对象表示矩形的左下角。
（3）下方是成员函数area的定义，它返回矩形的面积。
代码如下（示例）：
// proj3.cpp
#include<iostream>
using namespace std;
class MyPoint{
//表示平面坐标系中的点的类
double x;
double y;
public:
MyPoint (double x,double y){
this->x=x;this->y=y;}
double getX()const{
return x;}
double getY()const{
return y;}
void show()const{
cout<<'('<<x<<','<<y<<')';}
};
class MyRectangle{
//表示矩形的类
MyPoint up_left; //矩形的左上角顶点
MyPoint down_right; //矩形的右下角顶点
public:
MyRectangle(MyPoint upleft,MyPoint downright);
MyPoint getUpLeft()const{
return up_left;} //返回左上角坐标
MyPoint getDownRight()const{
return down_right;} //返回右下角坐标
MyPoint getUpRight()const; //返回右上角坐标
MyPoint getDownLeft()const; //返回左下角坐标
double area()const; //返回矩形的面积
};
//**1** **********found**********
MyRectangle::MyRectangle(_____________________):
up_left(p1),down_right(p2){
}
MyPoint MyRectangle::getUpRight()const
{
return MyPoint(down_right.getX(),up_left.getY());
}
MyPoint MyRectangle::getDownLeft()const
{
//**2** **********found**********
return MyPoint(___________________________);
}
//**3** **********found**********
___________________area()const
{
return (getUpLeft().getX()-getDownRight().getX())*
(getDownRight().getY()-getUpLeft().getY());
}
int main( )
{
MyRectangle r(MyPoint(0,2),MyPoint(2,0));
r.getUpLeft().show();
r.getUpRight().show();
r.getDownRight().show();
r.getDownLeft().show();
cout<<r.area()<<endl;
return 0;
}
解题思路：
1、构造函数中的参数要给私有成员赋值，在下句中up_left(p1),down_right(p2){ }指出私有成员赋值要使用形参p1和p2，因此这里参数要定义为MyPoint p1,Mypoint p2。
2、成员函数的返回语句，实际根据上面的右上角坐标的返回就可以判断出来，MyPoint MyRectangle::getDownLeft()const函数要求返回一个左下角的点坐标，因此使用语句MyPoint（up_left.getX(),down_right.getY());
3、成员函数的定义，在MyRectangle类中已经声明double area() const，因此此处只要添加 double MyRectangle::即可。构造函数的参数定义时要注意在赋值语句中用的参数，考查构造函数一般都会考查到形参，应注意联系上下文。类的成员函数在类外定义时要在函数名前面加上：返回值类型+类名+作用域（::）。
二、第三套 操作题考试题库试题
1.基本操作题
下列程序存在错误，改正这些错误，使程序的输出结果为：
The value is 10
代码如下（示例）：
// proj1.cpp
#include <iostream>
using namespace std;
class MyClass {
int value;
public:
// ERROR ********found********
void MyClass(int val) : value(val) {
}
int GetValue() const {
return value; }
void SetValue(int val);
};
// ERROR ********found********
inline void SetValue(int val) {
value = val; }
int main()
{
MyClass obj(0);
obj.SetValue(10);
// ERROR ********found******** 下列语句功能是输出obj的成员value的值
cout << "The value is " << obj.value << endl;
return 0;
}
解题思路：
1、这个点做过很多次了，定义构造函数时不需要显式地写出没有返回值，不使用void，直接使用MyClass(int val)即可。
2、类的成员函数的定义，在类体内直接给出函数的定义，称之为内联函数，在类定义体中实现的函数都是内联函数。如getEdge(),getAngle为内联函数。
在类体内只写出函数的原型说明，而成员函数的实现写在类的定义体外。在类外部定义成员函数的一般格式是：<返回类型><类名>::<成员函数名>(<参数表>) {<成员函数体>}
成员函数定义的结构与普通函数不同之处是在返回类型和函数名之间加了一个类名和双冒号：：称为作用域运算符，用来标识成员函数或数据成员属于哪个类的，在定义体外实现的函数可以通过函数说明和定义时分别加上inline关键字来表示该函数是内联函数，否则不是。成员函数除了可以定义为内联函数以外，也可以进行重载，可以对其参数设置默认值。
3、函数的调用问题，value是私有函数，在主函数中不能直接调用value，可以使用成员函数GetValue()来得到value的值。
2.简单应用题
如下程序定义了Stack类和ArrayStack类。
Stack是一个用于表示数据结构“栈”的类，栈中的元素是字符型数据。Stack为抽象类，它只定义了栈的用户接口，如下所示：
公有成员函数 功能
push 入栈：在栈顶位置添加一个元素
pop 退栈：取出并返回栈顶元素
ArrayStack是Stack的派生类，它实现了Stack定义的接口。ArrayStack内部使用动态分配的字符数组作为栈元素的存储空间。数据成员maxSize表示的是栈的最大容量，top用于记录栈顶的位置。成员函数push和pop分别实现具体的入栈和退栈操作。
请在程序的横线上填写合适的代码，已成功输出结果
a,b,c
c,b,a
代码如下（示例）：
// proj2.cpp
#include <iostream>
using namespace std;
class Stack {
public:
virtual void push(char c) = 0;
virtual char pop() = 0;
};
class ArrayStack : public Stack {
char * p;
int maxSize;
int top;
public:
ArrayStack(int s)
{
top = 0;
maxSize = s;
//********found********
p = __________;
}
~ArrayStack()
{
//********found********
__________;
}
void push(char c)
{
if (top == maxSize) {
cerr << "Overflow!\n";
return;
}
//********found********
__________;
top++;
}
char pop()
{
if (top == 0) {
cerr << "Underflow!\n";
return '\0';
}
top--;
//********found********
__________;
}
};
void f(Stack& sRef)
{
char ch[] = {
'a', 'b', 'c'};
cout << ch[0] << ", " << ch[1] << ", " << ch[2] << endl;
sRef.push(ch[0]); sRef.push(ch[1]); sRef.push(ch[2]);
cout << sRef.pop() << ", ";
cout << sRef.pop() << ", ";
cout << sRef.pop() << endl;
}
int main()
{
ArrayStack as(10);
f(as);
return 0;
}
解题思路：
1、ArrayStack类的构造函数，申请动态储存空间，在函数中要为p申请s个char型空间应使用的语句为p=new char[s]
2、析构函数使用delete释放动态内存空间，语法格式老样子：delete[ ]<指针变量>
3、主要考查push函数，top表示栈顶元素下标，添加的数据放到栈顶，因此使用语句 p [top] = c
4、主要考查pop函数，输出栈顶元素，top表示栈顶元素下标，因此使用语句return p [top]
3.综合应用题
下面程序其功能是读取文本文件in.dat中的全部内容，将文本存放到doc类的对象myDoc中。然后将myDoc中的字符序列反转，并输出到文件out.dat中。文件in.dat的长度不大于1000字节。
要求在规定区域内补充，实现将myDoc中的字符序列反转，并将反转后的序列在屏幕上输出。
代码如下（示例）：
// proj3.cpp
#include<iostream>
#include<fstream>
#include<cstring>
using namespace std;
class doc
{
private:
char *str; //文本字符串首地址
int length; //文本字符个数
public:
//构造函数，读取文件内容，用于初始化新对象。filename是文件名字符串首地址。
doc(char *filename);
void reverse(); //将字符序列反转
~doc();
void writeToFile(char *filename);
};
doc::doc(char *filename)
{
ifstream myFile(filename);
int len=1001,tmp;
str=new char[len];
length=0;
while((tmp=myFile.get())!=EOF)
{
str[length++]=tmp;
}
str[length]='\0';
myFile.close();
}
void doc::reverse(){
// 将数组str中的length个字符中的第一个字符与最后一个字符交换，第二个字符与倒数第二个
// 字符交换……
//*************333***********
//*************666***********
}
doc::~doc()
{
delete [] str;
}
void doc::writeToFile(char *filename)
{
ofstream outFile(filename);
outFile<<str;
outFile.close();
}
void main()
{
doc myDoc("in.dat");
myDoc.reverse();
myDoc.writeToFile("out.dat");
}
解题思路：
这道题主要是将已知的字符串进行反转输出，就是将首位各项依次调位，比较简单，具体实现程序如下：
int i,j;//定义两个整数临时变量i,j
for(i=0;j=length-1;i<j;i++,j--)
{
char temmp =str[i];//把Str[i]中的值保存在临时变量temp中
str[i]=str[j];//把Str[j]值赋值给Str[i],实现字符前后替换
Str[j]=temp;//把保存在临时变量temp中的值再赋值给Str[j]
}
总结
没什么说的了，这就是二三两套操作题考试题库的全部内容，每道题都有解题思路，有些考点出现不止一次，关键是能够准确理解题的逻辑。目前需要做的是掌握一些基本的表示，语法规则还需要进一步的学习，记忆。相信只要认真思考每道题，做题一定能够越来越好的(ง •_•)ง