自考C++程序结果及答案

2024年2月7日发(作者：)

1. 给出下面程序输出结果。

#include

class a

{public:

virtual void print()

{cout<< ""<< endl;};};

class b:public a

{};

class c:public b

{public:

void print(){cout<<"c

"<

void show(a *p)

{(*p).print();}

void main()

{a a;

b b;

c c;

show(&a);

show(&b);

show(&c);}

答案：

［解析］考查多态性的。a类对象调用本身的虚函数，b类因为没有覆写print，所以仍然调用基

类的虚函数。而c类重新定义print虚函数，所以调用c类的print。

2. 给出下面程序输出结果。

#include

#include

#include

bool fun(long n);

void main()

{long a=10,b=30,l=0;

if(a%2==0) a++;

for(long m=a;m<=b;m+=2)

if(fun(m))

{if(l++%10==0)

cout <

cout <

}

}

bool fun(long n)

{int sqrtm=(int)sqrt(n);

for(int i=2;i<=sqrtm;i++)

if(n%i==0)

return false;

return true;

}

答案：11 13 17 19 23 29

［解析］循环体用来判断n是否是质数的函数,在main函数判断10～30之间质数。

3. 给出下面程序输出结果。

#include

class Test

{int x,y;

public:

Test(int i,int j=0)

{x=i;y=j;}

int get(int i,int j)

{return i+j;}

};

void main()

{Test t1(2),t2(4,6);

int (Test::*p)(int,int=10);

p=Test::get;

cout<<(t1.*p)(5)<

Test *p1=&t2;

cout<<(p1->*p)(7,20)<

}

答案：15 27

［解析］指向类成员函数的指针的使用，*p指向Test类中有两个参数的函数的一个指针。

P＝Test::get.这样p就和get发生了联系。(t1.*p)(5)等价于调用一个参数的get函数。

4. #include

#include

#include

class student

{char name［8］;

int deg;

char level［7］;

friend class process; // 说明友元类

public:

student(char na［］,int d)

{ strcpy(name,na);

deg=d;

}

};

class process

{ public:

void trans(student &s)

{int i=/10;

switch(i)

{case 9:

strcpy(, "优");break;

case 8:

strcpy(,"良");break;

case 7:

strcpy(,"中");break;

case 6:

strcpy(,"及格");break;

default:

strcpy(,"不及格");

}

}

void show(student &s)

{cout<

};

void main()

{ student st［］={student("张三",78),student("李四",92),student("王五

",62),student("孙六",88)};

process p;

cout<<"结 果:"<<"姓名"<

for(int i=0;i<4;i++)

{ (st［i］);

(st［i］);}

}

答案：结果:姓名成绩等级

张三78中

李四92优

王五62及格

孙六88良

1. 给出下面程序输出结果。

#include

class example

{int a;

public:

example(int b=5){a=b++;}

void print(){a=a+1;cout <

void print()const

{cout<

};

void main()

{example x;

const example y(2);

();

();

}

答案：62

［解析］x是普通对象，调用普通的print函数；而y常对象，调用常成员函数。

2. 给出下面程序输出结果。

#include

void main()

{ int *p1;

int **p2=&p1;

int b=20;

p1=&b;

cout<<**p2<

}

答案：20

［解析］p1指向b，而p指向p1的地址。*p2表示p1的地址，p1的地址就是&b，即*p2是&b,所以

**p2就是b变量的值。

3. 给出下面程序输出结果。

#include

class Base

{private:

int Y;

public:

Base(int y=0) {Y=y;cout<<"Base("<

~Base() {cout<<"~Base()＼n";}

void print() {cout <

};

class Derived:public Base

{private:

int Z;

public:

Derived (int y, int z):Base(y)

{Z=z;

cout<<"Derived("<

}

~Derived() {cout<<"～Derived()＼n";}

void print()

{Base::print();

cout<

}

};

void main()

{Derived d(10,20);

();

}

答案：Base(10)

Derived(10,20)

10 20

～Derived()

~Base()

［解析］派生类对象，先调用基类构造函数输出Base(10)，后调用派生类构造函数输出Derived(10,20)，后执行(),调用派生类的print，再调用Base::print()输出10，后返回

输出z的值20。后派生类析构，再基类析构。4. 给出下面程序输出结果。

#include

class A

{public:

A()

{cout<<"A 构造函数＼n";fun();}

virtual void fun()

{cout<<"A::fun() 函数＼n";}

};

class B:public A

{public:

B()

{cout<<"B构造函数＼n";fun();}

void fun() {cout<<"B::fun() calle函数＼n";}

};

void main()

{B d;}

答案：A构造函数

A::fun()函数

B构造函数

B::fun()calle函数

［解析］定义派生类对象，首先调用基类构造函数，调用A类中fun()，然后调用B类的构造函数

，在调用B的fun函数。

1. 运行程序，写出程序执行的结果。

#include

void main()

{int a,b,c;

char ch;

cin>>a>>ch>>b>>c;//从键盘上输入1.5×c×10×20,×表示一个空格

cout<

}

答案：1

.

5

0

［解析］使用cin进行输入字符的输入的问题。1-->a,.-->ch,5-->b,空格转换为零给了c。

2. 给出下面程序输出结果。

#include

class A

{public:

A()

{cout<<"As cons."<

virtual ~A()

{cout<<"As des."<

virtual void f()

{cout<<"As f()."<

void g()

{f();}

};

class B:public A

{public:

B()

{f();cout<<"Bs cons."<

~B()

{cout<<"Bs des."<

};

class C:public B

{public:

C()

{cout<<"Cs cons."<

~C()

{cout<<"Cs des."<

void f()

{cout<<"Cs f()."<

};

void main()

{A *a=new C;

a->g();

delete a;

}

答案：As f().

Bs cons.

Cs cons.

Cs f().

Cs des.

Bs des.

As des.

［解析］定义C类对象时要调用基类构造函数从A到B再到C，调用B的构造函数时，B类没有

f（），则指向来自A类的f（）函数。同时用基类的指针指向了派生类对象。最后析构函数的执

行。

1. 给出下面程序输出结果。

#include

class a

{public:

a(int i=10){x=i;cout<<"a:"<

int x;

};

class b:public a

{public:

b(int i):A(i){x=i;cout<<"b:"<

"<

private:

a A;

int x;

};

void main()

{b B(5);

}

答案：a:10

a:5

b:5,10

［解析］定义对象B，先调用基类构造函数，在b构造函数中使用的是A(i)，注意大小写，不

是a(i),也就是说调用基类的构造函数时没有实参值，所以采用默认值；在初始化类成员A，即

A(i)，i＝5，所以输入为a:5；最后是b类的构造函数，x=5,来自基类x＝10，输出b:5,10。

2. 运行程序，写出程序执行的结果。

#include

class Location

{public:

int X,Y;

void init(int initX,int initY);

int GetX();

int GetY();

};

void Location::init (int initX,int

initY)

{X=initX;

Y=initY;

}

int Location::GetX()

{return X;

}

int Location::GetY()

{return Y;

}

void display(Location& rL)

{cout<<()<<" "<<()<<＼n;

}

void main()

{Location A［5］={{5,5},{3,3},{1,1},{2,2},{4,4}};

Location *rA=A;

A［3］.init(7,3);

rA->init(7,8);

for (int i=0;i<5;i++)

display(*(rA++));

}

答案：7 8

3 3

1 1

7 3

4 4

［解析］对象数组的使用。使用数组对象修改了A［3］元素的值，又使用指针修改指针所指向的

第一个元素的值，因此修改了A［0］和A［3］元素的值。

3. 给出下面程序输出结果。

#include

int a［8］={1,2,3,4,5,6,7};

void fun(int *pa,int n);

void main()

{int m=8;

fun(a,m);

cout<

}

void fun(int *pa,int n)

{for (int i=0;i

*(pa+7)+=*(pa+i);

}

答案：28

［解析］数组名与指针都表示地址，只是数组名是常地址，不能改变；指针是地址变量，使用时

可以当数组名使用。

4. 给出下面程序输出结果。

#include

class A

{int *a;

public:

A(int x=0):a(new int(x)){}

~A() {delete a;}

int getA() {return *a;}

void setA(int x) {*a=x;}

};

void main()

{A x1,x2(3);

A *p=&x2;

(*p).setA(()+5);

(10+());

cout<<()<<""<<()<

}

答案：108

［解析］p指向对象x2，()+5该值为8 即x2.a＝8;10+()为10，x1.a＝10。

1. 给出下面程序输出结果。

#include

class Base

{private:

int Y;

public:

Base(int y=0) {Y=y;cout<<"Base("<

~Base() {cout<<"~Base()＼n";}

void print() {cout <

};

class Derived:public Base

{private:

int Z;

public:

Derived (int y, int z):Base(y)

{Z=z;

cout<<"Derived("<

}

~Derived() {cout<<"～Derived()＼n";}

void print()

{Base::print();

cout<

}

};

void main()

{Derived d(10,20);

();

}

答案：Base(10)

Derived(10,20)

10 20

～Derived()

~Base()

［解析］派生类对象，先调用基类构造函数输出Base(10)，后调用派生类构造函数输出

Derived(10,20)，后执行(),调用派生类的print，再调用Base::print()输出10，后返回

输出z的值20。后派生类析构，再基类析构。

2. 给出下面程序输出结果。

#include

class test

{int x;

public:

test(int i=0):x(i){}

virtual void fun1()

{cout << "test::x"<

};

class ft:public test

{int y;

public:

void fun1(){cout <<"ft::y="<

ft(int i=2):test(i),y(i){}

};

void main()

{ ft ft1(3);

void (test::*p)();

p=test::fun1;

(ft1.*p)();

}

答案：ft::y=3

［解析］指向函数的指针的使用，p指向fun1函数，（ft1.*p）实际就是调用ft1对象的

fun1（）函数。

1. 给出下面程序输出结果。

#include

class example

{int a;

public:

example(int b=5){a=b++;}

void print(){a=a+1;cout <

void print()const

{cout<

};

void main()

{example x;

const example y(2);

();

();

}

答案：62

［解析］x是普通对象，调用普通的print函数；而y常对象，调用常成员函数。

2. 给出下面程序输出结果。

#include

class A

{public:

A()

{cout<<"A 构造函数＼n";fun();}

virtual void fun()

{cout<<"A::fun() 函数＼n";}

};

class B:public A

{public:

B()

{cout<<"B构造函数＼n";fun();}

void fun() {cout<<"B::fun() calle函数＼n";}

};

void main()

{B d;}

答案：A构造函数

A::fun()函数

B构造函数

B::fun()calle函数

［解析］定义派生类对象，首先调用基类构造函数，调用A类中fun()，然后调用B类的构造函数

，在调用B的fun函数。