C++高级编程练习题.docx

C++高级编程练习题.docx

《C++高级编程练习题.docx》由会员分享，可在线阅读，更多相关《C++高级编程练习题.docx（52页珍藏版）》请在冰豆网上搜索。

C++高级编程练习题

1C++语言基础及过程化程序设计

基础概念

1.函数声明和函数定义有什么区别？

答：

1）函数声明是函数的原型，强调函数如何被使用，不包含函数的实现代码；2）函数定义给出函数的实现代码。

char*p1;char*constp2;的区别

答：

1）const位于星号的左侧，const用来修饰指针所指向的变量，即指针指向为常量；2）const位于星号的右侧，const用来修饰指针本身，即指针本身是常量。

与delete[]区别

答：

delete只会调用一次析构函数，而delete[]会调用动态分配的多个对象的析构函数

4.解释堆和栈的区别

答：

1）栈：

由编译器自动分配释放，存放函数的参数、局部变量等。

通常在超出作用域后由系统自动释放。

2）堆：

一般由程序员负责分配与释放，若程序员不释放，占用的内存直到程序结束才由OS回收。

5.在什么时候需要使用“常引用”？

答：

如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。

6.全局变量和局部变量在内存中的区别。

答：

1）全局变量储存在静态数据区，程序加载时分配并初始化，程序结束时释放；2）局部变量在栈中，进入变量作用域后分配，超出其作用域后释放；3）全局变量不初始化会执行缺省初始化，如整型变量缺省初始化为0，局部变量不初始化不会执行缺省初始化，往往为垃圾值。

7.简述内存的分配方式。

答：

1）静态存储区，是在程序编译时就已经分配好的，在整个运行期间都存在，如全局变量、常量。

2）栈上分配，函数内的局部变量和形参在栈上分配。

3）堆上分配，动态分配，用new分配内存，用delete来释放内存。

8.指针的几种典型应用情况。

int*p[n];-----指针数组，每个元素均为指向整型数据的指针。

int（*p）[n];------指向一维数组的指针，这个一维数组含有n个整型数据。

int*p（）;----------返回指向整型指针的函数。

int（*p）（）;------指向函数的指针，要求函数无参并返回整型。

9.说明0、’\0’、’0’、“0”的区别

答：

0表示整数常量，值为0；’\0’表示ASCII码值为0的字符常量；’0’表示ASCII码值为48的字符常量；“0”为字符串常量，其中包含’0’和’\0’两个字符。

10.说明下面程序中存在的问题

#include

intmain（）

{

intarr[10],*p=arr;

inti;

for（;p

cin>>*p;

for（;a

cout<<*arr<<‘0’;

return0;

}

答：

arr为数组名，对应地址不可修改，不能应用++arr运算。

11.有如下定义，请写出访问a[2][3]元素的不同方法

inta[4][5];

int（*p）[5]=a;

答：

a[2][3]、p[2][3]、*（a[2]+3）、*（p[2]+3）、*（*（a+2）+3）、*（*（p+2）+3）

阅读程序

1.写出下面程序的运行结果。

#include

usingnamespacestd;

intmain（）

{

doublenumOne=;

intnumTwo=3;

doublequotient=numOne/2;

cout<<"Quotient:

"<

quotient=numTwo/2;

cout<<"Quotient:

"<

return0;

}

2.写出下面程序的运行结果。

#include

usingnamespacestd;

intmain（）

{

intnumber=103;

intdigit,tens,hundreds;

digit=number%10;

tens=（number/10）%10;

hundreds=（number/100）%10;

cout<<"Hundreds:

"<

"<<

tens<<",Digit:

"<

return0;

}

3.运行下面的程序3次，分别输入90、78、60，写出每次程序执行的输出结果。

#include

usingnamespacestd;

intmain（）

{

intgrade;

cout<<"Enteragrade（1-100）:

";

cin>>grade;

if（grade>=85）

cout<<"Excellent\n";

elseif（70<=grade<85）

cout<<"Pass\n";

else

cout<<"Fail\n";

return0;

}

