计算机科学C考试复习题

1.类定义的关键字是.（class）

2.类的访问权限有、、和___三种.（private、public、protected）

3.类的成员分为—和—.（数据成员、成员函数）

4.运算符—与类的对象一起使用，运算符—与指向类的对象的指针一起使用，可以访问类的

成员.（.、-＞）

5.类成员的默认访问方式是一.（私有的）

6.要存取类内的私有成员，需要一个界面，称为一.（接口）

7.类完成了面向对象程序设计的—特性.（封装）

8.类的变量称为一.（对象）

9.同一个类的两个对象，其数据成员是不同的，但是共享的.（成员函数）

10.一个一和—的关系，正如基本数据类型与该类型的变量一样，如intx;.（类、对象）

11.—是用来初始化类的数据成员的一种特殊的成员函数。（构造函数）

12.一个类有一个构造函数，有一个析构函数。（多、一）

13.构造函数是—被创建时自动执行，对象消失时自动执行的成员函数称为—.（对象、析构

函数）

14.设p是指向一个类动态对象的指针变量，则执行“deletep;”语句时，将自动调用该类的一

（析构函数）

15.对一个类中的数据成员的初始化可以通过构造函数中的实现，也可以通过构造函数的—

_实现.（初始化表、函数体）

16.拷贝构造函数的参数通常是一.（某个对象的引用名）

17.类中常展数据成员的初始化工作必须在—完成.（构造函数初始化表）

18.类中对象数据成员的初始化工作必须在—完戌.（构造函数初始化表）

20.类有两种用法：一种是类的实例化，即生成类的对象；另一种是通过一派生出新的类.（继

承）

21.如果类A继承了类B,则类A称为一，类B称为—.（派生类、基类）

22.C++语言提供的—机制允许一个派生类继承多个基类，即使这些基类是相互无关的.（多

重继承）

23.面向对象程序设计的3大机制为；、、.（封装、继承、多态）

24.如果一个特定的类型S当且仅当它提供了类型T的行为时，则称类型S是类型T的—.（子

类型）

25.声明虚函数的方法是在基类的成员函数原型前加上关键字—.（virtual）

26.在编译时就解决的函数调用称为一联编；在运行时才解决的函数调用称为一联编.（静态、

动态）

27.一是一个在基类中说明的虚函数，但未给出具体的实现，要求在其派生类实现.（纯虚函数）

28.在类定义中，将—置于虚函数的函数原型的末尾可以声明该函数为纯虚函数.（=0）

29.如果一个类中有一个或多个纯虚函数，则这个类称为—.（抽象类）

30.类的静态成员分为一和.（静态数据成员、静态成员函数）

31.静态数据成员在定义或说明时，前面要加上关键字—.（static）

32.类的一成员函数不能对类中的非静态成员进行默认访问.（静态）

33.类的—数据成员是类的所有对象共享的成员.（静态）

34.如果成员函数不需要访问类的—成员，则可以把它声明为静态成员函数.（非静态）

35.友元可以是一，也可以是一.（友元函数、友元类）

36.友元函数一类的成员函数.（是/不是）

37.友元函数的声明可以放在类的一部分，也可以放在类的一部分，它们是没有区别的.（私

有、公有）

38.若需要把一个函数"voidfun。；”定义为一个类A的友元函数，则在类A的定义中加入一条语

句:.（friendvoidfun（）;）

第1页共24页

39.如果说明类B是类A的友元类，则类B的所有戌员函数都是类A的一.（友元函数）

40.类中可以有许多用同名称、但参数类型或个数不同的成员函数，称为一.（函数重载）

41.设a和b是两个整型变量，我们用a+b的形式求这两个变量的和；设c和d为浮点型变量，

我们用c+d的形式求这两个变量的和.显然运算符“一”具有不同的用途，这是一的例子.（运算

符重载）

42.运算符函数中的关键字是—，它和运算符一起组成该运算符函数的函数名.（operator）

43.类中运算符重载一般采用两种形式：—和一.（成员函数、友元函数）

44.运算符重载后，原运算符的优先级和结合性—改变.（会/不会）

45.对于双目运算符，若重载为类的成员函数，有一个参数：若重载为友元函数，则有一个

参数.（1、2）

46.执行语句"x=（a=4,b=a++）;w后，变量x、a、b的值依次为。4,5,4

