C++面试试题

1.求下面函数的返回值（微软）

int func(x)

{

 int countx = 0;

 while(x)

 {

 countx ++;

 x = x&(x-1);

答：引用就是某个目标变量的“别名”(alias)，对应用的操作与

对变量直接操作效果完全相同。申明一个引用的时候，切记要

对其进行初始化。引用声明完毕后，相当于目标变量名有两个

名称，即该目标原名称和引用名，不能再把该引用名作为其他

变量名的别名。声明一个引用，不是新定义了一个变量，它只

表示该引用名是目标变量名的一个别名，它本身不是一种数据

类型，因此引用本身不占存储单元，系统也不给引用分配存储

单元。不能建立数组的引用。

3. 将“引用”作为函数参数有哪些特点？

（1）传递引用给函数与传递指针的效果是一样的。这时，被

参变量的副本；如果传递的是对象，还将调用拷贝构造函数。

因此，当参数传递的数据较大时，用引用比用一般变量传递参

数的效率和所占空间都好。

（3）使用指针作为函数的参数虽然也能达到与使用引用的效

果，但是，在被调函数中同样要给形参分配存储单元，且需要

重复使用"*指针变量名"的形式进行运算，这很容易产生错误

且程序的阅读性较差；另一方面，在主调函数的调用点处，必

须用变量的地址作为实参。而引用更容易使用，更清晰。

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

如果既要利用引用提高程序的效率，又要保护传递给函数的数

a=1; //正确

例 2

string foo( );

void bar(string & s);

那么下面的表达式将是非法的：

bar(foo( ));

bar("hello world");

C++中，这些临时对象都是 const 类型的。因此上面的表达式

就是试图将一个 const 类型的对象转换为非 const 类型，这是非

法的。

引用型参数应该在能被定义为 const 的情况下，尽量定义为

const 。

5. 将“引用”作为函数返回值类型的格式、好处和需要遵守的规

则?

格式：类型标识符 &函数名（形参列表及类型说明）{ //函数

体 }

好处：在内存中不产生被返回值的副本；（注意：正是因为这

点原因，所以返回一个局部变量的引用是不可取的。因为随着

该 局 部 变 量 生 存 期 的 结 束 ， 相 应 的 引 用 也 会 失 效 ， 产 生

runtime error!

+[1]的 Item 31。主要原因是局部变量会在函数返回后被销毁，

（2）不能返回函数内部 new 分配的内存的引用。这条可以参

照 Effective C++[1]的 Item 31。虽然不存在局部变量的被动销

毁问题，可对于这种情况（返回函数内部 new 分配内存的引

用），又面临其它尴尬局面。例如，被函数返回的引用只是作

为一个临时变量出现，而没有被赋予一个实际的变量，那么这

个 引 用 所 指 向 的 空 间 （ 由 new 分 配 ） 就 无 法 释 放 ， 造 成

memory leak。

（3）可以返回类成员的引用，但最好是 const。这条原则可以

参照 Effective C++[1]的 Item 30。主要原因是当对象的属性是

常量引用（或指针），那么对该属性的单纯赋值就会破坏业务

流操作符<<和>>，这两个操作符常常希望被连续使用，例如：

个仍然支持这两个操作符的流引用。可选的其它方案包括：返

回一个流对象引用是惟一选择。这个唯一选择很关键，它说明

了引用的重要性以及无可替代性，也许这就是 C++语言中引入

继续赋值。因此引用成了这个操作符的惟一返回值选择。

例 3

＃i nclude <iostream.h>

int &put(int n);

int vals[10];

int error=-1;

void main()

{

put(0)=10; //以 put(0)函数值作为左值，等价于 vals[0]=10;

put(9)=20; //以 put(9)函数值作为左值，等价于 vals[9]=20;

cout<<vals[0];

cout<<vals[9];

}

int &put(int n)

则运算符。它们不能返回引用，Effective C++[1]的 Item23 详细

的 讨 论 了 这 个 问 题 。 主 要 原 因 是 这 四 个 操 作 符 没 有 side

effect，因此，它们必须构造一个对象作为返回值，可选的方

案包括：返回一个对象、返回一个局部变量的引用，返回一个

new 分配的对象的引用、返回一个静态对象引用。根据前面提

到的引用作为返回值的三个规则，第 2、3 两个方案都被否决

了。静态对象的引用又因为((a+b) == (c+d))会永远为 true 而导

致错误。所以可选的只剩下返回一个对象了。

6. “引用”与多态的关系？

引用是除指针外另一个可以产生多态效果的手段。这意味着，

指针通过某个指针变量指向一个对象后，对它所指向的变量间

目标变量的别名，对引用的操作就是对目标变量的操作。此外，

数、赋值操作符=的参数、其它情况都推荐使用引用。

9. 结构与联合有和区别？

地址不同）。p

2. 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员

的值就不存在了, 而对于结构的不同成员赋值是互不影响的。

10. 下面关于“联合”的题目的输出？

a)

＃i nclude <stdio.h>

union

int i;

char x[2];

}a;

voidmain()

{

b)

 main()

 {

 union{ /*定义一个联合*/

 int i;

 struct{ /*在联合中定义一个结构*/

 char first;

 char second;

 }half;

 }number;

 printf("%c%c\n", number.half.first, mumber.half.second);

 getch();

 }

6261 (number.i 和 number.half 共用一块地址空间）

if ( strDest == NULL || strSrc == NULL)

return NULL ;

;

return tempptr ;

}

12. 已知 String 类定义如下：

class String

public:

String(const char *str = NULL); // 通用构造函数

String(const String &another); // 拷贝构造函数

~ String(); // 析构函数