4.写出下面程序的运行结果。

#include

usingnamespacestd;

boolcheck（intscore,intbaseLine）

{

if（score>=baseLine）

returntrue;

returnfalse;

}

boolcheck（intscore,intbaseLine=60）;

intmain（）

{

intscore=65;

if（check（score）==true）

cout<<"Passed!

\n";

else

cout<<"Failed!

\n";

if（check（score,70）==true）

cout<<"Passed!

\n";

else

cout<<"Failed!

\n";

return0;

}

5.写出下面程序的运行结果。

#include

usingnamespacestd;

intfun（inta）;

doublefun（doublea）;

charfun（chara）;

intmain（）

{

cout<

cout<

cout<

cout<

return0;

}

intfun（inta）{returna/2;}

doublefun（doublea）{returna/2;}

charfun（chara）

{

charresult=a;

if（a>='a'&&a<='z'）

result=a-32;

if（a>='A'&&a<='Z'）

result=a+32;

returnresult;

}

6.写出下面程序的运行结果。

#include

usingnamespacestd;

intgcd（intm,intn）

{

if（n==0）

returnm;

returngcd（n,m%n）;

}

intmain（）

{

cout<<"1:

"<

cout<<"2:

"<

return0;

}

7.写出下面程序的运行结果，假定输入"Hello_123"。

#include

usingnamespacestd;

intmain（）

{

charword[50];

cout<<"Enteraword:

";

cin>>word;

for（inti=0;word[i]!

='\0';++i）

{

if（word[i]>='a'&&word[i]<='z'）

word[i]-=32;

}

cout<<"Uppercase:

"<

return0;

}

8.写出下面程序的运行结果，假定输入"Hello123_World"。

#include

usingnamespacestd;

intmain（）

{

charword[50];

cout<<"Enterastring:

";

cin>>word;

intpos=0;

for（inti=0;word[i]!

='\0';++i）

{

if（word[i]<'0'||word[i]>'9'）

{

word[pos]=word[i];

++pos;

}

}

word[pos]='\0';

cout<<"result:

"<

return0;

}

9.写出下面程序的运行结果。

#include

usingnamespacestd;

intmain（）

{

inti,j;

for（i=0;i<5;i++）

{

for（j=i;j<5;j++）cout<<"*";

cout<

}

return0;

}

10.写出下面程序的运行结果。

#include

usingnamespacestd;

intsum（inta,intb=1,intc=3）

{

returna+b+c;

}

intmain（）

{

intsum（inta,intb=3,intc=4）;

cout<

（2）<

cout<

cout<

return0;

}

11.写出下面程序的运行结果。

#include

usingnamespacestd;

char&elem（char*s,intn）

{

returns[n];

}

intmain（）

{

charstr[]="HelloWorld";

elem（str,1）='A';

cout<

return0;

}

12.写出下面程序的运行结果。

#include

usingnamespacestd;

intx=10;

intmain（）

{

intx=15;

cout<

cout<<:

:

x<

return0;

}

13.写出下面程序的运行结果。

#include

usingnamespacestd;

voidxhg（int*a,int*b）

{

int*tmp;

tmp=b;b=a;a=tmp;

cout<<*a<<''<<*b<

}

intmain（）

{

intx（5）,y（4）;

xhg（&x,&y）;

cout<

return0;

}

14.写出下面程序的运行结果。

#include

usingnamespacestd;

voidxhg（int&a,int&b）

{

inttmp;

tmp=b;b=a;a=tmp;

cout<

}

intmain（）

{

intx（5）,y（4）;

xhg（x,y）;

cout<

return0;

}

15.写出下面程序的运行结果。

#include

usingnamespacestd;

intff（int*a,intsize）

{

if（size==1）

returna[0];

returna[size-1]+ff（a,size-1）;

}

intmain（）

