Title : C++复习资料
Author: sunwu
Date: Thu Nov 23 2006
http://www.sunwu.net

本次考试共有三大题：解词或解答，读程序，写程序。根据老师所讲的内容，整理如下：

解词或解答：

1、什么是面向对象的程序设计？P3
面向对象的程序设计是一种新的范型。这种范型的主要特征是：
程序＝对象＋消息
面向对象的程序设计的基本元素是对象，面向对象程序的主要结构特点是：
第一，程序一般由类的定义和类的使用两部分组成，在主程序中由类定义各对象并规定它们之间传递消息的规律；
第二，程序中的一切操作都是通过向对象发送消息来实现的，对象接收到消息后，启动有关方法完成相应的操作；
第三，类由继承关系产生相互间的联系。
简单地说面向对象程序设计语言应该具备下述特征：（1）它支持对象的概念，（2）它要求对象属于类，（3）它提供继承机制。P15

2、对象的特点是什么？P4
现实世界中的对象，具有以下特性：
（1）每一个对象必须有一个名字以区别于其他对象；
（2）用属性（或叫状态）来描述它的某些特征；
（3）有一组操作，每一个操作决定对象的一种行为；
（4）对象的操作可以分为两类：一类是自身所承受的操作，一类是施加于其他对象的操作。
程序中对象的特征：P10
（1）封装性 （2）模块独立性 （3）动态连接性 （4）易维护性

３、类由哪两部分组成？P6
数据成员、成员函数

4、重载概念：（什么是重载？）
重载一般包括函数重载和运算符重载。函数重载是指一个标识符可同时用于多个函数命名，而运算符是指一个运算符可同时用于多种运算。也就是说，相同名字的函数或运算符在不同的场合可以表现出不同的行为。

5、引用的概念：（什么是引用？）
（引用是c++中的新概念，）引用是能自动间接引用的一种指针。引用通常被认为是某个变量的别名。C＋＋通过引用运算符“＆”来声明一个引用。
e: 
int i=5;
int &j=I;
此时，j是一个整数类形的引用，变量i和引用j占用内存的同一位置。

6、类（class）与结构体（struct）的比较：对struct进行扩充而产生class，C＋＋规定，在默认情况下，结构中的成员是公有的，而类中的成员是私有的。

7、派生类构造函数与析构函数执行顺序：
创建时：首先执行基类的构造函数，随后再执行派生类的构造函数，撤销时：先执行派生类的析构函数，随后再执行基类的析构函数。

读程序题：
1、读下面程序，写出运行的结果。
#include <iostream.h>
#include <math.h>

class complex
{
private:
	double real;
	double image;
public:
	complex(double r, double i)  //构造函数
	{
		real=r;
		image=i;
	}
	double abscomplex()
	{
		double t;
		t=real*real+image*image;
		return sqrt(t);
	}
};

int main()
{
	complex A(1.1,2.2);  
	cout<<"abs of complex A = "<<A.abscomplex()<<endl;
	return 0;
}程序运行结果如下：
Abs of complex A = 2.459675


2、读下面程序，写出运行的结果。
#include <iostream.h>
class example
{
private:
	int x,y;
public:
	example(int n,int m)
	{
		x=n;
		y=m;
	}
	~example()
	{
		cout<<"Destructor called.\n";
	}
	int get_x()
	{
		return x;
	}
	int get_y()
	{
		return y;
	}
};
int main()
{
	example op[3][2]={example(1,2),example(3,4),example(5,6),example(7,8),example(9,10),example(11,12),};
	int i;
	for(i=0;i<3;i++)
	{
		cout<<op[i][0].get_x()<<" ";
		cout<<op[i][0].get_y()<<endl;
		cout<<op[i][1].get_x()<<" ";
		cout<<op[i][1].get_y()<<endl;
	}
	return 0;
}
程序运行结果如下：
1 2
3 4
5 6
7 8
9 10
11 12
Destruct called.
Destruct called.
Destruct called.
Destruct called.
Destruct called.
Destruct called.


3、P124例4.6
#include<iostream.h>
Class base{
int i;
public:
  base(int n)
{
 cout<<"Constructing base class"<<endl;
 i=n;
}
~base()
{
cout<<"Destructing base class"<<endl;
}
woid showi()
{
cout<<i<<endl;
}
};
class derive :public base
{
int j;
public:
derive(int n,int m):base
{
cout<<"Constructing derived class"<<endl;
j=n;
}
~derive()
{
cout<<"Destructing derive class"<<endl;
}
void showj()
{
cout<<j<<endl;
}
};
int main()
derive obj(30,40);
obj.showi();
obj.showj();
return 0;
}


…

程序运行结果：
Constructing base class
Constructing derived class
40
30
Destructing derived class 
Destructing derived class


4、P140 例 4.13
#include <iostream.h>
class X{
int a;
public:
 X(int sa)
 {a=sa;}
 int getX()
 {return a;}
};
class Y{
 int b;
public:
 Y(int sb)
 {b=sb;}
 int getY()
 {return b;}
};
class Z:public X,private Y{
 int c;
public:
 Z(int sa,int sb,int sc):X(sa),Y(sb)
{
 c=sc;
}
 int getZ()
 {return c;}
 int getY()
 {return Y::getY();}
}
main()
{
Z obj(2,4,6);
int ma=obj.getX();
cout<<"a="<<ma<<endl;
int mb=obj.getY();
cout<<"b="<<mb<<endl;
int mc=obj.getZ();
cout<<"c="<<mc<<endl;



程序运行结果：
a=2
b=4
c=6

5、P229 例6.4
#include <iostream.h>
const int size=10;
template<class Type>
class stack{
	Type stck[size];
	int tos;
	public:
		void init()
		{tos=0;}
		void push(Type ch);
		Type pop();
};
template<class Type>
void stack<Type>::push(Type ob)
{ 
	if(tos==size)
	{
		cout<<"stack is full!"<<endl;
		return ;
	}
	stck[tos]=ob;
	tos++;
}
template <class Type>
Type stack<Type>::pop()
{
	if(tos==0)
	{
		cout<<"stack is empty!"<<endl;
	}
	tos--;
	return stck[tos];
}
int main()
{
	stack<char>s1,s2;
	int i;
	s1.init();
	s2.init();
	s1.push('a');
	s2.push('x');
	s1.push('b');
	s2.push('y');
	for(i=0;i<2;i++)cout<<"pop s1 is : "<<s1.pop()<<endl;
	for(i=0;i<2;i++)cout<<"pop s2 is : "<<s2.pop()<<endl;
	stack<int>i1,i2;
	i1.init();
	i2.init();
	i1.push(1);
	i2.push(2);
	i1.push(3);
	i2.push(4);
	for(i=0;i<2;i++)cout<<"pop i1 is : "<<i1.pop()<<endl;
	for(i=0;i<2;i++)cout<<"pop i2 is : "<<i2.pop()<<endl;

	return 0;
}  //本程序我做了一点改动，你看到大概像这个样子，加上自己的理解，即可得出结论

书中的程序运行结果如下：
pop s1 : c
pop s1 : b
pop s1 : a
pop s2 : z
pop s2 : y
pop s2 : x
pop is1 : 5
pop is1 : 3
pop is1 : 1
pop is2 : 6
pop is2 : 4
pop is2 : 2


写程序：
写程序题大家一定要做，只要有文字就有分数。你就当作是写作文一样。
有可能就是上面读程序中的最后一个例子，内容为自己写一个堆栈的类，这个例子又能说明“类模板”的应用。
还有一个“复数的比较”有可能会出写程序题，大家自己发挥吧。