String::String(const char *str)

{

if ( str == NULL ) //strlen 在参数为 NULL 时会抛异常才会有

这步判断

 {

m_data[0] = '\0' ;

}

 else

{

 strcpy(m_data,str);

String::String(const String &another)

{

 m_data = new char[strlen(another.m_data) + 1];

 strcpy(m_data,other.m_data);

}

String& String::operator =(const String &rhs)

{

 delete []m_data; //删除原来的数据，新开一块内存

 m_data = new char[strlen(rhs.m_data) + 1];

 strcpy(m_data,rhs.m_data);

 delete []m_data ;

}

13. .h 头文件中的 ifndef/define/endif 的作用？

答：防止该头文件被重复引用。

14. ＃i nclude<file.h> 与 ＃i nclude "file.h"的区别？

答：前者是从 Standard Library 的路径寻找和引用 file.h，而后

者是从当前工作路径搜寻并引用 file.h。

围（可见性）的关键字，该关键字告诉编译器，其声明的函数

模块 A 中定义的全局变量和函数时只需包含模块 A 的头文件

即可。这样，模块 B 中调用模块 A 中的函数时，在编译阶段，

模块 B 虽然找不到该函数，但是并不会报错；它会在连接阶段

中从模块 A 编译生成的目标代码中找到此函数

extern "C"是连接申明(linkage declaration),被 extern "C"修饰的

变量和函数是按照 C 语言方式编译和连接的,来看看 C++中对

类似 C 的函数是怎样编译的：

作为一种面向对象的语言，C++支持函数重载，而过程式语言

C 则不支持。函数被 C++编译后在符号库中的名字与 C 语言的

不同。例如，假设某个函数的原型为：

成的名字不同，但是都采用了相同的机制，生成的新名字称为

息，C++就是靠这种机制来实现函数重载的。例如，在 C++中，

符号是不相同的，后者为_foo_int_float。

个名字与用户程序中同名的全局变量名字不同。

// 模块 A 头文件　moduleA.h

#define MODULE_A_H

int foo( int x, int y );

#endif　　

在模块 B 中引用该函数：

// 模块 B 实现文件　moduleB.cpp

＃i nclude "moduleA.h"

foo(2,3);

　　

// 模块 A 头文件　moduleA.h

#ifndef MODULE_A_H

#define MODULE_A_H

extern "C" int foo( int x, int y );

在模块 B 的实现文件中仍然调用 foo( 2,3 )，其结果是：

（1）模块 A 编译生成 foo 的目标代码时，没有对其名字进行

特殊处理，采用了 C 语言的方式；

中包含的是 extern int foo( int x, int y ) ，则模块 B 找不到模块 A

所以，可以用一句话概括 extern “C”这个声明的真实目的（任

实世界的需求驱动。我们在思考问题时，不能只停留在这个语

明白了 C++中 extern "C"的设立动机，我们下面来具体分析

extern "C"通常的使用技巧：

（1）在 C++中引用 C 语言中的函数和变量，在包含 C 语言头

文件（假设为 cExample.h）时，需进行下列处理：

extern "C"

{

＃i nclude "cExample.h"

}

而在 C 语言的头文件中，对其外部函数只能指定为 extern 类型，

C 语言 中不支持 extern "C" 声 明 ，在 .c 文 件中包 含了 extern

"C"时会出现编译语法错误。

C++引用 C 函数例子工程中包含的三个文件的源代码如下：

#endif

/* c 语言实现文件：cExample.c */

＃i nclude "cExample.h"

int add( int x, int y )

{

}

// c++实现文件，调用 add：cppFile.cpp

{

{

add(2,3);

return 0;

}

需添 加 extern "C" ， 但 是在 C 语言 中不 能 直接 引用 声 明了

extern "C" 的该头文件，应该仅将 C 文件中将 C++中定义的

//C++头文件 cppExample.h

#define CPP_EXAMPLE_H

extern "C" int add( int x, int y );

#endif

//C++实现文件 cppExample.cpp

＃i nclude "cppExample.h"

int add( int x, int y )

{

return x + y;

}

/* C 实现文件 cFile.c

extern int add( int x, int y );

int main( int argc, char* argv[] )

{

add( 2, 3 );

return 0;

}

15 题目的解答请参考《p pC++p p中p p

pppp

extern “C”p p含义深层探索》p p注解：

16. 关联、聚合(Aggregation)以及组合(Composition)的区别？

涉及到 UML 中的一些概念：关联是表示两个类的一般性联系 ，

比如“学生”和“老师”就是一种关联关系；聚合表示 has-a 的关系，

是一种相对松散的关系，聚合类不需要对被聚合类负责，如下



class A {...} class B { A* a; .....}

心的菱形表示组合关系：



实现的形式是:

参 考 文 章 ： http://blog.csdn.net/wfwd/archive/

2006/05/30/763753.aspx

 http://blog.csdn.net/wfwd/archive/2006/05/30/763760.aspx

17.面向对象的三个基本特征，并简单叙述之？

1. 封装：将客观事物抽象成类，每个类对自身的数据和方法实

行 protection(private, protected,public)

2. 继承：广义的继承有三种实现形式：实现继承（指使用基类

合=>接口继承以及纯虚函数）构成了功能复用的两种方式。

类类型的指针赋值给父类类型的指针。

18. 重载（overload)和重写(overried，有的书也叫做“覆盖”）的

区别？

常考的题目。从定义上来说：

重载：是指允许存在多个同名函数，而这些函数的参数表不同

（或许参数个数不同，或许参数类型不同，或许两者都不同）。

重写：是指子类重新定义复类虚函数的方法。