第1页:单项选择题 第2页:填空题 第3页:改错题 第4页:完成程序题 第5页:程序分析题

　　　　给出下面各程序的执行结果。

　　31．请分析以下的程序，给出该程序的正确执行结果。

　　　　#include

　　　　int add(int x,int y) { return x+y; }

　　　　void main()

　　　　{ int m=2,n=3;

　　　　cout<<”1：”<

　　　　m=2,n=3;

　　　　cout<<”2：”<

　　　　m=2,n=3;

　　　　cout<<”3：”<

　　　　m=2,n=3;

　　　　cout<<”4：”<

　　　　}

　　　 　　 答：1：7

　　　　2：8

　　　　3：8

　　　　4：9

　　[解析]在说明答案之前，要说明两个问题：

　　　　（1）C++语言中，函数参数是压在栈里的，因压栈是从前往后进行的，所以出栈就是从后向前进行的，也即先取最后的参数，然后再向前逐个取用；

　　　　（2）对于单加运算，m++是先执行后加1，++m是加1后再执行。

　　　　由此，因m=2,n=3;，所以：

　　　　1：（m++）+（m+n）=2+（2+3）=7 （m++后执行，且后加1，所以m=2一直未变）

　　　　2：（++m）+（m+n）=3+（2+3）=8 （++m后执行，但先加1，执行++m时，m=3了）

　　　　3：（m+n）+（ m++）=（3+3）+2=8 （先执行m++，后加1，执行m+n时，m=3了）

　　　　4：（m+n）+（++m）=（3+3）+3=9; （先执行++m，且先加1，故一开始就有m=3）

　　32．请分析下面的程序并给出该程序的执行结果。

　　　　#include

