C_C++笔试题集锦_(已排版).pdf

《C_C++笔试题集锦_(已排版).pdf》由会员分享，可在线阅读，更多相关《C_C++笔试题集锦_(已排版).pdf（34页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、1.求下面函数的返回值(微软)in t f u n c(x)in t c o u n t x =0;w h il e(x)(c o u n t x +;X =x&(x-l);r e t u r n c o u n t x;假定X =9 9 9 9 o 答案：8思路：将 x 转化为2 进制，看含有的1 的个数。2.什 么 是“引用”？申明和使用“引用”要注意哪些问题？答：引用就是某个目标变量的“别名”(a l ia s),对引用的操作与对变量直接操作效果完全相同。申明 个引用的时候，切记要对其进行初始化。引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，不能再把该引用名作为其他

2、变量名的别名。声明个引用，不是新定义了 个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。不能建立数组的引用。3.将“引用”作为函数参数有哪些特点？(1)传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象(在主调函数中)的操作。(2)使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果

3、传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用 般变量传递参数的效率和所占空间都好。(3)使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用“*指针变量名”的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。4.在什么时候需要使用“常引用”？如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：c o n s t 类型标识符&引用名=目标变量名；例 1in t a ;c

4、o n s t in t&r a=a;r a=l;错误a=l;正确例 2s t r in g f o o();v o id b a r(s t r in g&s);那么下面的表达式将是作法的：b a r(f o o();b a r(h e l l o w o r l d );原因在于f o o()和 h e l l o w o r l d”串都会产生一个临时对象,而在C+中，这些临时对象都是c o n s t 类型的。因此上面的表达式就是试图将一个c o n s t 类型的对象转换为非c o n s t 类型，这是非法的。引用型参数应该在能被定义为c o n s t 的情况下，尽量定义为con

5、 sto5.将“引用”作为函数返回值类型的格式、好处和需要遵守的规则？格式：类型标识符&函数名(形参列表及类型说明)函数体好处：在内存中不产生被返回值的副本；(注意：正是因为这点原因，所以返回 个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生run ti m e error!注意事项：(1)不能返回局部变量的引用。这条可以参照E ffecti ve C+l 的 I tem 3 1。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了”无所指的引用，程序会进入未知状态。(2)不能返回函数内部n ew分配的内存的引用。这条可以参照E ffecti v

6、e C+l 的 I tem 3 1。虽然不存在局部变量的被动销毁问题，可对于这种情况(返回函数内部n ew分配内存的引用)，乂面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间(由n ew分配)就无法释放，造成m em ory l ea k。(3)可以返回类成员的引用，但最好是con st。这条原则可以参照E ffecti ve C+l 的 I tem 3 0。主要原因是当对象的属性是与某种业务规则(b usi n ess rul e)相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务

7、规则当U 。如果其它对象可以获得该属性的非常量引用(或指针)，那么对该属性的单纯赋值就会破坏业务规则的完整性。(4)流操作符重载返回值中明为“引用”的作用：流操作符”和 ，这两个操作符常常希望被连续使用，例如：cout hel l o e n d l;因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括：返回一个流对象和返回个流对象指针。但是对于返回个流对象，程序必须重新(拷贝)构造个新的流对象，也就是说，连续的两个 操作符实际上是针对不同对象的！这无法让人接受。对于返回一个流指针则不能连续使用 操作符。因此，返回个流对象引用是惟选择。这个唯选择很关键，它说明了引

8、用的重要性以及无可替代性，也许这就是C+语言中引入引用这个概念的原因吧。赋值操作符=。这个操作符象流操作符一样，是可以连续使用的，例如：x 二j 二1 0;或者(x=1 0)=1 0 0;赋值操作符的返回值必须是个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。例 3#i nclude ios trea m.hint&put(int n);int va ls 1 0 ;int error=l;void ma inO(put(0)=1 0;以 put(0)函数值作为左值，等价于va ls 0 =1 0;put(9)=2 0;以 put(9)函数值作为左值,等价于va ls 9

9、=2 0;cout va ls 0 ;cout va ls 9 ;)int&put(int n)if(n=0&n=9 )return va ls n;els e cout/s ubs cript error”;return error;(5)在另外的一些操作符 ，却千万不能返回引用：+-*/四则运算符。它们不能返回引用，E ffective C+l的 I tem2 3 详细的讨论了这个问题。主要原因是这四个操作符没有s ide effect,因此，它们必须构造一个对象作为返回值，可选的方案包括：返回一个对象、返回一个局部变量的引用，返回一个new分配的对象的引用、返回个静态对象引用。根据前面提

10、到的引用作为返回值的三个规则，第 2、3两个方案都被否决T o 静态对象的引用又因为(a+b)=(c+d)会永远为true而导致错误。所以可选的只剩下返回一个对象了。6.“引用”与多态的关系？引用是除指针外另一个可以产生多态效果的手段。这意味着，一个基类的引用可以指向它的派生类实例。例 4C la s s A;C la s s B :C la s s A .;B b;A&ref=b;7.“引用”与指针的区别是什么？指针通过某个指针变量指向个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。此外，就是上面提到的对函数

11、传ref和 pointer的区别。8.什么时候需要“引用”？流操作符和、赋值操作符二的返回值、拷贝构造函数的参数、赋值操作符二的参数、其它情况都推荐使用引用。以上 2-8 参考：h t t p:blo g.c s d n.n e t/w f w d/a r c h i v e/2006/05/30/763551.a s p x9.结构与联合有何区别？1 .结构和联合都是由多个不同的数据类型成员组成，但在任何同时刻，联合中只存放了 个被选中的成员(所有成员共用一块地址空间)，而结构的所有成员都存在(不同成员的存放地址不同)。2.对于联合的不同成员赋值，将会对其它成员重写，原来成员的值就不存在了，

12、而对于结构的不同成员赋值是互不影响的。1 0.写出下面关于“联合”的题目的输出？a)#i n c lud e un i o ni n t i;c h a r x 2;a;v o i d m a i n()a.x 0=1 0;a.x l =1;p r i n t f a.i);)答 案:266(低位低地址,高位高地址，内存占用情况是O x O lO A)b)m a i n ()(un i o n /*定义个联合*/i n t i;s t r uc t /*在联合中定义个结构*/c h a r f i r s t;c h a r s e c o n d;(h a lf;n um be r;n um

13、 be r,i =0 x 4241;/*联合成员赋值*/p r i n t f n um be r,h a 1 f.f i r s t,m um be r.h a lf.s e c o n d);n um be r,h a lf.f i r s t=a;/*联合中结构成员赋值*/n um be r,h a lf,s e c o n d=b;p r i n t f n um be r,i);g e t c h O ;)答案：AB(0 x 41对应 A,是低位；0 x 42对应 B,是高位)6261 (n um be r,i 和 n um be r,h a lf 共用一块地址空间)11.已知 s

