C++试题收集

下面这些题目都是我之前准备笔试面试过程中积累的,大部分都是知名公司的笔试题,C++基础薄弱的很容易栽进去。我从中选了10道简单的题,C++初学者可以进来挑战下,C++大牛也可以作为娱乐玩下(比如下面的第6题)。为了便于大家思考,将题目与答案分开,不过无论题目本身如何,我觉得后面的解析过程更值得学习,因为涉及很多我们学习C++过程中必知必会的小知识点 。

    1. 如下函数,在32 bit系统foo(2^31-3)的值是:

      A:0 B: 1 C: 2 D: 4

      答案:C
      解释:我只想说注意运算符优先级,注意^是异或而不是幂次方。
       减号(-)的优先级高于异或(^);负数的二进制表示 30&-30

    2. 运算符优先级

      输出什么?
      输出:0xfffffff7(提示:+的优先级优于>>)
      如果将unsigned去掉,则输出0x7。
      ~优于+号优于>>,注意无符号

    3. 静态对象是否调用构造函数?

      输出:

      B’s Constructor Called

      解释:(1)上面的程序只是调用了B的构造函数,没有调用A的构造函数。因为静态成员变量只是在类中声明,没有定义。静态成员变量必须在类外使用作用域标识符显式定义。
      (2)如果我们没有显式定义静态成员变量a,就试图访问它,编译会出错,比如下面的程序编译出错:

      Compiler Error: undefined reference to `B::a

      (3)如果我们加上a的定义,那么上面的程序可以正常运行,
      注意:如果A是个空类,没有数据成员x,则就算B中的a未定义也还是能运行成功的,即可以访问A。

      输出:

      A’s constructor called
      B’s constructor called
      B’s constructor called
      B’s constructor called

      上面的程序调用B的构造函数3次,但是只调用A的构造函数一次,因为静态成员变量被所有对象共享,这也是它被称为类变量的原因。同时,静态成员变量也可以通过类名直接访问,比如下面的程序没有通过任何类对象访问,只是通过类访问a。

      输出:

      A’s constructor called

    4. union问题

      输出:266,
      自己画个内存结构图就知道了,注意union的存放顺序是所有成员都从低地址开始存放。Union的大小为其内部所有变量的最大值,并且按照类型最大值的整数倍进行内存对齐。
      union含有变量,函数,默认public。变量共享内存,长度为变量中最大的(例子中为4(int))低8位是10,高8位是1 (0000 0001 0000 1010 = 266)(内存布局从低到高)

    5. 下面代码会报错吗?为什么?

      答案:正常输出。上面的代码可以这样理解(这非常重要):

      也就是:并不是类没有初始化就不能调用类的成员函数,如果成员函数只是简单的打印个东西,没有调用类成员啥的就不会报错误。

    6. 下面代码的输出是什么?(非常考基础水平的一道题)

      解答:
      c是一个指针数组,每个数组元素都是char*类型的指针,值分别是那些字符串(的首地址):

      c[0] = “ENTER”
      c[1] = “NEW”
      c[2] = “POINT”
      c[3] = “FIRST”

      而[]和*是本质一样的运算,即c[i]=*(c+i)

      c和c+i都是char *[]类型,它可以退化成char **类型,再看cp,它正好是一个char **的数组,来看它的值:

      cp[0] = c + 3
      cp[1] = c + 2
      cp[2] = c + 1
      cp[3] = c

      引用后就有:cp[0][0]=*(c + 3)=c[3]="FIRST",以此类推。

      cp是char **[]类型,它可以退化成char ***类型,看最后的cpp,它正是char ***类型,它是一个指针变量,和上面两个不同,上面两个是数组。

      这样分析过后,下面的解析就一目了然了:

      • printf("%s",**++cpp);
        ++cpp的值是cp+1,引用一次后是cp[1]再引用是*cp[1]=c[2]=”POINT”,第一句的输出
      • printf("%s",*--*++cpp+3);
        再++cpp的值是cp+2,引用一次是cp[2]=c+1,再对这进行–,减后是c再引用是c[0]=”ENTER”再+3,字符串指针指到”ER”,输出是”ER”
      • printf("%s",*cpp[-2]+3);
        这时cpp的值是cp+2,cpp[-2]=*(cpp-2)=*(cp+2-2)=cp[0]=c+3,再引用是c[3]=”FIRST”,+3 字符串指针指到”ST”,输出是”ST”
      • printf("%s\n",cpp[-1][-1]+1);
        cpp还是cp+2,cpp[-1]=*(cpp-1)=*(cp+2-1)=cp[1]=c+2,再[-1]得*(c+2-1)=c[1]=”NEW”,+1字符串指针指到”EW”,输出是”EW”。注意语句执行会改变指针位置
    7. 结构体

      输出:4 2

      说明:一般变量都是从高到低分配内存地址,但对于结构体来说,结构体的成员在内存中顺序存放,所占内存地址依次增高,第一个成员处于低地址处,最后一个成员处于最高地址处,但结构体成员的内存分配不一定是连续的,编译器会对其成员变量依据前面介绍的 “对齐”原则进行处理。

      补充知识点:

      除了栈以外,堆、只读数据区、全局变量地址增长方向都是从低到高的。

    8. 改变string变量的值?

      输出:仍为“sarrr”。
      解释:string是传值参数,不能修改其值。要想改变string变量的值,可以改为传地址方式:

    9. 静态变量的输出

      输出:8 10 12 14 16
      解释:存储在静态数据区的变量会在程序刚开始运行时就完成初始化,也是唯一的一次初始化,此后该初始化不再执行,相当于一次执行后就作废,静态局部变量保存了前次被调用后留下的值。

    10. 返回值加const修饰的必要性你觉得下面两种写法有区别吗?

如果是下面的呢?其中A 为用户自定义的数据类型。

答案:没有任何区别。
解释:如果函数返回值采用“值传递方式”,由于函数会把返回值复制到外部临时的存储单元中,加const 修饰没有任何价值。所以,对于值传递来说,加const没有太多意义。
所以:

不要把函数int GetInt(void) 写成const int GetInt(void)。

不要把函数A GetA(void) 写成const A GetA(void)。

在编程中要尽可能多的使用const(比如函数参数采用const&修饰),这样可以获得编译器的帮助,以便写出健壮性的代码

返回值加const修饰的必要性

(来自:http://www.cnblogs.com/lanxuezaipiao/p/4148155.htm)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

1.一个c++基础类Base(存在虚函数);一个子类Child,子类Child非虚继承Base时,子类的vptr和基类的vptr不同,但是Base* base=new Child()时,子类对象的的虚表指针指赋值给了基类的虚表指针对吗?

解答:C++ virtual 解析

2.C++11中移动构造函数这样写对吗?

解答:

未试出…

来自:整理
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  1. new、delete、malloc、free 关系
    new和delete会自动调用对象的构造与析构函数而malloc与free不会;
    new和delete式C++运算符,而malloc和free是C/C++标准库函数。
  2. delete 与 delete [] 区别
    delete 删除一个指针,delete[] 删除一个数组;
    delete 只会调用一次析构函数,而 delete[] 会调用每一个成员的析构函数;
    delete 与 new 配套, delete [] 与 new [] 配套;
  3. 继承优缺点
    类继承是在编译时刻静态定义的,且可直接使用,类继承可以较方便地改变父类的实现。但是类继承也有一些不足之处。首先,因为继承在编译时刻就定义了,所以无法在运行时刻改变从父类继承的实现。更糟的是,父类通常至少定义了子类的部分行为,父类的任何改变都可能影响子类的行为。如果继承下来的实现不适合解决新的问题,则父类必须重写或被其他更适合的类替换。这种依赖关系限制了灵活性并最终限制了复用性。
  4. 子类析构时要调用父类的析构函数吗?
    析构函数调用的次序是先派生类的析构后基类的析构,也就是说在基类的的析构调用的时候 , 派生类的信息已经全部销毁了定义一个对象时先调用基类的构造函数、然后调用派生类的构造函数;析构的时候恰好相反:先调用派生类的析构函数、然后调用基类的析构函数
  5. 假定x = 9999,求值

    答案: 8
    将9999转为二进制,数有几个1
  6. 什么是 “ 引用 ” ?申明和使用 “ 引用 ” 要注意哪些问题?
    引用就是某个目标变量的 “ 别名 ”(alias) ,对应用的操作与对变量直接操作效果完全相同。申明一个引用的时候,切记要对其进行初始化。引用声明完毕后,相当于目标变量名有两个名称,即该目标原名称和引用名,不能再把该引用名作为其他变量名的别名。声明一个引用,不是新定义了一个变量,它只表示该引用名是目标变量名的一个别名,它本身不是一种数据类型,因此引用本身不占存储单元,系统也不给引用分配存储单元。不能建立数组的引用。
  7. 将 “ 引用 ” 作为函数参数有哪些特点?
    1 )传递引用给函数与传递指针的效果是一样的。这时,被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用,所以在被调函数中对形参变量的操作就是对其相应的目标对象(在主调函数中)的操作。
    2 )使用引用传递函数的参数,在内存中并没有产生实参的副本,它是直接对实参操作;而使用一般变量传递函数的参数,当发生函数调用时,需要给形参分配存储单元,形参变量是实参变量的副本;如果传递的是对象,还将调用拷贝构造函数。因此,当参数传递的数据较大时,用引用比用一般变量传递参数的效率和所占空间都好。
    3 )使用指针作为函数的参数虽然也能达到与使用引用的效果,但是,在被调函数中同样要给形参分配存储单元,且需要重复使用 “* 指针变量名 ” 的形式进行运算,这很容易产生错误且程序的阅读性较差;另一方面,在主调函数的调用点处,必须用变量的地址作为实参。而引用更容易使用,更清晰。
  8. 在什么时候需要使用 “ 常引用 ” ?
    如果既要利用引用提高程序的效率,又要保护传递给函数的数据不在函数中被改变,就应使用常引用。常引用声明方式: const 类型标识符 & 引用名 = 目标变量名;


    原因在于foo( )和”hello world”串都会产生一个临时对象,而在C++中,这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型,这是非法的。
    引用型参数应该在能被定义为const的情况下,尽量定义为const 。
    bar(foo());可执行
    bar(“hello world”);类型转换失败
  9. 将 “ 引用 ” 作为函数返回值类型的格式、好处和需要遵守的规则 ?
    格式

    好处:在内存中不产生被返回值的副本;(注意:正是因为这点原因,所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束,相应的引用也会失效,产生 runtime error!
    注意事项:
    ( 1 )不能返回局部变量的引用。这条可以参照 Effective C++[1] 的 Item 31 。主要原因是局部变量会在函数返回后被销毁,因此被返回的引用就成为了 ” 无所指 ” 的引用,程序会进入未知状态。
    ( 2 )不能返回函数内部 new 分配的内存的引用。这条可以参照 Effective C++[1] 的 Item 31 。虽然不存在局部变量的被动销毁问题,可对于这种情况(返回函数内部 new 分配内存的引用),又面临其它尴尬局面。例如,被函数返回的引用只是作为一个临时变量出现,而没有被赋予一个实际的变量,那么这个引用所指向的空间(由 new 分配)就无法释放,造成 memory leak 。
    ( 3 )可以返回类成员的引用,但最好是 const 。这条原则可以参照 Effective C++[1] 的 Item 30 。主要原因是当对象的属性是与某种业务规则( business rule )相关联的时候,其赋值常常与某些其它属性或者对象的状态有关,因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用(或指针),那么对该属性的单纯赋值就会破坏业务规则的完整性。
    ( 4 )流操作符重载返回值申明为 “ 引用 ” 的作用:
    流操作符 << 和 >> ,这两个操作符常常希望被连续使用,例如: cout << “hello” << endl;  因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括:返回一个流对象和返回一个流对象指针。但是对于返回一个流对象,程序必须重新(拷贝)构造一个新的流对象,也就是说,连续的两个 << 操作符实际上是针对不同对象的!这无法让人接受。对于返回一个流指针则不能连续使用 << 操作符。因此,返回一个流对象引用是惟一选择。这个唯一选择很关键,它说明了引用的重要性以及无可替代性,也许这就是 C++ 语言中引入引用这个概念的原因吧。 赋值操作符 = 。这个操作符象流操作符一样,是可以连续使用的,例如: x = j = 10; 或者 (x=10)=100; 赋值操作符的返回值必须是一个左值,以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。

    ( 5 )在另外的一些操作符中,却千万不能返回引用: +-*/ 四则运算符。它们不能返回引用, Effective C++[1] 的 Item23 详细的讨论了这个问题。主要原因是这四个操作符没有 side effect ,因此,它们必须构造一个对象作为返回值,可选的方案包括:返回一个对象、返回一个局部变量的引用,返回一个 new 分配的对象的引用、返回一个静态对象引用。根据前面提到的引用作为返回值的三个规则,第 2 、 3 两个方案都被否决了。静态对象的引用又因为 ((a+b) == (c+d)) 会永远为 true 而导致错误。所以可选的只剩下返回一个对象了。
  10. “ 引用 ” 与多态的关系?
    引用是除指针外另一个可以产生多态效果的手段。这意味着,一个基类的引用可以指向它的派生类实例。例
  11. “ 引用 ” 与指针的区别是什么?
    指针通过某个指针变量指向一个对象后,对它所指向的变量间接操作。程序中使用指针,程序的可读性差;而引用本身就是目标变量的别名,对引用的操作就是对目标变量的操作。此外,就是上面提到的对函数传 ref 和 pointer 的区别。
  12. 什么时候需要 “ 引用 ” ?
    流操作符 << 和 >> 、赋值操作符 = 的返回值、拷贝构造函数的参数、赋值操作符 = 的参数、其它情况都推荐使用引用。
  13. 结构与联合有和区别?
    (1). 结构和联合都是由多个不同的数据类型成员组成 , 但在任何同一时刻 , 联合中只存放了一个被选中的成员(所有成员共用一块地址空间) , 而结构的所有成员都存在(不同成员的存放地址不同)。
    (2). 对于联合的不同成员赋值 , 将会对其它成员重写 ,  原来成员的值就不存在了 , 而对于结构的不同成员赋值是互不影响的。
  14. 面关于 “ 联合 ” 的题目的输出?
    a)

    答案: 266 ( 低位低地址,高位高地址,内存占用情况是 Ox010A )

    b)

    答案: AB   (0x41 对应 ‘A’, 是低位; Ox42 对应 ‘B’, 是高位)
    6261 (number.i 和 number.half 共用一块地址空间)

  15. 关联、聚合 (Aggregation) 以及组合 (Composition) 的区别?
    涉及到 UML 中的一些概念:关联是表示两个类的一般性联系,比如 “ 学生 ” 和 “ 老师 ” 就是一种关联关系;聚合表示 has-a 的关系,是一种相对松散的关系,聚合类不需要对被聚合类负责,如下图所示,用空的菱形表示聚合关系:从实现的角度讲,聚合可以表示为 :
    class A {…}  class B { A* a; …..}
    而组合表示 contains-a 的关系,关联性强于聚合:组合类与被组合类有相同的生命周期,组合类要对被组合类负责,采用实心的菱形表示组合关系:实现的形式是 :
    class A{…} class B{ A a; …}
  16. 面向对象的三个基本特征,并简单叙述之?
    1. 封装:将客观事物抽象成类,每个类对自身的数据和方法实行 protection(private, protected,public)
    2. 继承:广义的继承有三种实现形式:实现继承(指使用基类的属性和方法而无需额外编码的能力)、可视继承(子窗体使用父窗体的外观和实现代码)、接口继承(仅使用属性和方法,实现滞后到子类实现)。前两种(类继承)和后一种(对象组合 => 接口继承以及纯虚函数)构成了功能复用的两种方式。
    3. 多态:是将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。
    静多态可以通过模板和函数重载来实现
    动多态则是通过继承、虚函数(virtual)、指针来实现
    在编译期决定你应该调用哪个函数的行为是静态绑定(static-binding),这种现象就是静多态。
    在运行期决定应该调用哪中类型对象的函数的行为是动态绑定(dynamic-binding),这种现象就是动多态!
  17. 重载(overload)和重写(overried,有的书也叫做“覆盖”)的区别?
    从定义上来说:重载:是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)。重写:是指子类重新定义父类虚函数的方法。从实现原理上来说:重载:编译器根据函数不同的参数表,对同名函数的名称做修饰,然后这些同名函数就成了不同的函数(至少对于编译器来说是这样的)。如,有两个同名函数:function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的:int_func、str_func。对于这两个函数的调用,在编译器间就已经确定了,是静态的。也就是说,它们的地址在编译期就绑定了(早绑定),因此,重载和多态无关重写:和多态真正相关。当子类重新定义了父类的虚函数后,父类指针根据赋给它的不同的子类指针,动态的调用属于子类的该函数,这样的函数调用在编译期间是无法确定的(调用的子类的虚函数的地址无法给出)。因此,这样的函数地址是在运行期绑定的(晚绑定)。
  18. 多态的作用?
    主要是两个:1. 隐藏实现细节,使得代码能够模块化;扩展代码模块,实现代码重用;2. 接口重用:为了类在继承和派生的时候,保证使用家族中任一类的实例的某一属性时的正确调用
  19.  #define DOUBLE(x) x+x i = 5*DOUBLE(5) i 是多少?
    i 为30。(注意直接展开就是了) 5 * 5 + 5
  20. 有哪几种情况只能用intializationlist 而不能用assignment?
    当类中含有const、reference 成员变量;基类的构造函数都需要初始化表。
  21. C++是不是类型安全的?
    不是。两个不同类型的指针之间可以强制转换(用reinterpret cast)。C#是类型安全的。
  22. main 函数执行以前,还会执行什么代码?
    全局对象的构造函数会在main 函数之前执行,为malloc分配必要的资源,等等。
  23. 描述内存分配方式以及它们的区别?
    1) 从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static 变量
    2) 在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。
    3) 从堆上分配亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存,程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定,使用非常灵活,但问题也最多。
    4) 代码区。
  24. struct class 的区别
    struct 的成员默认是公有的,而类的成员默认是私有的。struct 和 class 在其他方面是功能相当的。从感情上讲,大多数的开发者感到类和结构有很大的差别。感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位,而类就象活的并且可靠的社会成员,它有智能服 务,有牢固的封装屏障和一个良好定义的接口。既然大多数人都这么认为,那么只有在你的类有很少的方法并且有公有数据(这种事情在良好设计的系统中是存在 的!)时,你也许应该使用 struct 关键字,否则,你应该使用 class 关键字。
  25. 当一个类A 中没有声明任何成员变量与成员函数,这时sizeof(A)的值是多少,如果不是零,请解释一下编译器为什么没有让它为零。(Autodesk
    肯定不是零。举个反例,如果是零的话,声明一个class A[10]对象数组,而每一个对象占用的空间是零,这时就没办法区分A[0],A[1]…了。
  26. 8086 汇编下,逻辑地址和物理地址是怎样转换的?(Intel
    通用寄存器给出的地址,是段内偏移地址,相应段寄存器地址*10H+通用寄存器内地址,就得到了真正要访问的地址。
  27. 比较C++中的4种类型转换方式?
    重点是static_cast, dynamic_cast和reinterpret_cast,const_cast的区别和应用。
    static_cast的转换格式:static_cast <type-id> (expression)
    将expression转换为type-id类型,主要用于非多态类型之间的转换,不提供运行时的检查来确保转换的安全性;dynamic_cast的转换格式:dynamic_cast <type-id> (expression) 将expression转换为type-id类型,type-id必须是类的指针、类的引用或者是void *;如果type-id是指针类型,那么expression也必须是一个指针;如果type-id是一个引用,那么expression也必须是一个引用。适用于多态类型之间的转换;const_cast的转换格式:const_cast <type-id> (expression)
    const_cast用来将类型的const、volatile和__unaligned属性移除。常量指针被转换成非常量指针,并且仍然指向原来的对象;常量引用被转换成非常量引用,并且仍然引用原来的对象reinterpret_cast的转换格式:reinterpret_cast <type-id> (expression)
    允许将任何指针类型转换为其它的指针类型;它主要用于将一种数据类型从一种类型转换为另一种类型。它可以将一个指针转换成一个整数,也可以将一个整数转换成一个指针

    参考:static_cast、dynamic_cast、const_cast和reinterpret_cast总结

  28. 分别写出BOOL,int,float,指针类型的变量a 与“零”的比较语句。

    剖析:
    考查对0值判断的“内功”,BOOL型变量的0判断完全可以写成if(var==0),而int型变量也可以写成if(!var),指针变量的判断也可以写成if(!var),上述写法虽然程序都能正确运行,但是未能清晰地表达程序的意思。
    一般的,如果想让if判断一个变量的“真”、“假”,应直接使用if(var)、if(!var),表明其为“逻辑”判断;如果用if判断一个数值型变量(short、int、long等),应该用if(var==0),表明是与0进行“数值”上的比较;而判断指针则适宜用if(var==NULL),这是一种很好的编程习惯。
    浮点型变量并不精确,所以不可将float变量用“==”或“!=”与数字比较,应该设法转化成“>=”或“<=”形式。如果写成if(x == 0.0),则判为错,得0分。

  29. 请说出const#define 相比,有何优点?
    1) const 常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会产生意料不到的错误。
    2) 有些集成化的调试工具可以对const 常量进行调试,但是不能对宏常量进行调试。
  30. 简述数组与指针的区别?
    数组要么在静态存储区被创建(如全局数组),要么在栈上被创建。指针可以随时指向任意类型的内存块。
    (1)修改内容上的差别

    (2) 用运算符sizeof 可以计算出数组的容量(字节数)。sizeof(p),p 为指针得到的是一个指针变量的字节数,而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量,除非在申请内存时记住它。注意当数组作为函数的参数进行传递时,该数组自动退化为同类型的指针。

    计算数组和指针的内存容量

  31. 类成员函数的重载、覆盖和隐藏区别?
    a.成员函数被重载的特征:
    (1)相同的范围(在同一个类中);
    (2)函数名字相同;
    (3)参数不同;
    (4)virtual 关键字可有可无。
    b.覆盖是指派生类函数覆盖基类函数,特征是:
    (1)不同的范围(分别位于派生类与基类);
    (2)函数名字相同;
    (3)参数相同;
    (4)基类函数必须有virtual 关键字。
    c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数,规则如下:
    (1)如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)。
    (2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual 关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)
  32. There are two int variables: a and b, don’t use “if”, “? :”, “switch”or other judgementstatements, find out the biggest one of the two numbers.
    ( ( a + b ) + abs( a- b ) ) / 2
  33. 如何打印出当前源文件的文件名以及源文件的当前行号?
    cout << __FILE__ ;
    cout<<__LINE__ ;
    __FILE__和__LINE__是系统预定义宏,这种宏并不是在某个文件中定义的,而是由编译器定义的
  34. main 主函数执行完毕后,是否可能会再执行一段代码,给出说明?
    可以,可以用_onexit 注册一个函数,它会在main 之后执行int fn1(void), fn2(void), fn3(void),fn4 (void);

    The _onexit function is passed the address of a function (func) to be called whenthe program terminates normally. Successive calls to _onexit create a registerof functions that are executed in LIFO (last-in-first-out) order. The functionspassed to _onexit cannot take parameters.
  35. 如何判断一段程序是由C 编译程序还是由C++编译程序编译的?

  36. 文件中有一组整数,要求排序后输出到另一个文件中

  37. 链表题:一个链表的结点结构

    (1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel)

    (2)已知两个链表head1 head2 各自有序,请把它们合并成一个链表依然有序。(保留所有结点,即便大小相同)

    (3)已知两个链表head1 head2 各自有序,请把它们合并成一个链表依然有序,这次要求用递归方法进行。(Autodesk)

  38. 分析一下这段程序的输出(Autodesk)

  39. 写一个函数找出一个整数数组中,第二大的数(microsoft)

  40. 写一个在一个字符串(n)中寻找一个子串(m)第一个位置的函数。
    KMP算法效率最好,时间复杂度是O(n+m)。
  41. 多重继承的内存分配问题:
       比如有class A : public class B, public classC {}
       那么A的内存结构大致是怎么样的?
    这个是compiler-dependent的, 不同的实现其细节可能不同。
    如果不考虑有虚函数、虚继承的话就相当简单;否则的话,相当复杂。
    可以参考《深入探索C++对象模型》
  42. 如何判断一个单链表是有环的?(注意不能用标志位,最多只能用两个额外指针)

  43. 已知strcpy的函数原型:char *strcpy(char *strDest, const char *strSrc)其中strDest 是目的字符串,strSrc 是源字符串。不调用C++/C 的字符串库函数,请编写函数 strcpy。

  44. 已知String类定义如下:


    尝试写出类的成员函数实现。
  45. .h头文件中的ifndef/define/endif 的作用?
    防止该头文件被重复引用。
  46. #include<file.h> 与#include “file.h”的区别?
    前者是从Standard Library的路径寻找和引用file.h,而后者是从当前工作路径搜寻并引用file.h。

在C++程序中调用被C 编译器编译后的函数,为什么要加extern “C”?
首先,作为extern是C/C++语言中表明函数和全局变量作用范围(可见性)的关键字,该关键字告诉编译器,其声明的函数和变量可以在本模块或其它模块中使用。通常,在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如,如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样,模块B中调用模块A中的函数时,在编译阶段,模块B虽然找不到该函数,但是并不会报错;它会在连接阶段中从模块A编译生成的目标代码中找到此函数extern “C”是连接申明(linkage declaration),被extern “C”修饰的变量和函数是按照C语言方式编译和连接的,来看看C++中对类似。C的函数是怎样编译的:
作为一种面向对象的语言,C++支持函数重载,而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如,假设某个函数的原型为:

该函数被C编译器编译后在符号库中的名字为_foo,而C++编译器则会产生像_foo_int_int之类的名字(不同的编译器可能生成的名字不同,但是都采用了相同的机制,生成的新名字称为“mangled name”)。

_foo_int_int 这样的名字包含了函数名、函数参数数量及类型信息,C++就是靠这种机制来实现函数重载的。例如,在C++中,函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的,后者为_foo_int_float。

同 样地,C++中的变量除支持局部变量外,还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名,我们以”.”来区分。而本质上,编译器在进行编译时,与函数的处理相似,也为类中的变量取了一个独一无二的名字,这个名字与用户程序中同名的全局变量名字不同。

未加extern “C”声明时的连接方式

假设在C++中,模块A的头文件如下:


在模块B中引用该函数:


实际上,在连接阶段,连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号!

加extern “C”声明后的编译和连接方式

加extern “C”声明后,模块A的头文件变为:


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

(1)模块A编译生成foo的目标代码时,没有对其名字进行特殊处理,采用了C语言的方式;

(2)连接器在为模块B的目标代码寻找foo(2,3)调用时,寻找的是未经修改的符号名_foo。

如果在模块A中函数声明了foo为extern “C”类型,而模块B中包含的是extern int foo( int x, int y ) ,则模块B找不到模块A中的函数;反之亦然。

所以,可以用一句话概括extern “C”这个声明的真实目的(任何语言中的任何语法特性的诞生都不是随意而为的,来源于真实世界的需求驱动。我们在思考问题时,不能只停留在这个语言是怎么做的,还要问一问它为什么要这么做,动机是什么,这样我们可以更深入地理解许多问题):实现C++与C及其它语言的混合编程

明白了C++中extern “C”的设立动机,我们下面来具体分析extern “C”通常的使用技巧:

extern “C”的惯用法 

 (1)在C++中引用C语言中的函数和变量,在包含C语言头文件(假设为cExample.h)时,需进行下列处理:


而在C语言的头文件中,对其外部函数只能指定为extern类型C语言中不支持extern “C”声明,在.c文件中包含了extern”C”时会出现编译语法错误。

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

如果C++调用一个C语言编写的.DLL时,当包括.DLL的头文件或声明接口函数时,应加extern “C” { }。

(2)在C中引用C++语言中的函数和变量时,C++的头文件需添加extern “C”,但是在C语言中不能直接引用声明了extern “C”的该头文件,应该仅将C文件中将C++中定义的extern”C”函数声明为extern类型。

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

来自:C/C++ 笔试、面试题目大汇总 (部分从其他转来,但这个全一些)

  1. 找错题目(1)

(2)

(3)

解答:
试题1字符串str1需要11个字节才能存放下(包括末尾的’\0’),而string只有10个字节的空间,strcpy会导致数组越界;

对试题2,如果面试者指出字符数组str1不能在数组内结束可以给3分;如果面试者指出strcpy(string,str1)调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分,在此基础上指出库函数strcpy工作方式的给10分;

对试题3,if(strlen(str1)<= 10)应改为if(strlen(str1) < 10),因为strlen的结果未统计’\0’所占用的1个字节。

剖析:
考查对基本功的掌握:
(1)字符串以’\0’结尾;
(2)对数组越界把握的敏感度;
(3)库函数strcpy的工作方式,如果编写一个标准strcpy函数的总分值为10,下面给出几个不同得分的答案:
(4)

(5)

(6)

(7)

解答:
试题4传入中GetMemory(char *p )函数的形参为字符串指针,在函数内部修改形参并不能真正的改变传入形参的值,执行完

char *str = NULL;
GetMemory( str );
后的str仍然为NULL;

试题5中
char p[] = “hello world”;
return p;
的p[]数组为函数内的局部自动变量,在函数返回后,内存已经被释放。这是许多程序员常犯的错误,其根源在于不理解变量的生存期。

试题6的GetMemory避免了试题4的问题,传入GetMemory的参数为字符串指针的指针,但是在GetMemory中执行申请内存及赋值语句

*p = (char *) malloc( num );
后未判断内存是否申请成功,应加上:

if ( *p == NULL )
{
…//进行申请内存失败处理
}

 

试题7存在与试题6同样的问题,在执行
char *str = (char *) malloc(100);
后未进行内存是否申请成功的判断;另外,在free(str)后未置str为空,导致可能变成一个“野”指针,应加上:

str = NULL;

试题6的Test函数中也未对malloc的内存进行释放。

剖析:
试题4~7考查面试者对内存操作的理解程度,基本功扎实的面试者一般都能正确的回答其中50~60的错误。但是要完全解答正确,却也绝非易事。

对内存操作的考查主要集中在:
1)指针的理解;

2)变量的生存期及作用范围;
3)良好的动态内存申请和释放习惯。

再看看下面的一段程序有什么错误:

在swap函数中,p是一个“野”指针,有可能指向系统区,导致程序运行的崩溃。在VC++中DEBUG运行时提示错误“AccessViolation”。该程序应该改为:

2.以下为WindowsNT下的32位C++程序,请计算sizeof的值

解答:
sizeof( str ) = 4
sizeof ( p ) = 4
剖析:
Func ( char str[100] )函数中数组名作为函数形参时,在函数体内,数组名失去了本身的内涵,仅仅只是一个指针;在失去其内涵的同时,它还失去了其常量特性,可以作自增、自减等操作,可以被修改。
数组名的本质如下:
(1)数组名指代一种数据结构,这种数据结构就是数组;
例如:
char str[10];
cout << sizeof(str) << endl;
输出结果为10,str指代数据结构char[10]。

(2)数组名可以转换为指向其指代实体的指针,而且是一个指针常量,不能作自增、自减等操作,不能被修改;

char str[10];
str++; //编译出错,提示str不是左值

(3)数组名作为函数形参时,沦为普通指针。Windows NT 32位平台下,指针的长度(占用内存的大小)为4字节,故sizeof( str ) 、sizeof ( p) 都为4。

3.写一个标准MIN,这个宏输入两个参数并返回较小的一个。另外,当你写下面的代码时会发生什么事?
least = MIN(*p++, b);

解答:
#define MIN(A,B) ((A) <= (B) ? (A) : (B))
MIN(*p++, b)会产生宏的副作用

剖析:
这个面试题主要考查面试者对宏定义的使用,宏定义可以实现类似于函数的功能,但是它终归不是函数,而宏定义中括弧中的“参数”也不是真的参数,在宏展开的时候对“参数”进行的是一对一的替换。

程序员对宏定义的使用要非常小心,特别要注意两个问题:

(1)谨慎地将宏定义中的“参数”和整个宏用用括弧括起来。所以,严格地讲,下述解答:

#define MIN(A,B) (A) <= (B) ? (A) : (B)
#define MIN(A,B) (A <= B ? A : B )都应判0分;

(2)防止宏的副作用。

宏定义#define MIN(A,B) ((A) <= (B) ? (A) : (B))对MIN(*p++, b)的作用结果是:

((*p++) <= (b) ? (*p++) : (*p++))

这个表达式会产生副作用,指针p会作三次++自增操作。

除此之外,另一个应该判0分的解答是:

#define MIN(A,B) ((A) <= (B) ? (A) : (B));
这个解答在宏定义的后面加“;”,显示编写者对宏的概念模糊不清,只能被无情地判0分并被面试官淘汰。

4.函数头是这样的:

解答:

正确解答1:

正确解答2:

剖析:
这个试题主要考查面试者对标准库函数的熟练程度,在需要的时候引用库函数可以很大程度上简化程序编写的工作量。
最频繁被使用的库函数包括:
(1) strcpy
(2) memcpy
(3) memset

5.已知WAV文件格式如下表,打开一个WAV文件,以适当的数据结构组织WAV文件头并解析WAV格式的各项信息。

WAVE文件格式说明表

偏移地址 字节数 数据类型 内 容
文件头 00H 4 Char “RIFF”标志
04H 4 int32 文件长度
08H 4 Char “WAVE”标志
0CH 4 Char “fmt”标志
10H 4 过渡字节(不定)
14H 2 int16 格式类别
16H 2 int16 通道数
18H 2 int16 采样率(每秒样本数),表示每个通道的播放速度
1CH 4 int32 波形音频数据传送速率
20H 2 int16 数据块的调整数(按字节算的)
22H 2 每样本的数据位数
24H 4 Char 数据标记符"data"
28H 4 int32 语音数据的长度
 解答:
将WAV文件格式定义为结构体WAVEFORMAT:

假设WAV文件内容读出后存放在指针buffer开始的内存单元内,则分析文件格式的代码很简单,为:

WAVEFORMAT waveFormat;
memcpy( &waveFormat, buffer,sizeof( WAVEFORMAT ) );
直接通过访问waveFormat的成员,就可以获得特定WAV文件的各项格式信息。

剖析:
试题考查面试者组织数据结构的能力,有经验的程序设计者将属于一个整体的数据成员组织为一个结构体,利用指针类型转换,可以将memcpy、memset等函数直接用于结构体地址,进行结构体的整体操作。透过这个题可以看出面试者的程序设计经验是否丰富。

6.编写类String的构造函数、析构函数和赋值函数,已知类String的原型为:

剖析:
能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上!
在这个类中包括了指针类成员变量m_data,当类中包括指针类成员变量时,一定要重载其拷贝构造函数、赋值函数和析构函数,这既是对C++程序员的基本要求,也是《Effective C++》中特别强调的条款。
仔细学习这个类,特别注意加注释的得分点和加分点的意义,这样就具备了60%以上的C++基本功!

7.请说出static和const关键字尽可能多的作用

解答:
static关键字至少有下列n个作用:
(1)函数体内static变量的作用范围为该函数体,不同于auto变量,该变量的内存只被分配一次,因此其值在下次调用时仍维持上次的值;
(2)在模块内的static全局变量可以被模块内所用函数访问,但不能被模块外其它函数访问;
(3)在模块内的static函数只可被这一模块内的其它函数调用,这个函数的使用范围被限制在声明它的模块内;
(4)在类中的static成员变量属于整个类所拥有,对类的所有对象只有一份拷贝;
(5)在类中的static成员函数属于整个类所拥有,这个函数不接收this指针,因而只能访问类的static成员变量。

const关键字至少有下列n个作用:
(1)欲阻止一个变量被改变,可以使用const关键字。在定义该const变量时,通常需要对它进行初始化,因为以后就没有机会再去改变它了;
(2)对指针来说,可以指定指针本身为const,也可以指定指针所指的数据为const,或二者同时指定为const;
(3)在一个函数声明中,const可以修饰形参,表明它是一个输入参数,在函数内部不能改变其值;
(4)对于类的成员函数,若指定其为const类型,则表明其是一个常函数,不能修改类的成员变量;
(5)对于类的成员函数,有时候必须指定其返回值为const类型,以使得其返回值不为“左值”。例如:
const classA operator*(const classA& a1,const classA& a2);
operator*的返回结果必须是一个const对象。如果不是,这样的变态代码也不会编译出错:

classA a, b, c;
(a * b) = c; // 对a*b的结果赋值
操作(a * b) = c显然不符合编程者的初衷,也没有任何意义。

剖析:
惊讶吗?小小的static和const居然有这么多功能,我们能回答几个?如果只能回答1~2个,那还真得闭关再好好修炼修炼。

这个题可以考查面试者对程序设计知识的掌握程度是初级、中级还是比较深入,没有一定的知识广度和深度,不可能对这个问题给出全面的解答。大多数人只能回答出static和const关键字的部分功能。

8.写一个函数返回1+2+3+…+n的值(假定结果不会超过长整型变量的范围)

解答:

剖析:
对于这个题,只能说,也许最简单的答案就是最好的答案。下面的解答,或者基于下面的解答思路去优化,不管怎么“折腾”,其效率也不可能与直接return( 1 l + n ) * n / 2相比!

所以程序员们需要敏感地将数学等知识用在程序设计中。

来自:C/C++ 笔试、面试题目大汇总2