47.表述“x或y中有一个大于z”的C++语言表达式是—ox>z||y>z

48.执行语句"y=（x=3,z=--x）;"后，变量的值依次为o2,2,2

49.设x为整型变量，表达数学关系式：13vxv19的C++语言表达式是oIKx&&x>19

50.设有代码staticinta[3][4]={{1,2},{3},{4,5,6）};M则a[l]⑴值为。0

51.若有定义：charu;intb;floatv;doubled;

则表达式u*b+d-v的值的类型为1>double

52.类的构造函数的主要作用是__________。对对象进行初始化

53.C++将类继承分为和两种。单一继承，多重继承

54.派生类可以定义其中不具备的数据和操作。基类

55.operaior是C++的一个关键字，它经常和C++的一个运算符连用，构成一个运算符函数名。运

算价函数的返I川类型不能是类型。void

56.在继承机制下，当对象消亡时，编译系统先执行的析构函数，然后再执行的析

构函数。派生类，基类

57.C++文件的两种类型，分别是和。字符文件，二进制文件

58.在保护继承关系下，基类有公有成员和保护成员将成为派生类中的成员，它们只

能由派生类的来访问。保护，成员

59.在私有继承关系下，基类的公有成员和保护成员将成为派生类中的成员，它们只能

由来访问。私有派生类的成员函数

60.类的成员函数可以在定义，也可以在定义。类体内类体

处

选择题

1.下列变量名中，（B）是合法的。

A.56AB.abcC.d-PtrD.while

2.下列各种运算符中，（A）优先级最高。

A.+B.&&C.==D.*=

3.设变量in,n,a,b,c,d均为0,执行（m=a==b}&&（n=c==d）后，m,n的值是（I））。

A.0,0B.0,1C.1,0D.1,1

4.字符串“\t\v\\\0which\n”的长度是（B）。

A.4B.3C.9D.字符串有非法字符，输出值不确定

5.设a=2,b=3,c=2；计算a+=b*=（++b-c++）中a、b、c的值（C）«

A.8、6、2B.2、4、2C.10、8、3D.5、3、3

6.己知：inti=5,下列do-while循环语句的循环次数为（D）。

do{cout«i―<<endl;

i—；

}while（i!=0）;

A.0B.1C.5I）.无限

7.下面关于循环语句的描述中，（B）是错误的。

A.循环体内可以包含有循环语句

B.循环体内必须同时出现break语句和continue语句

C.循环体内用以出现选择语句

D.循环体内可以是空语句

8.下面程序段(B)。

do