{

inta[5]={1,2,3,4,5};

cout<<“result:

”<

return0;

}

16.写出下面程序的运行结果。

#include

usingnamespacestd;

voidf（conststring&s,intn）

{

cout<

if（n>1）

f（s,n-1）;

}

intmain（）

{

f（"animal",6）;

cout<

f（"hello",3）;

return0;

}

17.写出下面程序的运行结果。

#include

usingnamespacestd;

intfunc（intdata[],intsize）

{

inta=data[0];

intb=data[0];

for（inti=1;i

{

if（data[i]>a）a=data[i];

if（data[i]

}

returna-b;

}

intmain（）

{

inta[]={9,3,2,-1,8,0,4};

cout<

cout<

return0;

}

18.写出下面程序的运行结果。

#include

#include

usingnamespacestd;

voidf（conststring&s,intn）

{

cout<

if（n>1）

f（s,n-1）;

}

intmain（）

{

f（"animal",6）;

cout<

f（"hello",3）;

return0;

}

19.写出下面程序的执行结果。

#include

usingnamespacestd;

intfun（intinterval）

{

intsum=0,i=0;

for（i=0;i<100;i+=interval）

sum+=i;

returnsum;

}

intmain（）

{

cout<<"Result:

"<

（2）<

return0;

}

20.写出下面程序的执行结果。

#include

usingnamespacestd;

doublefunc（doublepData[],intsize）;

intmain（）

{

doublearray[]={,,6,};

cout<<"Result:

"<

cout<<"Result:

"<

return0;

}

doublefunc（doublepData[],intsize）

{

doubleresult=0;

inti;

for（i=0;i

{

result+=pData[i];

}

result/=size;

returnresult;

}

面向对象程序设计

基础概念

1、定义形式如下的类，C++编译器自动为该类产生的四个缺省函数是什么？

写出其原型。

classMyClass

{

public:

voidSetX（int）;

private:

intx;

};

答：

无参构造函数，拷贝构造函数，析构函数，赋值运算符函数。

MyClass（）;

MyClass（constMyClass&）;

~MyClass（）;

MyClass&operator=（constMyClass&）;

2、定义形式如下的类，写出C++编译器自动生成的拷贝构造函数和赋值运算符函数的定义。

classMyClass

{

public:

voidSetX（int）;

private:

intx;

};

答：

MyClass（constMyClass&a）

{x=;}

MyClass&MyClass:

:

operator=（constMyClass&a）

{x=;

return*this;}

3、拷贝构造函数在哪几种情况下会被调用？

答：

1）当类的一个对象去初始化该类的另一个对象时；2）如果函数的形参是类的对象，调用函数进行形参和实参结合时；3）如果函数的返回值是类对象，函数调用完成返回时。

4、构造函数与普通成员函数相比有什么不同？

答：

1）构造函数是类的一种特殊成员函数，一般情况下，它是专门用来初始化数据成员的。

2）构造函数的名字必须与类名相同，它不具有任何返回类型。

构造函数在创建对象时由系统自动调用。

5、创建派生类对象时，构造函数的调用顺序是什么？

答：

1）先调用基类构造函数；2）按定义顺序初始化对象数据成员；3）最后调用本类的构造函数。

6、哪几种情况必须用到初始化成员列表？

答：

1）类的常量数据成员初始化；2）类的引用成员初始化；3）类的对象成员初始化，而该对象没有无参构造函数；4）基类成员初始化，而基类没有无参构造函数。

7、C++头文件中通常会包含哪些内容？

答：

类的定义、常量定义、函数声明、全局变量声明

8、什么是常对象？

答：

常对象是指在任何场合都不能对其成员的值进行修改的对象。

9、什么叫抽象类？

答：

包含纯虚函数的类，不能定义抽象类对象，可以定义抽象类的指针或引用，指向或引用派生类对象。

10、同类对象间是怎样实现数据共享的？

答：

通过类的静态数据成员来实现。