　　　　class AA {

　　　　int a;

　　　　public:

　　　　AA() { cout<<”Initualizing AA!\n”; }

　　　　~AA() { cout<<”Destroying AA!\n”;

　　　　};

　　　　class BB {

　　　　int b;

　　　　AA p;

　　　　public:

　　　　BB() { cout<<”Initualizing BB!\n”; }

　　　　~BB() { cout<<”Destroying BB!\n”;

　　　　};

　　　　void main()

　　　　{ BB X;

　　　　cout<<”Ending main!\n”;

　　　　}

　　　 　　 答：Initualizing AA!

　　　　Initualizing BB!

　　　　Ending main!

　　　　Destroying BB!

　　　　Destroying AA!

　　[解析]虽然在主程序中只定义了一个类BB的对象，但在类BB中声明了类AA的对象作为它的数据成员。当一个类中含有对象作为数据成员时，在生成对象时，先调用成员对象的构造函数，再调用类自己的构造函数，所以输出了“Initualizing AA!”（成员对象构造函数的输出）和“Initualizing BB!”（类自己构造函数的输出）。对象生成后，执行下一句输出语句，则输出“Ending main!”。此时程序结束，调用析构函数来析构掉对象，先调用类自身的析构函数，其输出为“Destroying BB!”，再调用成员对象的析构函数，其输出为“Destroying AA!”。

　　33．写出下列程序的运行结果。

　　　　#include

　　　　class AA {

　　　　int a;

　　　　public:

　　　　AA(int i) { a=i; cout<<”AA=”<

　　　　virtual ~AA() { cout<<”~AA=”<

　　　　};

　　　　class BB:public AA {

　　　　int b;

　　　　public:

　　　　BB(int i,int j):AA(i) { b=j; cout<<”BB=”<

　　　　~BB() { cout<<”~BB=”<

　　　　};

　　　　void main()

　　　　{ AA *pa=new AA(8);

　　　　delete pa;

　　　　AA *pb=new BB(6,9);

　　　　delete pb;

　　　　}

　　　 　　 答：AA=8

　　　　~AA=8

　　　　AA=6

　　　　BB=9

　　　　~BB=9

　　　　~AA=6

　　[解析]语句“AA *pa=new AA(8);”动态生成一个类AA的对象并把它的地址赋给对象指针“pa”，为此系统调用了AA的构造函数，输出AA=8。接下来，执行语句“delete pa;”删除该对象指针，其实是删除了动态生成的对象，因此调用类AA的析构函数，输出~AA=8。接着执行语句“AA *pb=new BB(6,9);”，动态生成一个类BB的对象，并将其地址赋给类AA的指针“pb”。在生成派生类BB对象时，系统首先调用基类AA的构造函数输出AA=6，然后调用派生类BB的构造函数输出BB=9。最后执行语句“delete pb;”，由于基类AA的析构函数被定义为虚函数，因此在运行时是动态联编的。故系统先调用派生类BB的析构函数输出~BB=9，再调用基类AA的析构函数输出~AA=6（若基类析构函数非虚函数，则只输出~AA=6）。

　　34．写出下列程序的运行结果。

　　　　#include

　　　　class AA {

　　　　public:

　　　　static int n;

　　　　AA() { n++; }

　　　　};

　　　　int AA::n=0;

　　　　main()

　　　　{ cout<<”AA::n=”<

　　　　AA d1;

　　　　cout<

　　　　AA d2;

　　　　cout<

　　　　AA d3,d4;

　　　　cout<

　　　　cout<

　　　　}

　　　 　　 答：AA::n=0

　　　　d1.n=1

　　　　d2.n=2

　　　　d1.n=4

　　　　d2.n=4

　　[解析]由于数据成员n的访问属性是公有的，所以在类外可访问它；又它是静态变量，所以具有全局性。在构造函数中，执行的是n++操作，即每次调用构造函数n就加1。当程序开始时，因未定义对象，所以n的值为初始化时的值，则输出为“AA::n=0”。当定义了对象d1后，由于调用了构造函数，则该对象中n=1，故输出“d1.n=1”。同理，对象d2输出“d2.n=2”。由于接下来生成了两个对象d3和d4，调用两次构造函数，n两次加1，此时n=4，所以下面两条语句的输出为“d1.n=4”和“d2.n=4”。

　　35．写出下列程序的输出结果。

　　　　#include

　　　　class AA {

　　　　public:

　　　　AA{} { cout<<”Constructor of AA． \n”; fun(); }

　　　　virtual void fun() { cout<<”AA::fun() calle

　　　　D．\n”; }

　　　　};

　　　　class BB:public AA {

　　　　public:

　　　　BB(){ cout<<”Constructor of B

　　　　B．\n”; fun(); }

　　　　void fun() { cout<<”BB::fun() calle

　　　　D．\n”; }

　　　　};

　　　　void main()

　　　　{ BB d; }

　　　 　　 答：Constructor of AA．

　　　　AA::fun() called.

　　　　 Constructor of BB.

　　　　BB::fun() called.

　　[解析]虽然函数fun()说明为虚函数，但当在构造函数中被调用时，呈现的是静态联编，即基类和派生类都调用各自的函数fun()。所以，当生成对象d时，先调用基类的构造函数，在构造函数中又调用自己的函数“fun()”，所以输出为“Constructor of AA．”和“AA::fun() called.”。同理调用派生类的构造函数时，生成的输出为“Constructor of BB.”和“BB::fun() called.”。

　　36．请给出下面的程序的输出结果。

　　　　#include

　　　　template

　　　　void sort(T* a,int n)

　　　　{ T num;

　　　　for(int i=0;i

　　　　{ for(int j=i;j

　　　　if(a[j]>a[j+1])

　　　　{ num=a[j]; a[j]=a[j+1]; a[j+1]=num; }

　　　　}

　　　　for(i=0;i

　　　　cout<

　　　　cout<

　　　　}

　　　　void main()

　　　　{ int iver[5]={ 12,45,9,23,37 };

　　　　double dver[5]= { 22.3,56.7,43.5,13.8,8.6 };

　　　　sort(iver,5);

　　　　sort(dver,.5);

　　　　}

　　　 　　 答：9 12 23 37 45

　　　　8.6 13.8 22.3 43.5 56.7

　　[解析]这是使用模板的例子。函数sort是一个递增的排序函数，T是个模板。当数组是整型数据类型时，它为整型数组排序；当数组为双精度数据类型时，它为双精度数组排序。所以输出如上结果。