{y=x—;

if(!y){cout«wx"；continue;}

cout<<w#'>;}

while(x>=l&&x<=2);

A.将输出##B.将输出

C.是死循环D.含有不合法的控制表达式

9.在函数的定义格式中，下面各组成部分中，(D)是可以省略的。

A.函数名B.函数体C.函数数据类型说明D.函数参数

10.在函数的引用调用时，实参和形参应该是使用(C)。

A.变量值和变量B.地址值和指针C.变量值和引用D.地址值和引用

11.以下关于文件操作的叙述中，不正确的是(B)o

A.打开文件的目的是使文件对象与磁盘文件建立联系

B.文件读写过程中，程序将直接与磁盘文件进行数据交换

C.关闭文件的目的之一是保证将输出的数据写入硬盘文件

I).关闭文件的目的之一是释放内存中的文件对象

12.若有语句inta[10]={0,l,2,3,4,5,6,7,8,9},*p=a；贝ij(B)不是对a数组元素的正确引

用(其中0Wi<10)。

A.p[i]B.*(*(a+i))C.a[p-a]D.*(&a[i])

13.以下程序的输出结果是(A)。

#include<iostre<im.h>

voidmain()

{chars[]="a匕cdefbcde",*p=s;

intvl=0,v2=0,v3=(),v4=0;

for(p;*p;p++)

switch(*p)

(

case'a:vl++;break;

case'b':v3++;break;

case'e':v2++;break;

default:v4++;

)

cout«vl«\，，«v2«",//«V3«",\<v4«endl;

)

A.1,2,2,5B.4,7,5,8C.1,5,3,10D.8,8,8,8

14.下列结构体定义，正确的是C

A.record(B.bliuulieuoid{

intno;intno;

charnum[16];charnum[16];

floatscore;floatscore;

)；)

C.structrecord{D.structrecord{

intno;intno

charnum[16];charnum[16]

floatscore;floatscore

)；)

15.下列是构造函数的痔点，(C)是错误的。

A.构造函数是一种成员函数，它具有一般成员函数的特点

B.构造函数的名称与其类名相同

C.构造函数必须指明其类型

D.一个类中可定义一个或多个构造函数

16.关于友元函数的描述中，（A）是错的。

A.友元函数是成员函数，它被说明在类体内

B.友元函数可直接访问类中的私有成员

C.友元函数破坏封装性，使用时尽量少用

D.友元类中的所有成员函数都是友元函数

17.下列对派生类的描述中，（C）是错误的。

A.一个派生类可以作为另一个派生类的基类

B.派生类至少应有一个基类

C.基类中成员访问权限继承到派生类中都保持不变

D.派生类的成员除了自己定义的成员外，还包含了它的基类成员

18.C++类体系中，能被派生类继承的有（B）。

A.构造函数B.虚函数C.友元函数I）.析构函数

19.关于下列虚函数的描述中，（C）是正确的。

A.虚函数是•个static存储类的成员函数

B.虚函数是一个非成员函数

C.基类中说明了虚函数后，派生类中将其对应的函数可不必说明为虚函数

I）.派生类的虚函数与基类的虚函数应具有不同的类型或个数

20.以下有美静态数据成员函数的叙述不正确的是（B）。

A.静态成员函数属于整个类

B.对静态成员函数的弓用不允许使用对象名

C.在静态成员函数中不能直接引用类的非静态成员

D.使用类名可以直接调用其静态成员函数

21.下列有关运算符重载的描述中，（B）是正确的。

A.运算符重载可改变其优先级B.运算符重载不改变其语法结构

C.运算符重载可改变其结合性D.运算符重教可改变其操作数的个数

22.对new运算符的下列描述中，（B）是错误的。

A.它可以动态创建对象和对象数组

B.用它创建对象数组时必须指定初始值

C.用它创建对象时要调用构造函数

D.用它创建的对象可以使用运算符delete来释放

23.下列是为字符数组赋字符串的语句组，其中错误是（A）。

A.chars[10];s=“programv;B.chars[]=wprogramw;

C.chars[10]=wHello!n;D.chars[10];strcpy（s,whello!n）;

24.当调用函数时，实参是一个一维数组名a,则向函数传送的是（D）。

A.数组的长度B.数组所有元素的值

C.数组元素a[0]的值D.数组元素a[0]的地址

25.下列有关类的说法不正确的是（C）。

A.对象是类的一个实例

B.任何一个对象只能属于一个具体的类

C.一个类只能有一个对象

D.类与对象的关系和数据类型与变量的关系相似

123456789101112131415

BA0BCDBBDCBBACC

16171819202122232425

ACBCBBBADC

1.下列字符列中，可作为C++语言程序自定义标识符是(B)0

A.switchB.fileC.breakD.do

2.运算符+、<=、=、%中，优先级最低的运算符是(C)。

A.+B.<=C.=I).%

3.设变量m,n,a,b,c,d均为0,执行(m=a==b)|(n=c==d)后，m,n的值是(C)。

A.0,0B.0,1C.1,0D.1,1

4.字符串“vm\x43\\\np\102qu”的长度是(B)o

A.8B.9C.16D.17

5.设有代码“inia=6;"，则执行了语句“a+=a-=a*a；w后，变量a的值是(D)。

A.0B.-24C.-40C.-60

6.voidmainO

{intx=-l;

do

{x=x*x;}

while(!x);)