静态数据成员属于类，而不为某个对象所私有，所有实例对象共享类的静态数据成员。

11、函数重载是什么意思？

它与虚函数的概念有什么区别？

答：

1）函数重载是相同作用域内存在多个同名的函数，编译系统在编译阶段通过函数参数个数、参数类型不同来区分该调用哪一个函数，即实现的是静态的多态性，但不能仅仅通过函数返回值不同来实现函数重载。

2）虚函数在基类中通过使用关键字virtual来声明一个函数为虚函数，该函数的功能可能在将来的派生类中重新定义或者在基类的基础之上进行扩展，系统只能在运行阶段才能动态决定该调用哪一个函数，所以实现的是动态的多态性。

12、函数重载与函数覆盖的区别？

答：

1）函数重载是在相同作用域内，存在多个同名的函数，但函数参数或参数类型不同，调用函数时编译器通过实参类型匹配某个函数版本，属于静态多态性；2）函数覆盖指基类和派生类之间存在同名函数，派生类中的函数隐藏了基类的同名函数的现象。

13、构造函数和析构函数是否可以被重载，为什么

答：

构造函数可以被重载，析构函数不可以被重载。

因为构造函数可以带多个参数，而析构函数不能带参数。

14、分析正误：

抽象类不能产生实例，所以不需要有构造函数。

答：

错。

抽象类中可以包含数据成员，派生类对象初始化时需要通过抽象基类的构造函数完成对其数据成员的初始化。

15、一个类的构造函数和析构函数什么时候被调用，是否需要手工调用

答：

构造函数在创建类对象的时候被自动调用，析构函数在类对象生命期结束时。

构造函数和析构函不需要手工调用，由系统自动调用。

16、构造函数和析构函数的调用顺序？

析构函数为什么要定义为虚函数？

答案：

构造函数的调用顺序：

基类构造函数→对象成员构造函数→派生类构造函数；析构函数的调用顺序与构造函数相反：

派生类析构函数→对象成员析构函数→基类析构函数。

析构函数定义为虚函数是为了防止析构不彻底，造成内存泄漏。

17、请说出类中private，protect，public三种访问限制类型的区别

答案：

private是私有类型，只有本类中的成员函数才能访问；protect是保护型的，本类和子类成员函数可以访问；public是公有类型，本类和子类成员函数可以访问，类外部通过对象可以间接访问。

18、Test是一种类类型，现要为其重载前置和后置++运算符，写出它们的原型。

答：

1）前置++：

Test&operator++（）;2）后置++：

Test&operator++（int）

19、说明组合和继承在复用代码方面的区别

答：

组合关系描述的是“有一种”关系，一个对象是另一个对象的一部分；继承关系描述的“是一种”关系，实现对象的层次关系。

20、指出Dog类定义中的错误。

#include

usingnamespacestd;

classDog

{

public:

Dog（）{age=1;weight=10;}

Dog（inta,intw）{age=a;weight=w;}

voidplay（）const{cout<

private:

constintage;

intweight;

};

答：

1）age为常数据成员，不能在构造函数体内赋值，只能通过初始化列表完成初始化；2）play为常成员函数，不能修改数据成员的值。

阅读程序

1、写出程序输出结果

#include

usingnamespacestd;

classBase{

public:

voiddisplay（）{cout<<“Basedisplay”<

};

classDerived:

publicBase{

public:

voiddisplay（）{cout<<“Deriveddisplay”<

};

voiddisplay（Base&rr）

{

（）;

}

intmain（）

{

Baseb;

Derivedd;

display（b）;

display（d）;

return0;

}

2、写出程序输出结果

#include

usingnamespacestd;

classPerson

{

public:

Person（）

{

cout<<“Person构造函数!

”<

}

~Person（）{

cout<<“Person被析构!

”<

}

};

classStudent:

publicPerson

{

public:

Student（）{cout<<“Student构造函数!

”<

~Student（）{cout<<“Student被析构!

”