14、t r c p y 的函数原型：c h a r *s t r c p y(c h a r *s t r D e s t,c o n s t c h a r *s t r S r c)其中 s t r D e s t 是目的字符串，s t r S r c 是源字符串。不调用C+/C的字符串库函数，请编写函数s t r c p y o答案：c h a r *s t r c p y (c h a r *s t r De s t,c o n s t c h a r *s t r S r c)(i f (s t r De s t =N U L L I|s t r S r c =N U L L)r e t

15、 ur n N U L L ;i f (s t r De s t =s t r S r c)r e t ur n s t r De s t ;c h a r *t e m p p t r =s t r De s t ;w h i le(*s t r De s t+=*s t r S r c+)!=0)r e t ur n t e m p p t r ;12.已知S t r i n g 类定义如下：c la s s S t r i n g(p ubli c:S t r i n g (c o n s t c h a r *s t r =N U L L);/通用构造函数S t r i n g (c

16、o n s t S t r i n g&a n o t h e r);/拷贝构造函数 S t r i n g O ;/析构函数S t r i n g&o p e r a t e r =(c o n s t S t r i n g&r h s);/赋值函数p r i v a t e:c h a r *m _ d a t a;/用于保存字符串；尝试写出类的成员函数实现。答案：S t r i n g:S t r i n g(c o n s t c h a r *s t r)(i f (s t r =N U L L )s t r le n在参数为N U L L时会抛异常才会有这步判断(m _ d a

17、t a =n e w c h a r f l;m _ d a t a 0 =0 ;)e ls e(m _ d a t a =n e w c h a r s t r le n(s t r)+1 ;s t r c p y(m _ d a t a,s t r);)S t r i n g:S t r i n g(c o n s t S t r i n g&a n o t h e r)(m d a t a =n e w c h a r s t r le n (a n o t h e r.m _ d a t a)+1 ;s t r c p y (m _ d a t a,o t h e r.m _ d a

18、t a);)S t r i n g&S t r i n g:o p e r a t o r =(c o n s t S t r i n g&r h s)(i f (t h i s =&r h s)r e t ur n *t h i s ;d e le t e n i _ d a t a;删除原来的数据，新开,块内存m _ d a t a =n e w c h a r s t r le n(r h s.m _ d a t a)+1 ;s t r c p y (m _ d a t a,r h s.m _ d a t a);r e t ur n *t h i s ;S t r i n g:S t r

19、 i n g()(d e le t e m _ d a t a ;1 3,h头文件中的ifndef/define/endif的作用？答：防止该头文件被重复引用。1 4.#i n c lud e 与#i n c lud e f i le.h”的区别？答：前者是从S t a n d a r d L i br a r y的路径寻找和引用f i le.h,而后者是从当前工作路径搜寻并引用f i le,h o1 5.在C+程序中调用被C 编译器编译后的函数，为什么要加e x t e r n “C”？首先，作为e x t e r n是C/C+语言中表明函数和全局变量作用范围(可见性)的关键字，该关键字告诉

20、编译器，其声明的函数和变量可以在本模块或其它模块中使用。通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字ex ter n声明。例如，如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样，模块B U 调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但是并不会报错；它会在连接阶段中从模块A编译生成的目标代码中找到此函数ex ter n C”是连接申明(1 i n k age decl ar ati o n),被ex ter n C 修饰的变量和函数是按照C语言方式编译和连接的,来看看C+中对类似C的函数是怎样编译的：作为种面向对象的语言

21、，C+支持函数重载，而过程式语言C则不支持。函数被C+编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：v o i d fo o(i n t x,i n t y );该函数被C编译器编译后在符号库中的名字为_fo o,而C+编译器则会产生像_fo o _i n t_i n t之类的名字(不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“m an gl ed n am e)。_fo o _i n t_i n t这样的名字包含了函数名、函数参数数量及类型信息，C+就是靠这种机制来实现函数重载的。例如，在C+中，函数v o i d fo o(i n t x,i

22、 n t y )与v o i d fo o(i n t x,fl o at y )编译生成的符号是不相同的，后者为_fo o _i n t_fl o at。同样地，C+中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以.来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了 个独无二的名字，这个名字与用户程序中同名的全局变量名字不同。未加ex ter n C”声明时的连接方式假设在C+中，模块A的头文件如下：/模块A头 文 件m o du l eA.h#i fn def M O D U L E _A _Hdefi n

23、e M 0 D U L E _A _Hi n t fo o(i n t x,i n t y );tten di f在模块B中引用该函数：/模块B实 现 文 件m o du l eB.cp p#i n cl u de“m o du l eA.h fo o(2,3);实际上，在连接阶段，连接器会从模块A生成的目标文件m o du l eA.o bj中寻找_fo o _i n t_i n t这样的符号！加ex ter n C声明后的编译和连接方式加ex ter n C声明后，模块A的头文件变为：/模块A头 文 件m o du l eA.htti fn def M O D U L E _A _Hdef

24、i n e M 0 D U L E _A _Hex ter n C i n t fo o(i n t x,i n t y );S en di f在模块B的实现文件中仍然调用fo o (2,3 ),其结果是：(1)模块A 编译生成fo。的目标代码时，没有对其名字进行特殊处理，采用了 C 语言的方式；(2)连接器在为模块B 的目标代码寻找化。(2,3)调用时，寻找的是未经修改的符号名_f。如果在模块A中函数声明了 fo o 为 ex ter n C 类型，而模块B中包含的是ex ter n i n t fo o(i n t x,i n t y ),则模块B 找不到模块A中的函数；反之亦然。所以，可

25、以用一句话概括ex ter n C”这个声明的真实目的(任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题)：实现C+与C 及其它语言的混合编程。明白了 C+中e x te r n C”的设立动机，我们下面来具体分析e x te r n C通常的使用技巧：e x te r n C的惯用法(1)在 C+中引用C 语言中的函数和变量，在包含C 语言头文件(假设为c Ex a mp le.h)时，需进行下列处理：e x te r n(#i nc lud e

26、 c Ex a mp le.h)而在C 语言的头文件中，对其外部函数只能指定为e x te r n类型，C 语言中不支持e x te r n C声明，在.c文件中包含了 e x te r n C时会出现编译语法错误。C+引用C 函数例子工程中包含的三个文件的源代码如下：/*c 语言头文件:c Ex a mp le.h*/#if nd e f C_ EX AM P L E_ H#d e f ine C_ EX AM P L E_ He x te r n int a d d (int x,int y);tte nd if/*c 语言实现文件:c Ex a mp le.c */#i nc lud e

27、 c Ex a mp le.hint a d d(int x,int y )(r e tur n x +y;)/c+实现文件，调用 a d d：c p p F ile.c p pe x te r n C”#i nc lud e “c Ex a mp le.h)int ma in(int a r gc,c ha r*a r gv )(a d d(2,3);r e tur n 0;)如果C+调用一个C 语言编写的.DL L 时，当包括.DL L 的头文件或声明接口函数时，应加e x te r n C 。(2)在 C 中引用C+语言中的函数和变量时，C+的头文件需添加e x te r n 但是在C

28、语言中不能直接引用声明了 e x te r n C 的该头文件,应该仅将C 文件中将C+中定义的e x te r n C 函数声明为e x te r n类型。C 引用C+函数例子工程中包含的三个文件的源代码如下：C+头文件 c p p Ex a mp le.h#if nd e f CP P _ EX AM P L E_ H#d e f ine CP P _ EX AM P L E_ He x te r n C int a d d(int x,int y );tte nd ifC+实现文件 c p p Ex a mp le.c p p#i nc lud e c p p Ex a mp le.hi

29、nt a d d(int x,int y )(r e tur n x +y;)/*C 实现文件c F ile.c */*这样会编译出错：#i nc lud e c Ex a mp le.h */e x te r n int a d d (int x,int y );int ma in(int a r gc,c ha r*a r gv 0)(a d d(2,3);r e tur n 0;1 5 题目的解答请参考 C+中 e x te r n“C”含义深层探索注解。1 6 .关联、聚合(Aggr e ga tio n)以及组合(Co mp o sitio n)的区别？涉及到U M L 中的一些概念

30、：关联是表示两个类的般性联系，比如“学生”和“老师”就是种关联关系；聚合表示ha s-a 的关系，是一种相对松散的关系，聚合类不需要对被聚合类负责，如下图所示，用空的菱形表示聚合关系：从实现的角度讲，聚合可以表示为：c la ss A c la ss B A*a;.而组合表示c o nta ins-a 的关系，关联性强于聚合：组合类与被组合类有相同的生命周期，组合类要对被组合类负责，采用实心的菱形表示组合关系：实现的形式是：c l a s s A .c l a s s B A a;.参考文章：1)h t t p:b l o g.c s d n.n e t/w f w d/a r c h i v

31、 e/2006/05/30/763753.a s p x2)h t t p:b l o g,c s d n.n e t/w f w d/a r c h i v e/2006/05/30/763760.a s p x17.面向对象的三个基本特征，并简单叙述之？1.封装：将客观事物抽象成类，每个类对自身的数据和方法实行p r o t e c t i o n (p r i v a t e,p r o t e c t e d,p u b l i c)2.继承：广义的继承有三种实现形式：实现继承(指使用基类的属性和方法而无需额外编码的能力)、可视继承(子窗体使用父窗体的外观和实现代码)、接口继承(仅使用

32、属性和方法，实现滞后到子类实现)。前两种(类继承)和后一种(对象组合二 接口继承以及纯虚函数)构成了功能复用的两种方式。3.多态：是将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是句话：允许将子类类型的指针赋值给父类类型的指针。18.重 载（o v e r l o a d）和重写（o v e r r i e d,有的书也叫做“覆盖”）的区别？常考的题目。从定义上来说：重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。重写：是指子类重新定义复类虚函数

33、的方法。从实现原理上来说：重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数:f u n c t i o n f u n c（p:i n t e g e r）:i n t e g e r;和 f u n c t i o nf u n c （p:s t r i n g）:i n t e g e r;o那么编译器做过修饰后的函数名称可能是这样的:i n t _f u n c s t r _f u n co对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因

34、此，重载和多态无关！重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。19.多态的作用？主要是两个：1.隐藏实现细节，使得代码能够模块化：扩展代码模块，实现代码重用：2.接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某属性时的正确调用。20.A d o与A d o.n e t的相同与不同？除 了“能够让应用程序处理存储于D B M S 中的数据”这一基本相似点外，两者没有太多共同之处。但是

35、A d o使用O L E D B 接口并基于微软的C O M 技术，而 A D O.N E T 拥有自己的A D O.N E T 接口并且基于微软的.N E T 体系架构。众所周知.N E T体系不同于C O M 体系，A D O.N E T 接口也就完全不同于A D O 和 O L E DB接口，这也就是说A D O.N E T 和 A D O 是两种数据访问方式。A D O.n e t 提供对X M L 的支持。21.n e w d e l e te 与 m a l l o c f r e e 的联系与区别？答案：都是在堆（h e a p）上进行动态的内存操作。用 m a l l o c

36、函数需要指定内存分配的字节数并且不能初始化对象，n e w 会自动调用对象的构造函数。d e l e te 会调用对象的d e s tr uc to r,而 f r e e 不会调用对象的d e s tr uc to r.22.#d e f i n e D O UB L E （x）x+x,i =5*D 0UB L E（5）；i 是多少？答案：i为 3 0。23.有哪几种情况只能用i n ti a l i za ti o n l i s t而不能用a s s i g n m e n t?答案：当类U 含有c o n s t、r e f e r e n c e 成员变量；基类的构造函数都需要初始化

37、表。24.C+是不是类型安全的？答案：不是。两个不同类型的指针之间可以强制转换（用 r e i n te i r r e t c a s t）。C#是类型安全的。25.m a i n函数执行以前，还会执行什么代码？答案：全局对象的构造函数会在m a i n 函数之前执行。26 .描述内存分配方式以及它们的区别？1)从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，s ta ti c 变量。2)在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。3)从堆

38、上分配，亦称动态内存分配。程序在运行的时候用m a l l o c 或 n e w 申请任意多少的内存，程序员自己负责在何时用f r e e 或 d e l e te 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。27 .s tr uc t 和 c l a s s 的区别答案：s tr uc t的成员默认是公有的，而类的成员默认是私有的。s t r uc t 和 c l a s s 在其他方面是功能相当的。从感情上讲，大多数的开发者感到类和结构有很大的差别。感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位，而类就象活的并且可靠的社会成员，它有智能服务，有牢固的封装屏隙和个

39、良好定义的接口。既然大多数人都这么认为，那么只有在你的类有很少的方法并且有公有数据(这种事情在良好设计的系统中是存在的！)时，你也许应该使用s t r uc t 关键字，否则，你应该使用c l a s s 关键字。2 8.当一个类A中没有声明任何成员变量与成员函数，这 时s i ze o f (A)的值是多少，如果不是零，请解释一下编译器为什么没有让它为零。(A ut o d e s k)答案：肯定不是零。举个反例，如果是零的话，声明一个c l a s s A 1 0 对象数组，而每一个对象占用的空间是零，这时就没办法区分A O ,A 1 了。2 9 .在8 0 8 6汇编下，逻辑地址和物理地

40、址是怎样转换的？(I n t e l)答案：通用寄存器给出的地址，是段内偏移地址，相应段寄存器地址*1 0 1 1+通用寄存器内地址，就得到了真正要访问的地址。3 0 .比较C+中的4种类型转换方式？重点是 s t a t i c _c a s t,d yn a m i c _c a s t 和 r e i n t e r p r e t _c a s t 的区别和应用。请参考：ht t p:b l o g,c s d n.n e t/wf wd/a r c hi ve/2 0 0 6/0 5/3 0/7 6 3 7 8 5.a s p x3 1 .分别写出B O O L,i n t,f l

41、o a t,指针类型的变量a与“零”的比较语句。答案：B O O L :i f (!a )o r i f (a)i n t :i f (a =0)f l o a t :c o n s t E X P R E S S I O N E X P =0.0 0 0 0 0 1i f (a -E X P)p o i n t e r :i f (a !=N U L L)o r i f(a =N U L L)3 2.请说出c o n s t与#d e f i n e相比，有何优点？答案：1)c o n s t 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没

42、有类型安全检查，并且在字符替换可能会产生意料不到的错误。2)有些集成化的调试工具可以对c o n s t 常量进行调试，但是不能对宏常量进行调试。3 3 .简述数组与指针的区别？数组要么在静态存储区被创建(如全局数组)，要么在栈上被创建。指针可以随时指向任意类型的内存块。(1)修改内容上的差别c h a r a =h el l o ;a 0 =X;c h a r *p =w o r l d”；注 意p指向常量字符串p 0 =X;编译器不能发现该错误，运行时错误(2)用运算符s i z eo f可以计算出数组的容量(字节数)。s i z eo f(p),p为指针得到的是 个指针变量的字节数，而不

43、是P所指的内存容量。C+/C语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。c h a r a口 =/h el l o w o r l d”;c h a r *p =a;c o u t s i z eo f(a)en dl;/12 字节c o u t s i z eo f(p)en dl;/4 字节计算数组和指针的内存容量v o i d F u n c (c h a r a 100)(c o u t s i z eo f(a)en dl;/4 字节而不是 100 字节34.类成员函数的重载、覆盖和隐藏区别？答案:a.

44、成员函数被重载的特征：(1)相同的范围(在同一个类中)；(2)函数名字相同；(3)参数不同；(4)v i r t u a l关键字可有可无。b.覆盖是指派生类函数覆盖基类函数，特征是：(1)不同的范围(分别位于派生类与基类)：(2)函数名字相同；(3)参数相同；(4)基类函数必须有v i r t u a l关键字。c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：(1)如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无v i r t u a l关键字，基类的函数将被隐藏(注意别与重载混淆)。(2)如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有v i

45、 r t u a l关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)。35.Th er e a r e t w o i n t v a r i a bl es:a a n d b,do nJ t u s e i f,M s w i t c h o r o t h er j u dg em en ts t a t em en t s,fi n d o u t t h e bi g g es t o n e o f t h e t w o n u m ber s.答案：(a +b)+a bs(a -b)/236.如何打印出当前源文件的文件名以及源文件的当前行号？答案：c o u t _F I L

46、 E _;c o u t _L I N E _;_ F I L E _和 _L I N E _是系统预定义宏，这种宏并不是在某个文件中定义的，而是由编译器定义的。37.m ain主函数执行完毕后，是否可能会再执行一段代码，给出说明？答案：可以，可以用_ o n ex i t注册个函数，它会在m a i n之后执行i n t fn l (v o i d),fn 2(v o i d),fn 3(v o i d),fn 4(v o i d);v o i d m a i n(v o i d)(St r i n g s t r(z h a n g l i n );_ o n ex i t(fn l );

47、_ o n ex i t(fn 2);_ o n ex i t(fn 3);_ o n ex i t (fn 4);p r i n t f(Th i s i s ex ec u t ed fi r s t.n，z);)i n t fn l ()(p r i n t f(n ex t.n );r et u r n 0;)i n t fn 2()(p r i n t f(ex ec u t ed );r et u r n 0;)i n t fn 3()(p r i n t f(i s );r et u r n 0;)i n t fn 4()(p r i n t f(Th i s );r et u

48、r n 0;Th e _ o n ex i t fu n c t i o n i s p a s s ed t h e a ddr es s o f a fu n c t i o n (fu n c)t o be c a l l ed w h en t h e p r o g r a mt er m i n a t es n o r m a l l y.Su c c es s i v e c a l l s t o _ o n ex i t c r ea t e a r eg i s t er o f fu n c t i o n s t h a t a r e ex ec u t edi n

49、 L I F O (l a s t-i n-fi r s t-o u t)o r der.Th e fu n c t i o n s p a s s ed t o _ o n ex i t c a n n o t t a k e p a r a m et er s.38.如何判断一段程序是由C编译程序还是由C+编译程序编译的？答案：Si fdef _ c p l u s p l u sc o u t c+；#el s ec o u t c ;t t en di f39.文件中有一组整数，要求排序后输出到另一个文件中答案：#i nc lu d e nc lu d e u s ing name s

50、 p ac e s t d;v oid Or d e r(v e c t or&d at a)/b u b b le s or t(int c ou nt =d at a.s iz e O;int t ag =f als e ;/设置是否需要继续冒泡的标志位f or (int i =0 ;i c ou nt ;i+)(f or (int j=0 ;j d at a j+l)(t ag =t r u e ;int t e mp =d at a j;d at a j=d at a j+l;d at a j+l=t e mp ;)if (!t ag )b r e ak;)v oid main(v o