下列说法正确的是(

A.是死循环B.循环执行两次

C.循环执行一次0.有语法错误

7.下面有关for循环的正确描述是(D

A.for循环只能用于循环次数已经确定的情况

B.for循环是先执行循环体语句，后判断表达式

C.在for循环中，不能用break语句跳出循环体

D.for循环的循环体语句中，可以包含多条语句，但必须用大括号括起来

8.下面程序段(C

do

(y=x—；

if(!y)(cout«Mx”；continue;}

cout<<w#";}

while(K=x<=2);

A.将输出##B.将输出##*

C.是死循环D.含有不合法的控制表达式

9.以下正确的说法是(D),.

A.用户若需要调用标准函数，调用前必须重新定义

B.用户可以直接调用所有标准库函数

C.用户可以定义和标准库函数重名的函数，但是在使用时调用的是系统库函数

D.用户可以通过文件包含命令将系统库函数包含到用户源文件中，然后调用系统库函数

10.在参数传递过程中，对形参和实参的要求是(B)o

A.函数定义时，形参一直占用存储空间

B.实参可以是常量、变量或表达式

C.形参可以是常量、变量或表达式

D.形参和实参类型和个数都可以不同

11.对数组名作函数的参数，下面描述正确的是(B)。

A.数组名作函数的参数，调用时将实参数组复制给形参数组

B.数组名作函数的参数，实参数组和形参数组共用一段存储单元

C.数组名作参数时，形参定义的数组长度不能省略

D.数组名作参数，不能改变主调函数中的数据

12.若有语句inta[10]={0,l,2,3,4,5,6,7,8,9},*p=a；则(B)不是对a数组元素的正确引

用(其中0Wi<10)«

A.p[i]B.*(*(a+i))C.a[p-a]D.*(&a[i])

13.以下程序的输出结臭是(B)。

#include<iostrcam.h>

voidmain()

{chars[]="12134211”,*p;

intvl=0,v2=0,v3=0,v4=0;vlv2v3v4

for(p=s;*p;p++)2434

switch(*p)

(

case'f:vl++;

case'3':v3++;

case'2':v2++;

default:v4++;

}

cout<〈vl<<〃，"<<v3<<〃，"<<v4«endl;

}

A.4,2,1,1B.4,7,5,8C.7,3,2,1D.8,8,8,8

14.下列声明结构体变量错误的是（C)o

A.structstudentB.structstudent

{intno;{intno;

charname[16];charname[16];

}stl,st2;}；

btLuulbtudeul5tl,

C.structstudentD.structstudent

{intno;{intno;

charname[16];charname[16];

）；）；

structstl,st2;studentst1,st2;

15.对类的构造函数和析构函数描述正确的是（A）。

A.构造函数可以重载,析构函数不能重载

B.构造函数不能重载,析构函数可以重载

C.构造函数可以重载,析构函数也可以重载

D.构造函数不能重载,析构函数也不能重载

16.下面对于友元函数描述正确的是（C

A.友元函数的实现必须在类的内部定义B.友元函数是类的成员

C,友元函数破坏了类的封装性和隐藏性D.反元函数不能访问类的私有成员

17.派生类的对象对它的基类成员中（A）是可以访问的。

A.公有继承的公有成员B.公有继承的私有成员

C.公有继承的保护成员D.私有继承的公有成员

18.C++类体系中，不能被派生类继承的有（A）。

A.构造函数B,虚函数C.静态成员函数D.赋值操作函数

19.以下（C）成员函数表示纯虚函数。

A.virtualintvl（int）;B.voidvt（int）=O;

C.virtualvoidvf（）=0;D.virtualvoidvf（int）{};

20.下面对静态数据成员的描述中，正确的是（B）。

A.静态数据成员可以在类体内进行初始化

B.静态数据成员不可以在类的构造函数中进行初始化

C.静态数据成员不能受private控制符的作用

1）.静态数据成员不可以用对象调用

21.继承具有（B）,即当基类本身也是某一个类派生类时，底层的派生类也会自动继承间接基类

的成员。

A.规律性B.传递性C.重夏性D.多样性

22.若有以下定义，则释放指针所指内存空间的操作是（C）。

floatr=newsfloat[10];

A.deleter;B.delete*r;

C.delete匚r;D.deleter[];

23.若有以下定义，则芯字符串的操作错误的是（C）。

chars[10]=/,Prograni/,,t口:"test";

A.strcpy(s,t);B.cout«strlen（s）;

C.strcat(''this”,t);D.cin»t;

24.在if语句中的表达式是(I））o

A.只能是表达式B.只能是关系表达式和逻辑表达式

C.只能是逻辑表达式D.可以是任意表达式

25.在用关键字class定义的类中，以下叙述正确的是（A）。

A.在类中，不作特别说明的数据成员均为私有类型

B.在类中，不作特别说明的数据成员均为公有类型

C.类成员的定义必须是成员变量定义在前，成员函数定义在后

I).

程序阅读与分析

1.函数fun用以求某正整数的阶乘值。

ttinclude<iostream.h>

voidfun(n)\\doubJefun(Yz?tn)

{inti;

doublef=0;\\doublef=/.0;

if(n<0)

{cout«?，DataError!

return-1;

)

for(i=l;i<=n\i+-)

f=f*i;

returnf;

)

voidmainO

{intn;

cout«，zInputn:";

cin>>n;

cout<<n<<"!="<<fun(n)<<endl;

)

2.将一维数组按升序排列。

#include<iostream.h>

voidsort(intp,intn)\\voidsort(intp[],intn)

{inti,j,temp;

for(i=l;i<n-l;i++)

for(j=i;j<n;j++)

if(p[i]>p[jl)

{temp=p[i];p[i]=p[j]；p[j]=temp;}

)

voidmain(void)

{intal[6]={l,3,2,5,4,6},*pi,i;

pi=al[0];\\pi=al;

sort(pi,6);

for(i=0;i<6;i++)cout«al[i]«，\t*;

cout«endl;

)

3.#include<iostream.h>

classone

{public:

intal=0,a2;\\intal,a2;

voidinitial(intxl,intx2)\\(?/7edntxl,intx2)

{al=xl:

a2=x2;

)

}；

voidmainO

(onedata(2,3);

cout«data.al<<cndl;

cout«data.a2«endl;

}

4.#include<iostream.h>

^include<conio.h>

#include〈math.h>

classTpoint{

doublex,y;

public:

Tpoint(doublea,doubleb)

(x=a;y=b;}

frienddoubledistance(Tpointa,Tpointb);

)；

doubleTpoint::distance(Tpointa,Tpointb)\\doubled/s£a〃ce(Tpointa,Tpointb)

{doubledist;

dist=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));

returndist;

}

voidmainO

{Tpointpl(2,2),p2(5,5);

cout<<”上述两点之间的距离："<<pLdistance(pl,p2)«cndl;\\cout<<“上述两点之间的距

离:"<<distance(pl,p/〈<endl;

getchO;

)

5.下列程序求字符中长度。

#include<iostrcam.h>

intfun(Mars)//*sors[]

{inti=0;

while(s[i]\=,\nr)//\0

■++；}

returni;

)

voidmain()

{chars[80];

cin.getline(s,80):〃读一行字符

cout«/，length:*«fun(s)<<endl;)

6.下列程序功能是求x的y次方(缺省是x的2次方)

#include<iostrean.h>

doublefun(doublex,double回//fun(doub1cx,doubley=2)

{inti;

doubles=l;

3//(i=0;i<y;i++)cr(i=l;i<=y;i++)

s=s*x;

returns;

)

voidmain()

{doublex=2.5,y=3;

cout«*pow(2.5,2):"«fun(x)<<endl;

cout<<，，pow25,3):"<<fun(x,y)«endl;

)

7.#include<iostream.h>

classPoint

{private:

intx,y;

public:〃插入

-oid加”(inta,intb)//Point

{x=a;y=b;}

voidshow")

{cout«"x="«x«"y="«y«endl;}

)；

voidmain()

{Pointa(24,50);

a.show();

)

8.#include<iostream.h>

classAmplifier(

floatinvoLoutvol;

public:

Amplifier(floatvin,floatvout)

{invol=vin;ouivol=voui;}

floatgain();

)；

Amplifier::float火ain(1//floatAmplifier::gain()

{returnoutvol/invol;

)

voidmain()

{Amplifieramp(5.0,100);

coul〈v=\n\nThegainis=>"vv5，1/")vvendl;//amp.gain()

9.#include<iostrecin.h>

voidmain()

{intI;

for(I=l;K=5;I++)

switch(I%2)

{case0:I++;cout<<break;

case1:I+=2;cout<<“*"；

default:cout<<"\n"；}}

10.^include<iostream.h>

voidfun();

intn=5;

voidmain()

{intn=10:

cout<<n«cndl;

fun();

)

voidfun()

{cout<<n«endl;

)

11.#include<iostream.h>

intb=5;

intfun(intn);

voidmain()

{inti;

for(i=0;i<：3;i++)

{cout«fun(i)«endl;}

)

intfun(intn)

{statica=l;

intc=10;

a=a+100;

b=b+100;

c=c+100;

returna+b+c;

)

12.ttinclude<iostream.h>

intgcd(intm,intn)

{if(m%n==0)returnn;

elsereturnged(n,m%n);

)

voidmain()

{intx=40,y=116;

cout<<gcd(y,x)<<endl;

)

13.#include<iostream.h>

#include<conio.h>

classPoint(

intx,y;

public:

Point(){x=l;y=l;}

Point(inttx,intty)

{x=lx;y=ly;}

-Point(){cout«"Point"«x«\,«y«uisdeleted."«endl;}

1；

voidmain()

{Pointobj1;

Pointobj2(10,20);}

14.#include<iostream.h>

classcount

{staticintn;

public:

counl()

{n十十；}

voidshow()

{cout«n«endl;}

-count()

{cout«n«endl;n—;

)

)；

intcount::n=0;

voidmain()

{counta;

a.show();

{countb[4J;

b[3].show();

)

a.show();

)

I.运行结果：

*

#

2.运行结果：

10

5

3.运行结果；

316

516

716

4.运行结果：

4

5.运行结果：

Point10,20isdeleted.

Point1,1isdeleted.

6.运行结果：

I

5

5

4

3

2

1

1

15.#include<iostream.h>

voidmain()

{intn=0,j=0,s=0:

for(inti=8;i<=20;i++)

{n++;i++;

if(i%4==0)

j++；

else

s++;

}cout<〈"n="〈<n〈<'\n'〈<"i="<<i<<'\n'<<"s=〃<<s;

)

16.#include<iostream.h>

voidfun(inii);

voidmain()

{intn;

for(n=l;n<5:n++)fun(n);

)

voidfun(inti)

{statics=0;

s+=i;

cout«s«endl;

)

17.irinclude<iostream.h>

voidmainO

{inti,a[]=(l,2,3,4,5,6,7,8},*p=a;

for(i=l;i<5;i++)

p[i]=a[i-l]+a[i+l]:

cout«a[3]«endl;

)

18.classmystr

{charstring[81];intIon;

public:

mystr(char*s){strcpy(string,s);)

voidgetvalue(char*s,int&n)

{strcpy(s,string);n=len;)

friendmystropcrator+(mystra,mystrb)

{mystrcr");

strcpy(c.string,a.string);

strcat(c.string,b.string);

c.len=strlen(c.string);

returnc;}

}；

voidmain()

{charst[81];int1;

mystra("Heilo"),b("everybody!"),c("");

c=a+b;

c.getvalue(st,1);

cout«st<〈endl〈<"Len="<<l<〈endl;

}

19.ttinclude<iostream.h>

#include<conio.h>

intcount=0;

classPoint{

intx,y;

public:

Point(){x=l;y=l;count++;}

"Point(){count­;}

friendvoiddisplay();

)；

voiddisplay()

{cout<<，/Thoreare，，<<count<<，/points,/z<<endl;}

voidmain()

{Pointa;

display();

(Pointb[5]:

display();

display();

)

2().^include<iostream.h>

classbase

{public:

virtualvoidshow()

{cout«,，classbaseshow()iscalled.\n”;}

}；

classderived:publicbase

{public:

voidshow()

{cout<<*classderivedshow()iscalled.\n”;}

)；

voiddisplay(base*obj)

{obj->show();)

voidmain()

{basedemol;

deriveddemo2;

display(&demol);

display(&demo2);

)

1.n=7

i=22

s=7

2.1

3

6

10

3.13

4.Helloeverybody!

Len=16

5.Thereare1points,

Thereare6points,

Thereare1points,

6.classbaseshow()iscalled,

classderivedshow。iscalled.

1.下面的程序实现输出x,y,z三个数中的最大值，请填入正确的内容。

#include<iostream.h>

voidmain()

{intx=5,y=8,z=9,u,v;

if((1))u=x;

elseu=y;

if((2))v=u;

elsev=z；

cout«,,v=,5«v«endl;

)

2.下面程序是输出10()以内能被7整除且个位数是4的所有整数，请填空:

#include<iostream.h>

voidmain()

{inti,j;

for(i=0;(1):i++)

{j=i*10+4;

if(⑵)

continue;

⑶

cout«j«endl;

})

3.下列函数sw叩实现数据交换功能功能，请填空。

#inckide<ioslream.h>

voidswap(int*p,int*q)

{inttemp;

temp=*p;

voidmain()

{inta,b;

int*pl,*p2;

coutvv”请输入两个正数：”；

cin»a»b;

pl=&a;

p2=&b;

swap(pl,p2);

coutvv”结果a和b的值:"«a«'\H«b«endl;

)

4.下面是计算并输出矩阵每一行的元素之和的程序。

#include<iostream>

usingnamespacestd;

voidRowSum(intA[][4],(I))

{intsum;

for(inti=0;i<nrow;i++)

{

⑵；

for(intj=0;j<4;jiI)

sum+=A[i][j];

cout«"Sumofrow"«i

«"is"«sum«endl;

A[i][0]=sum;

)

)

voidmain(void)

{intTablc[3][4]={{1,2,3,4},{2,3,4,5},{3,4,5,6});

for(inii=0;i<3;i++)

{for(intj=0;j<4;j++)

cout«Table[i][j]«H"；

cout«endl;

}

RowSum((3),3);

for(inti=0;i<3;i++)

cout«Table[i][0]

)

5.已知一个类的定义如下：

#inc1ude<iostream.h>

classAA{

inta[10];

intn;

public:

voidSetA(intaa[],intnn);//用数组aa初始化数据成员a,用nn初始化数据成员n

intMaxAO;〃从数组a中前n个元素中查找并输出最大值

voidSortAO;〃采用选择排序的方法对数组a中前n个元素，进行从小到大排序

)；

该类中MaxAO函数的实现如下，请在标号位置补充适当的内容。

int____(1)_____

intx=a[0];

for(inti=l;i<n:i++)

if(a[i]>x)—(2)—;

—(3);

}

6.声明一个哺乳动物Mammal类，再由此派生出狗Dog类，二者都定义Speak()成员函数，基类中

定义为虚函数。声明一个Dog类的对象，用指向Mammal的指针调用Speak()函数。

程序：

#include<iostream.h>

classMammal

{public:

Mammal(){cout<<，，cal1Mammal"<<endl;}

⑴{cout«Acallbaseclass*<<endl;}

}；

classDog:publicManmal

{public:

Dog(){cout«*cal1Dog\n”;}

voidspeak()[cout«z，callDogclass'n";}

}；

voidmain()

{Mammal*pm,a;

a.speak();

Dogb;

pm二&b;

⑵；

)

1.(l)x>y(2)u>z

2.(l)i<=9或ivlO(2)j%7!=0(3)else

3.(1)*p=*q(2)*q=tcmp

4.(1)intnrow(2)sum=0(3)Table

5.(1)AA::MaxA()(2)x=a[i](3)cout<<x<<endl;

6.(1)virtualvoicspeak()(2)pm-->speak()

1.输入一个字母，如果它是一个大写字母，则把它变成小写字母；如果它是一个小写字母，则把它

变成大写字母：其它字符不变。填入正确内容。

#include<iostrcam.h>

voidmain()cin»ch;

{charch;if((1))ch=ch+32;

elseif(ch>='a,&&chv='z')

__(2)；

cout«ch«endl;

)

2.计算1〜20之间偶数之和，请填充：

#includc<iostrcam.h>

voidmain()

{inta,b,i;

a=0;b=0;

for(i=0;⑴：i+=2)

{a+=i;

—(2)_；

⑶；

cout«”偶数之和为：,,«a«endl：

}

3.读入三个浮点数，将整数部分和小数部分分别输出

#include<iostream>

usingnamespacestd;

voidsplitfloat(floatx,int*imparl,float*fracparl)

{*intpart=int(x);

*fracpart=(I);

)

voidmain(void)

(

inti,n;

floatx,f;

cout«"Enterthreefloatingpointnumbers"«endl;

for(i=0;i<3;i++)

{

cin»x;

splitfloat(x.&n.(2)):

cout«"IntegerPartis"«n«"FractionPartis'*«f«endl;

)

I

4.下面的程序是实现矩阵的转置：

^include<iostream>

usingnamespacestd;

voidmain()

(

inti,j,k,seed;

(1);

cin»seod;

srand(seed);

cout«"产生的矩|性的为："<<ondl;

for(i=0;i<3;i++)

{for(j=0;j<3;j++)

{data[i][j]=rand()%100;

cout«data[i][j]<<"";}

⑵；)

for(i=0;i<3;i++)

for(j=0;j<i;j++)

(

k=data[i][j];