程序员面试之——C++

Posted 小小新说数据

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了程序员面试之——C++相关的知识,希望对你有一定的参考价值。

1.new、delete、malloc、free关系

delete会调用对象的析构函数,和new对应free只会释放内存,new调用构造函数。malloc与free是C++/C语言的标准库函数,new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。对于非内部数据类型的对象而言,光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数,对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析构函数的任务强加于malloc/free。因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new,以及一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。

2.delete与 delete []区别

delete只会调用一次析构函数,而delete[]会调用每一个成员的析构函数。在More Effective C++中有更为详细的解释:“当delete操作符用于数组时,它为每个数组元素调用析构函数,然后调用operator delete来释放内存。”delete与new配套,delete []与new []配套

这就说明:对于内建简单数据类型,delete和delete[]功能是相同的。对于自定义的复杂数据类型,delete和delete[]不能互用。delete[]删除一个数组,delete删除一个指针。简单来说,用new分配的内存用delete删除;用new[]分配的内存用delete[]删除。delete[]会调用数组元素的析构函数。内部数据类型没有析构函数,所以问题不大。如果你在用delete时没用括号,delete就会认为指向的是单个对象,否则,它就会认为指向的是一个数组。

3.C++有哪些性质(面向对象特点)

封装,继承和多态

5.多态,虚函数,纯虚函数

多态:是对于不同对象接收相同消息时产生不同的动作。C++的多态性具体体现在运行和编译两个方面:在程序运行时的多态性通过继承和虚函数来体现;

在程序编译时多态性体现在函数和运算符的重载上;

虚函数:在基类中冠以关键字 virtual 的成员函数。 它提供了一种接口界面。允许在派生类中对基类的虚函数重新定义。

纯虚函数的作用:在基类中为其派生类保留一个函数的名字,以便派生类根据需要对它进行定义。作为接口而存在 纯虚函数不具备函数的功能,一般不能直接被调用。

从基类继承来的纯虚函数,在派生类中仍是虚函数。如果一个类中至少有一个纯虚函数,那么这个类被称为抽象类(abstract class)。

抽象类中不仅包括纯虚函数,也可包括虚函数。抽象类必须用作派生其他类的基类,而不能用于直接创建对象实例。但仍可使用指向抽象类的指针支持运行时多态性。

7.什么是“引用”?申明和使用“引用”要注意哪些问题?

答:引用就是某个目标变量的“别名”(alias),对应用的操作与对变量直接操作效果完全相同。申明一个引用的时候,切记要对其进行初始化。引用声明完毕后,相当于目标变量名有两个名称,即该目标原名称和引用名,不能再把该引用名作为其他变量名的别名。声明一个引用,不是新定义了一个变量,它只表示该引用名是目标变量名的一个别名,它本身不是一种数据类型,因此引用本身不占存储单元,系统也不给引用分配存储单元。不能建立数组的引用


11、结构与联合有和区别?

 

(2). 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的

  

13.重载(overload)和重写(overried,有的书也叫做“覆盖”)的区别?

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

重载:是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)。

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

从实现原理上来说:

 

15. C++是不是类型安全的?

答案:不是。两个不同类型的指针之间可以强制转换(用reinterpret cast)。C#是类型安全的。

17. 描述内存分配方式以及它们的区别?

1) 从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static 变量。

2) 在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。

3) 从堆上分配,亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存,程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定,使用非常灵活,但问题也最多。

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

答案:

BOOL : if ( !a ) or if(a)

int : if ( a == 0)

float : const EXPRESSION EXP = 0.000001

if ( a < EXP && a >-EXP)

pointer : if ( a != NULL) or if(a == NULL)

19.请说出const与#define 相比,有何优点?

答案:

const作用:定义常量、修饰函数参数、修饰函数返回值三个作用。被Const修饰的东西都受到强制保护,可以预防意外的变动,能提高程序的健壮性。

1) const 常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会产生意料不到的错误。

2) 有些集成化的调试工具可以对const 常量进行调试,但是不能对宏常量进行调试。

20.简述数组与指针的区别?

数组要么在静态存储区被创建(如全局数组),要么在栈上被创建。指针可以随时指向任意类型的内存块。

(1)修改内容上的差别

char a[] = “hello”;

a[0] = ‘X’;

char *p = “world”; // 注意p 指向常量字符串

p[0] = ‘X’; // 编译器不能发现该错误,运行时错误

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

char a[] = "hello world";

char *p = a;

cout<< sizeof(a) << endl; // 12 字节

cout<< sizeof(p) << endl; // 4 字节

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

void Func(char a[100])

{

cout<< sizeof(a) << endl; // 4 字节而不是100 字节

}


25题:引用与指针有什么区别?                      

1) 引用必须被初始化,指针不必。

2) 引用初始化以后不能被改变,指针可以改变所指的对象。

3) 不存在指向空值的引用,但是存在指向空值的指针。

 

 

26题:const  与 #define 的比较 ,const有什么优点?


(1) const 常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会产生意料不到的错误(边际效应) 。

(2)  有些集成化的调试工具可以对 const 常量进行调试,但是不能对宏常量进行调试。

 

 

 

27题:复杂声明

void * ( * (*fp1)(int))[10];

float (*(* fp2)(int,int,int))(int);

int (* ( * fp3)())[10]();

分别表示什么意思?                                                         

1.void * ( * (*fp1)(int))[10];   fp1是一个指针,指向一个函数,这个函数的参数为int型,函数的返回值是一个指针,这个指针指向一个数组,这个数组有10个元素,每个元素是一个void*型指针。

2.float (*(* fp2)(int,int,int))(int);   fp2是一个指针,指向一个函数,这个函数的参数为3个int型,函数的返回值是一个指针,这个指针指向一个函数,这个函数的参数为int型,函数的返回值是float型。

3.int (* ( * fp3)())[10]();   fp3是一个指针,指向一个函数,这个函数的参数为空,函数的返回值是一个指针,这个指针指向一个数组,这个数组有10个元素,每个元素是一个指针,指向一个函数,这个函数的参数为空,函数的返回值是int型。

 

 

 

28题:内存的分配方式有几种?

一、从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量。

二、在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。

三、从堆上分配,亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存,程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定,使用非常灵活,但问题也最多。

 

 

29题:基类的析构函数不是虚函数,会带来什么问题?

【参考答案】派生类的析构函数用不上,会造成资源的泄漏。

 

30题:全局变量和局部变量有什么区别?是怎么实现的?操作系统和编译器是怎么知道的?

【参考答案】

生命周期不同:

全局变量随主程序创建和创建,随主程序销毁而销毁;局部变量在局部函数内部,甚至局部循环体等内部存在,退出就不存在;

使用方式不同:通过声明后全局变量程序的各个部分都可以用到;局部变量只能在局部使用;分配在栈区。 

操作系统和编译器通过内存分配的位置来知道的,全局变量分配在全局数据段并且在程序开始运行的时候被加载。局部变量则分配在堆栈里面 。

8.tcp为什么要三次握手,tcp为什么可靠。

为什么不能两次握手:(防止已失效的连接请求又传送到服务器端,因而产生错误)

假设改为两次握手,client端发送的一个连接请求在服务器滞留了,这个连接请求是无效的,client已经是closed的状态了,而服务器认为client想要建立

一个新的连接,于是向client发送确认报文段,而client端是closed状态,无论收到什么报文都会丢弃。而如果是两次握手的话,此时就已经建立连接了。

服务器此时会一直等到client端发来数据,这样就浪费掉很多server端的资源。

(校注:此时因为client没有发起建立连接请求,所以client处于CLOSED状态,接受到任何包都会丢弃,谢希仁举的例子就是这种场景。但是如果服务器发送对这个延误的旧连接报文的确认的同时,客户端调用connect函数发起了连接,就会使客户端进入SYN_SEND状态,当服务器那个对延误旧连接报文的确认传到客户端时,因为客户端已经处于SYN_SEND状态,所以就会使客户端进入ESTABLISHED状态,此时服务器端反而丢弃了这个重复的通过connect函数发送的SYN包,见第三个图。而连接建立之后,发送包由于SEQ是以被丢弃的SYN包的序号为准,而服务器接收序号是以那个延误旧连接SYN报文序号为准,导致服务器丢弃后续发送的数据包)

三次握手的最主要目的是保证连接是双工的,可靠更多的是通过重传机制来保证的。 

TCP可靠传输的实现:

TCP 连接的每一端都必须设有两个窗口——一个发送窗口和一个接收窗口。TCP 的可靠传输机制用字节的序号进行控制。TCP 所有的确认都是基于序号而不是基于报文段。
发送过的数据未收到确认之前必须保留,以便超时重传时使用。发送窗口没收到确认不动,和收到新的确认后前移。

发送缓存用来暂时存放: 发送应用程序传送给发送方 TCP 准备发送的数据;TCP 已发送出但尚未收到确认的数据。

接收缓存用来暂时存放:按序到达的、但尚未被接收应用程序读取的数据; 不按序到达的数据。必须强调三点:

    1>   A 的发送窗口并不总是和 B 的接收窗口一样大(因为有一定的时间滞后)。
2> TCP 标准没有规定对不按序到达的数据应如何处理。通常是先临时存放在接收窗口中,等到字节流中所缺少的字节收到后,再按序交付上层的应用进程。
3> TCP 要求接收方必须有累积确认的功能,这样可以减小传输开销(累积确认:一般地讲,如果发送方发了包1,包2,包3,包4;接受方成功收到包1,包2,包3。

那么接受方可以发回一个确认包,序号为4(4表示期望下一个收到的包的序号;当然你约定好用3表示也可以),那么发送方就知道包1到包3都发送接收成功,必要时重发包4。一个确认包确认了累积到某一序号的所有包。而不是对没个序号都发确认包。)TCP报文格式  :

(1)序号:Seq序号,占32位,用来标识从TCP源端向目的端发送的字节流,发起方发送数据时对此进行标记。

  (2)确认序号:Ack序号,占32位,只有ACK标志位为1时,确认序号字段才有效,Ack=Seq+1。
  (3)标志位:共6个,即URG、ACK、PSH、RST、SYN、FIN等,具体含义如下:
    (A)URG:紧急指针(urgent pointer)有效。
    (B)ACK:确认序号有效。
    (C)PSH:接收方应该尽快将这个报文交给应用层。
    (D)RST:重置连接。
    (E)SYN:发起一个新连接。
    (F)FIN:释放一个连接。

 需要注意的是:
  (A)不要将确认序号Ack与标志位中的ACK搞混了。
  (B)确认方Ack=发起方Req+1,两端配对。

  • 三次握手

TCP三次即建立TCP连接,指建立一个TCP连接时,需要客户端服务端总共发送3 个包以确认连接的建立。在socket编程中,这一过程中由客户端执行connect来触发,流程如下:(1)第一次握手:Client将标志位SYN置为1(表示要发起一个连接),随机产生一个值seq=J,并将该数据包发送给Server,Client进入SYN_SENT状态,等待Server确认。

(2)第二次握手:Server收到数据包后由标志位SYN=1知道Client请求建立连接,Server将标志位SYN和ACK都置为1,ack=J+1,随机产生一个值seq=K,并将该数据包发送给Client以确认连接请求,Server进入SYN_RCVD状态。
(3)第三次握手:Client收到确认后,检查ack是否为J+1,ACK是否为1,如果正确则将标志位ACK置为1,ack=K+1,并将该数据包发送给Server,Server检查ack是否为K+1,ACK是否为1,如果正确则连接建立成功,Client和Server进入ESTABLISHED状态,完成三次握手,随后Client与Server之间可以开始传输数据了。

 SYN攻击:

  在三次握手过程中,Server发送SYN-ACK之后,收到Client的ACK之前的TCP连接称为半连接(half-open connect),此时Server处于SYN_RCVD状态,当收到ACK后,Server转入ESTABLISHED状态。SYN攻击就是Client在短时间内伪造大量不存在的IP地址,并向Server不断地发送SYN包,Server回复确认包,并等待Client的确认,由于源地址是不存在的,因此,Server需要不断重发直至超时,这些伪造的SYN包将产时间占用未连接队列,导致正常的SYN请求因为队列满而被丢弃,从而引起网络堵塞甚至系统瘫痪。SYN攻击时一种典型的DDOS攻击,检测SYN攻击的方式非常简单,即当Server上有大量半连接状态且源IP地址是随机的,则可以断定遭到SYN攻击了,使用如下命令可以让之现行:
#netstat -nap | grep SYN_RECVddos攻击:
分布式拒绝服务(DDoS:Distributed Denial of Service)攻击指借助于客户/服务器技术,将多个计算机联合起来作为攻击平台,对一个或多个目标发动DDoS攻击,从而成倍地提高拒绝服务攻击的威力。通常,攻击者使用一个偷窃帐号将DDoS主控程序安装在一个计算机上,在一个设定的时间主控程序将与大量代理程序通讯,代理程序已经被安装在网络上的许多计算机上。代理程序收到指令时就发动攻击。利用客户/服务器技术,主控程序能在几秒钟内激活成百上千次代理程序的运行。

 

  • 四次挥手

所谓四次挥手(Four-Way Wavehand)即终止TCP连接,就是指断开一个TCP连接时,需要客户端和服务端总共发送4个包以确认连接的断开。在socket编程中,这一过程由客户端或服务端任一方执行close来触发,整个流程如下图所示:由于TCP连接时全双工的,因此,每个方向都必须要单独进行关闭,这一原则是当一方完成数据发送任务后,发送一个FIN来终止这一方向的连接,收到一个FIN只是意味着这一方向上没有数据流动了,即不会再收到数据了,但是在这个TCP连接上仍然能够发送数据,直到这一方向也发送了FIN。首先进行关闭的一方将执行主动关闭,而另一方则执行被动关闭,上图描述的即是如此。

 (1)第一次挥手:Client发送一个FIN,用来关闭Client到Server的数据传送,Client进入FIN_WAIT_1状态。
 (2)第二次挥手:Server收到FIN后,发送一个ACK给Client,确认序号为收到序号+1(与SYN相同,一个FIN占用一个序号),Server进入CLOSE_WAIT状态。
 (3)第三次挥手:Server发送一个FIN,用来关闭Server到Client的数据传送,Server进入LAST_ACK状态。
 (4)第四次挥手:Client收到FIN后,Client进入TIME_WAIT状态,接着发送一个ACK给Server,确认序号为收到序号+1,Server进入CLOSED状态,完成四次挥手。

 为什么需要TIME_WAIT

TIMEWAIT状态也称为2MSL等待状态。

 1)为实现TCP这种全双工(full-duplex)连接的可靠释放

2)为使旧的数据包在网络因过期而消失

每个具体TCP实现必须选择一个报文段最大生存时间MSL(Maximum Segment Lifetime)。它是任何报文段被丢弃前在网络内的最长时间。

为什么建立连接是三次握手,而关闭连接却是四次挥手呢?

 这是因为服务端在LISTEN状态下,收到建立连接请求的SYN报文后,把ACK和SYN放在一个报文里发送给客户端。而关闭连接时,当收到对方的FIN报文时,仅仅表示对方不再发送数据了但是还能接收数据,我们也未必全部数据都发送给对方了,所以我们不可以立即close,也可以发送一些数据给对方后,再发送FIN报文给对方来表示同意现在关闭连接,因此,我们的ACK和FIN一般都会分开发送。

4 多态, 虚函数, 纯虚函数

多态:不同对象接收相同的消息产生不同的动作。多态包括 编译时多态和 运行时多态

    运行时多态是:通过继承和虚函数来体现的。
       编译时多态:运算符重载上。

虚函数: 在基类中用virtual的成员函数。允许在派生类中对基类的虚函数重新定义。
       基类的虚函数可以有函数体,基类也可以实例化。
       虚函数要有函数体,否则编译过不去。
       虚函数在子类中可以不覆盖。
       构造函数不能是虚函数。

纯虚函数:基类中为其派生类保留一个名字,以便派生类根据需要进行定义。
       包含一个纯虚函数的类是抽象类。
       纯虚函数后面有 = 0;
       抽象类不可以实例化。但可以定义指针。
       如果派生类如果不是先基类的纯虚函数,则仍然是抽象类。
        抽象类可以包含虚函数。

5 抽象类和接口的区别  

       在C++里面抽象类就是接口

     抽象类:定义了纯虚函数的类是抽象类,不能实例化。
        抽象类包括抽象方法(纯虚方法),也可以包含普通方法。
        抽象类可以派生自一个抽象类,可以覆盖基类的抽象方法也可以不覆盖。
        虽不能定义抽象类的实例,但是可以定义抽象类的指针。

6 什么是“引用”?声明和使用“引用”要注意哪些问题?

         引用的特性:

                 引用是目标变量的别名,对引用的操作与对变量的操作效果一样。声明引用的时候要必须对其初始化。引用声明完后,相当于目标变量有两个名称,不能     再把引用作为其他变量的别名。

                 引用不是新定义一个变量,它只是表示该引用是目标变量名的一个别名,它本身不是一种数据类型,因此引用不占用存储单元。

                 无法建立数组的引用。因为数组是一个由若干元素组成的集合,无法建立数组的别名。

         引用的作用:

                 作为函数的参数,以前用值传递,现在用指针或引用。

                 传引用和传指针给函数效果一样的。

                 传递引用,内存中没有生成实参副本,是直接对实参操作。如果传递的是值类型,需要在栈上生成副本,如果是对象,还要调用构造函数。

                  引用作为返回值最大的好处是:内存中不会产生副本。

                  但是,引用作为返回值注意事项:

                  A:不能返回局部变量的引用。

                  B:不能返回函数内部new的变量。因为引用仅仅是别名,无法释放内存。

                  C: 可以返回类成员的引用,但是最好是const

                  D : 引用和指针一样,可以产生多态的效果。

   总结:    

             A: 引用的使用主要用于函数传参,解决大块数据或对象的问题。
             B: 用引用传递函数参数,不产生副本,通过const,保证引用传递的安全性。
             C:比指针的可读性好,

7 将引用作为函数参数有哪些特点   

8 什么时候用常引用

         const int &ra = a;   // 不能通过引用对目标变量的值进行修改,从而使引用的目标成为const的,安全。

         void bar(String &ra)

         bar("AA")  // 这个会报错,因为 ”AA“相当于 const char[], 不能传递给bar函数。

          可以把函数声明为Void bar(Const String &ra), 上述语句就不会报错。

9  引用作为函数返回值类型的格式,好处和规则?

            int &fun(int a) {}

             好处:不会生成副本。

             规则:    不能返回局部变量的引用;不能返回函数内部new分配的内存引用; 如果返回成员的话,返回const'

10  结构与联合的区别

              联合是公用存储单元的,任何一个时刻只有一个被选中的成员。一旦赋值后,其他成员也覆盖了。

11 重载(overload)和重写(override)?

       重载:多个同名函数,参数不同(个数不同,参数类型不同);是同一层级的函数;静态绑定;编译期绑定。

       重写:子类重新定义父类函数的方法;是动态绑定。

12  有几种情况用intialization list(初始化列表)而不是assignment(赋值)?

           当类中含有const成员变量; reference成员变量; 基类构造函数需要初始化列表。

13  C++是不是类型按群的?

         不是; 两个不同类型的指针之间可以强制转换。

14  main函数之前会执行什么代码?

      全局变量的初始化。

15 内存分配方式和区别

  (1)静态存储区:在编译时就分配好,在整个运行期间都存在。比如全局变量,static变量。

  (2)常量区: 存放常量的,比如字符串常量。

  (3)堆

  (4)栈

16 BOOL,int,float,指针类型,于”零“的比较语句。

   BOOL: if(!a)  or  if(a)

           int:  if(a == 0)

           float:  const EXPRESSION exp = 0.000001

                     if (a < EXP && a > -EXP)

           指针:  if(a != NULL)

17  const 与 #define相比,优点?

       const:    定义常量;  修饰函数参数;   修饰函数返回值;     修饰类成员函数。

       好处:     const 修饰的有数据类型,而宏没有,所以可以做类型检查;而宏仅作字符替换,无安全检查。

                     const常量可以调试

                     宏有副作用。不加括号的话有副作用。

18 数组和指针的区别

     数组要么在静态存储区创建,要么在栈上创建。指针可以随时指向任意类型的内存块。

      char a[] = "khell"; // 栈中分配内存,所以可以修改。
      a[0] = 'x'; // 可以 没有问题
      char *p = "khell";//常量字符串,存储在字符常量区,不可以修改


       p[0] = 'x'; // 编译可以,运行时错误。
       sizeof(a) //是数组的大小;
       sizeof(p) // 是指针的大小4.

       当数组作为函数参数进行传递时,该数组退化成指针

  void Func(char a[100])
  {
    cout<< sizeof(a) << endl; // 4 字节而不是100 字节
  }

        数组名不能自加自减,但是指针可以。

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

19 int(*s[10])(int)         

        函数指针数组,S[10]里面每个元素都是函数指针,指向函数的类型是 int  fun(int a)

                  void add(int a, int b)
                   {
                     cout << a + b << endl;
                   }

      void (*p1)(int a, int b);
      p1 = add;

20 为什么基类的析构函数是虚函数?

       动态绑定,不会造成潜在的内存泄漏

21 全局变量和局部变量的区别?如何实现的?操作系统和编译器是怎么知道的?

        全局变量分配在全局数据段(静态存储区),在程序开始运行时候加载。局部变量则分配在堆栈里面。

22  内存分配方式

自由存储区:用malloc /free分配释放。 和堆类似。

全局/静态存储区:全局变量,静态变量。

常量存储区:放常量,不允许修改。

int a=0;    全局/静态存储区
char *p1;  全局/静态存储区 
int main() 

int b; //栈 
char s[]="abc"; //栈 
char *p2; //栈 
char *p3="123456"; //123456在常量区,p3在栈上。

static int c =0;//全局(静态)初始化区 
p1 = (char *)malloc(10); //分配得来得10和20字节的区域就在堆区
p2 = (char *)malloc(20); 
strcpy(p3,"123456"); //123456/0放在常量区,编译器可能会将它与p3所指向的"123456" 优化成一个地方。 
}

23 void *(*(*fp1)(int)[10]  / float(*(*fp2)(int, int, int))(int)  /  int (*(*fp3())[10]()

24 引用与指针区别:
  引用必须初始化,指针不用。
  引用初始化后不能改变,指针可以改变所指的内容。
  不存在指向空值的引用,但是存在指向空值的指针。
  指针可以有多级;引用就一级。
  指正要解引用,引用不用。
  引用没有const, 但是指针有。
  sizeof结果不同。
  自增的语义不同。

25 int id[sizeof(unsigned long)] 合法吗?
可以。数组的大小在编译的时候就要确认。

27 虚函数 VS 纯虚函数
  虚函数为了重载和多态,在基类中是有定义的,即便定义为空。在子类中可以重写。
  纯虚函数在基类中没有定义,必须在子类中实现。
  多态的基础是继承,需要虚函数的支持。

28 子类不能继承父类的函数
  子类继承父类大部分的资源,不能继承的有构造函数,析构函数,拷贝构造函数,operator=函数,友元函数。

29 开发中常用的数据结构:
  A:数组和链表:
    数组大小不能动态定义。链表和动态分配大小的。 
    数组不适应动态增/减的情况,因为大小固定,一旦定义就不能改变。
    链表适合动态的增加、删除数据。
    数组的随机访问快。
    数组栈中分配; 链表在堆中。
  B:二叉树遍历:
    先序、中序、后序。

30 const与static的用法
  const:
    修饰类成员变量,成员不可以改。

               修饰函数参数;

               修饰返回值;
    修饰函数,函数不会修改类内的数据成员。不会调用非const成员函数。(在函数末尾,默认是const this指针,不能修改成员)
    const函数只能调用const函数,非const函数可以调用const函数。
  static:
    局部static变量:局部静态变量,处于内存中的静态存储区;只能初始化一次;作用域是局部。
    全局static变量:全局静态变量,静态存储区;全局静态变量的作用局是声明它的文件,在文件之外是不可见的。其实是从
    定义的地方到文件结尾。

  类的static成员:类的全局变量,被类的所有独享共享,包括派生类的对象。按照这种方式int base::var = 10;进行
  初始化,不能在构造函数内初始化,但是可以用const修饰的static数据成员在类内初始化。

  static修饰成员函数,类只有一份,不含this指针。
  static成员变量定义放在cpp文件中。 const static 可以就地初始化。

31 类的static变量在什么时候初始化,函数的static变量什么时候初始化?
         类的静态成员在类实例化之前就存在了; 函数的static变量在执行此函数时进行实例化(第一次调用的时候,只初始化一次)

32 栈溢出的原因:

  栈大小有限制:分过多的数组; 
  递归调用层太深;

33 switch参数类型
  可以是:byte short int long bool
  不能是: float double(这种浮点型的不能精确的比较,所以不能) string
  但是在c++ 11里面, string可以作为switch的条件了。

35 频繁出现的短小的函数,在c/C++中分别如何实现
  c中用宏定义; C++ 内联

36 C++函数传参数方式

  值传递、指针、引用

37 定义宏注意什么?
  定义部分的每个形参和整个表达式都必须用括号括起来。

38 .h头文件中的ifndef/define/endif作用
  防止头文件重复包含

39 struct VS class
  struct的成员默认是共有的,而类的成员默认是私有的。
  继承的的时候,class默认是私有继承;结构体是共有继承;
  class还用于定义模板参数,就像typename

40 系统会自动打开和关闭的三个标准文件是?

  在C语言中,在程序开始运行时,系统自动打开3个标准文件:标准输入、标准输出、标准出错输出。通常这3个文件都与终端相联系。因此,以前我们所用到的从终端输入或输出都不需要打开终端文件。系统自定义了3个文件指针 stdin、stdout、stderr,分别指向终端输入、终端输出和标准出错输出(也从终端输出)。

  标准输入流:stdin

       标准输出流:stdout

  标准错误输出流:stderr

41 如何判断浮点数是否是0.5
  fabs(x - 0.5)< DBL_DEPSILON

42 内存泄漏? 指针越界和内存泄漏,有哪些方法?
  new/delete, new[]/delete, malloc/free 配套使用
  对指针赋值的时候,一定要看原来指向的东西是否需要释放
  指针指向的东西释放后,一定要将指针设置为null。

43 TCP、UDP差别
  TCP: 面向连接, 有保障, 效率低, 基于流的,重要数据
  udp:    无连接 无保障 效率高 基于数据报文 不重要的数据

44  #include<file.h> #include "file.h" 
  前者是从标准库路径寻找
  后者是从当前工作路径

        H:sizeof不能返回外部数组的大小,因为sizeof是编译时常量(函数调用的时候,数组退化成指针)

38 sizeof VS strlen
  sizeof() 返回值类型为size_t(unsigned int) 
  sizeof是运算符,strlen是函数
  sizeof的参数可以是类型,变量或函数。而strlen只能用char*做参数,必须以'\0'结尾
  数组指针作为sizeof参数会退化为指针,但是传递给strlen的无论是数组还是指针不会退化为指针。
  char *p = "chinaaaa";
  char q[] = "chinaaaa";
  cout << sizeof(p) << endl; 4 // 就是指针
  cout << sizeof(q) << endl; 9
  cout << strlen(p) << endl; 8 
  cout << strlen(q) << endl; 8

  sizeof是编译时常量,而strlen运行的时才会计算处理,而且是字符个数,不算最后的结尾字符。

40 空指针和悬挂指针
  空指针是等于null的指针; 悬挂指针是delete后没有置空的野指针。
  A: 空指针可以被delete多次,而野指针多次delete会很不稳定。
  B: 二者都容易导致程序崩溃。

41 C++空类,有哪些成员函数?
  默认构造函数, 析构函数, 赋值构造函数, 赋值函数。
  class Empty
  { Empty(); // 缺省构造函数,如果用户定义构造函数,就没有这个缺省的了。无this指针。
    // 两种办法初始化:
      初始化列表:效率高。常量成员变量/引用类型/无缺省构造函数的类成员,必须用初始化列表,函数体内赋值
  Empty(const Empty&)     // 拷贝构造函数,直接用对象赋值。必须是引用。注意深拷贝/浅拷贝的问题。
             // 3种情况调用拷贝构造函数 :  一个对象初始化另一个对象;
                                函数形参是类对象,调用函数的时候;
                                 函数返回值是对象

  ~Empty(); 
  // 析构函数,无参,无返回值,所以不能重载。

  Empty& operator=(const Empty&);
  }

42 所有的函数都设置为虚函数?
  不行。 每个虚函数的对象要维护虚函数表。代价高。

43 共有继承 受保护继承 私有继承
  共有继承:可以访问基类中的公有成员,派生类可以访问公有的和受保护的成员;
  受保护继承:
  私有继承:

44 阻止类实例化

         抽象基类 或者 构造函数是private

46 main函数执行之前会执行什么?执行之后还能执行代码吗?
  全局对象的构造函数在main函数之前执行。
  用_onexit注册一个函数,在main执行之后就会调用这个函数.

47 函数参数入栈的顺?
  从右端往左进入栈的。为了支持可变参数(原理要懂得)。

48 类的static变量的定义和初始化

   static int Sum;//在头文件中声明静态数据成员
  int Myclass::Sum=0;//定义并初始化静态数据成员,在类的外部。

50 父类写了一个virtual函数,如果子类覆盖它函数不加virtual,可以多态吗?
  可以; 子类可写,可不写。

51 子类的空间中,有无父类的virtual函数,或者私有变量?

      答:除了static的,其他的都有。

52 sprintf/strcpy/memcpy
  sprintf: 其他字符串或基本类型向字符串的转换功能。是一种格式化。
  strcpy: 操作的是字符串,从源字符到目的字符串拷贝功能。
  memcpy:内存拷贝。内存块内容复制。

53 内联函数在编译时是否做类型检查
  内联函数要做类型检查,这是内联函数比宏的优势

54 c/C++的结构体区别:
      c++的结构体和class几乎一样。结构体可以继承,可以有函数,可以实现多态。

          区别是:结构体成员默认是public的,而类是private的;

                         另外class可以作为模板中的一个关键字 template<Class T>

                         默认的继承访问权限不同,struct是public的继承;class 是private的继承。

 

  c 的结构体不具备面向对象的特征,有变量,没有函数,但是可以有函数指针。

55 如何判断一段程序是C编译程序还是C++编译程序编译的?
  #ifdef __cplusplus
    cout << "c++" << endl;
  #else
    cout << "c";
  #endif

56 C ++ 在c基础上加了什么?
  A:包含全部的C语言部分。
  B:面向对象部分,封装,继承,多态。
  C:泛型编程部分,模板,方便使用。
  D:STL库。

57 全局变量和局部变量
  分配的区域不同: 全局数据区 vs 栈
  声明周期不同: 主程序 vs 函数内部
  可见性不同: 全局 VS 局部

58 有N个大小不等的自然数(1–N),请将它们由小到大排序.要求程序算法:时间复杂度为O(n),空间复杂度为O(1)。#include <iostream>  

#include <algorithm>  
#include
<iterator>

void sort(int*, int);
int main(){
int arr[] = {5,9,3,7,4,2,8,6,1,10};
int n = sizeof(arr)/sizeof(int);
sort(arr, n);
std::copy(arr,arr
+n,std::ostream_iterator<int>(std::cout, ","));
std::cout
<< std::endl;
return 0;
}

void sort(int *arr, int n)
{
int count = 0;//此数据不是算法必须,用来计算算法循环次数。
int i;
int tmp;
for(i=0;i<n;++i){
while( (i + 1) != arr[i]){
tmp
= arr[i];
arr[i]
= arr[tmp-1];
arr[tmp
-1] = tmp;
++count; //算法每循环一次加一。
}
}
std::cout
<< "count = " << count << std::endl; //最后得出的循环次数小于等于n。
} 59 宏,内联函数,函数 区别

  宏效率高,编译时替换,没有类型检查,可能有副作用。
  内联函数有类型检查,效率高,替换,当然也有可能不替换。一般函数短可以用内联,长的话编译器可以优化不内联。
  函数,调用过程入栈、出栈,效率低。

61 常引用的作用
  传递给函数的数据在函数中不被改变

62 引用与多态的关系?  

        引用和指针可以实现多态。

63 多态作用
  代码模块化,扩展代码模块,实现代码重用。

64 隐藏

  隐藏:派生类的函数屏蔽了同名的基类函数:
  派生类函数与基类函数同名,参数不同,无论有无virtual关键字,基类函数被隐藏(不是重载)
  派生类函数与基类函数同名,参数相同,基类无virtual, 基类被隐藏。

65 a,b两个变量,不用 if,else, 不用switch,不用三目表达式。找到最大的那个?

       找最大的:  (a + b + abs(a-b) )  /  2   

       找最小的:  (  a + b - abs(a-b)  )   / 2 

 

66  打印文件名行号
  cout << __FILE__ << " " << __LINE__ << endl;

67 程序在结束的时候,系统会自动析构所有的全局变量。
       事实上,系统也会析构所有的类的静态成员变量,就像这些静态成员也是全局变量一样

68:pragma once ,  ifdefine

  #pragma once是编译器相关的,有的编译器支持,有的编译器不支持,具体情况请查看编译器API文档,不过现在大部分编译器都有这个杂注了。
  #ifndef,#define,#endif是C/C++语言中的宏定义,通过宏定义避免文件多次编译。所以在所有支持C++语言的编译器上都是有效的,如果写的程序要跨平台,最好使用这种方式

69: 函数的const参数构成重载函数
  如果是值传递的函数,值的const 和非const 不构成重载。
  如果是引用和指针的可以构成重载
  非const 可以调用const。
  const 不可调用非const的。
  调用重载函数的时候 会选择最匹配的那个

70:C++ 全局变量/常量解析

  编译单元:编译成obj文件,然后link成.exe,编译主要是看语法错误;链接主要是重复定义或者没有定义。

  声明与定义:函数或变量在声明的时候,没有给实际的物理内存空间,它有时候可以保证编译能通过;

                             当函数或变量定义的时候,它就在内存中有了实际的物理空间。声明可以多次,但是定义只能一次。

      extern 作用: 

                   A: extern "C"  void fun(int a, int b),在编译fun这个函数时按照C的规则区翻译相应的函数名,而不是c++. 

                   B: extern作用:你现在编译的文件中,有一个变量或函数虽然在本文件中没有定义,但是在别的文件中定义的全局变量。

          在头文件中: extern int g_int 作用是声明函数或全局变量的作用范围的关键字,其声明的函数或变量

                    可以在本模块或其他模块中使用,记住,这是声明不是定义!也就是说b模块引用a 中定义的全局变量或

                    函数,它包含a的头文件,就可以在编译阶段通过,b模块在链接的时候从模块a生成的目标代码中找到
                    此函数或变量。

                        错误的做法:在stdafx.h中定义int globalINt = 0; 然后在其他.cpp文件中extern int globalINt ;总是提示重复定义。 原因是:.h文件会被包含多次,相当于

                                             定义多次。

                         正确的做法: 不在.h文件中定义, 而是在.cpp文件中定义。在.h文件中声明。这样就是多次声明。 链接的

                         

       注意:  int a ;   // 这个也是定义,虽然没有给赋值。extern int a 才是声明
                                 extern const int globalINt = 1;    //当这个给它赋值了,也可以看做是定义。
                                       只有当extern声明位于函数外部时,才可以含有初始化式。

                         

        问题1: 一个源文件定义了 char a[6];  另外一个文件用下列语句进行了声明: extern char *a, 这样可以吗?
        答案:不可以。因为指向类型T的指针并不等价于类型T数组。提示我们:声明和定义要严格一样的格式。

                            

        问题2: 如果用extern函数的方式引用全局函数,当函数原型修改后,比如加了个参数,编译居然不报告错。
        解决方案:通常提供函数放在自己的XX.h文件中声明和这个函数,其他的调用方include该头文件,从而省去
             extern这一步,可以避免上述错。

  

71: extern "C "
  #ifndef XXXXXXX
  #define XXXXXXX //避免重复包含头文件, #pragma once 可以实现同样的功能

  #ifdef __CPLUSCPLUS
    extern "C"{
  #endif

    #ifdef __cplusplus
  }
  #endif
  # endif


73 字符数组和字符串          

        注意最后一个'\0'.

  char str[10] =  {'a','b','c'}  // 不是以 '\0'结尾
  char *p = "abc";   // 是以'\0'结尾

74 static 文件作用域的问题   

  当同时编译多个文件时,所有未加static的全局变量和函数都是全局可见的(其他文件加上的extern就行)。
  用static修饰全局变量,可见性就是本文件,这样可以在不同的源文件中定义同名的函数和变量,不担心冲突。
  static函数: 主要就是为了隐藏(只在本文件中可以看到)。
  static变量: 一是隐藏; 另外是保持变量内容的持久。存储在静态区域的变量会在程序刚刚运行时就完成初始化,
                         也是唯一的一次初始化(初始化只是一次,但是可以改变值)
  static 还有一个作用:默认初始化为0,其实全局变量也是这样的。

75 字节对齐,类对象占据内存
  字节对齐好处:为了提高存取效率,读取int类型的时候,一次读取就OK。否则要高低字节拼接才行。

  下面代码演示了:单独对一个结构体的字节对齐方式进行设置。 
  #pragma pack(push) // 将当前pack设置压栈保存
  #pragma pack(2)// 必须在结构体定义之前使用
  struct S1
  {
  char c;
  int i;
  };
  struct S3
  {
  char c1;
  S1 s;
  char c2
  };

  pack影响的的是偏移量。

  注意:空结构体,空对象的占据空间是1个字节。

  #include <stdio.h>
  union
  {
    int i;
    char x[2];
  }a;

  void main()
  {
    a.x[0] =10; 
    a.x[1] =1;
    printf("%d",a.i);
  }

76  进程之间通信
  消息队列:存放在内核中,是链表的形式。
  匿名管道:CreatePipe(); 只能本地使用。管道是半双工的。只能是父子进程之间通信
  命名管道:也是半双工,但是可在无亲缘关系的进程之间通信。可用于网络通信,可以通过名称引用;支持多客户端链接,双向通信;
  共享内存(内存映射文件):CreateFileMapping .创建内存映射文件,是多个进程对同一块物理内存的映射。(因为是共享内存的方式,读写之间有冲突)
               共享内存的效率是最高的,因为共享一块都能看见的内存,不用多份拷贝,而且访问共享内存相当于内存中区域一样,
               不需要通过系统调用或者切入内核来完成。但是需要字节提供同步措施。一般用信号量解决读写冲突。
       socket: 可以跨越机器

77 类型转换
  隐式类型转换:int 类型 和float类型相加,会转成float
  显式类型转换:static_cast /   dynamic_cast /  const_cast / reinterpret_cast
   static_cast: static_cast <type-id> (expression)主要用于非多态类型之间的转化:
          用于类层次结构中,基类和子类之间指针和引用的转换;
          当进行上行转换,也就是把子类的指针或引用转换成父类表示,这种转换是安全的;
          当进行下行转换,也就是把父类的指针或引用转换成子类表示,这种转换是不安全的,也需要程序员来保证;
          基本数据类型之间的转换,如把int转换成char,把int转换成enum等等,这种转换的安全性需要程序员来保证;
           把void指针转换成目标类型的指针,是极其不安全的;

   dynamic_cast: dynamic_cast <type-id> (expression),因为是动态,主要是考虑多态的问题。
          type-id必须是类的指针,类的引用或者是void*, 如果是指针,expression也是指针;如果是引用,expression也是
          引用。主要用于类层次之间的上行/下行转换,以及类之间的交叉转。在类上行转换的时候和static_cast一样;下行
          转换的时候,比static 安全。 多态类型之间转换,主要使用dynamic_cast, 因为类型提供了运行时信息。 
          class b: Public A
          {};

          B *pb = new B;
          A *Pa = dynamic_cast<A*>(pb); //安全的、


          下面是转换成Void*,A和B没有关系,但是都有虚函数
          void *pV = dynamic_cast<void *>(pA); // pV points to an object of A
          pV = dynamic_cast<void *>(pB); // pV points to an object of B

          // 因为向下转换是不安全的,所以dynimac做检查。这就是动态比静态好的原因。
          如果expression是type-id的基类,使用dynamic_cast进行转换时,在运行时就会检查expression是否真正的指向一个type-id类型的对象,如

                                     果是,则能进行正确的转换,获得对应的值;否则返回NULL,如果是引用,则在运行时就会抛出异常

    const_cast: const_cast <type-id> (expression)
            const_cast用来将类型的const、volatile和__unaligned属性移除。常量指针被转换成非常量指针,并且仍然指向原来的对象;
            常量引用被转换成非常量引用,并且仍然引用原来的对象

    reinterpret_cast: reinterpret_cast <type-id> (expression):
          允许将任何指针类型转换为其它的指针类型;听起来很强大,但是也很不靠谱。它主要用于将一种数据类型从一种类型
          转换为另一种类型。它可以将一个指针转换成一个整数,也可以将一个整数转换成一个指针,在实际开发中,
          先把一个指针转换成一个整数,在把该整数转换成原类型的指针,还可以得到原来的指针值;特别是开辟了系统全局
          的内存空间,需要在多个应用程序之间使用时,需要彼此共享,传递这个内存空间的指针时,
          就可以将指针转换成整数值,得到以后,再将整数值转换成指针,进行对应的操作。

static_cast和reinterpret_cast的区别主要在于多重继承,比如:

class A {
public:
int m_a;
};

class B {
public:
int m_b;
};

class C : public A, public B {};
那么对于以下代码:

注意:reinterpret_cast, 操作符修改了操作数类型,但仅仅是重新解释了给出的对象的比特模型而没有进行二进制转换。

78 虚函数表
  注意: 如果没有虚函数,那么就没有这个虚函数表的指针。虚函数表的指针(占4字节大小)影响sizeof的结果

  class Base {
  public:
  virtual void f() { cout << "Base::f" << endl; }
  virtual void g() { cout << "Base::g" << endl; }
  virtual void h() { cout << "Base::h" << endl; }

  };

  typedef void(*Fun)(void);

  pFun();

  虚函数表最后有一个结尾标志。

  一般继承(无虚函数覆盖):
  总结:A: 虚函数表按照其声明的顺序放在表中。
             B: 父类的虚函数在子类的虚函数前面。

  一般继承(有虚函数覆盖):
  总结:子类的覆盖的函数放在原来虚函数的位置。
              没有被覆盖的函数依旧。

  多重继承(无函数覆盖):情况比较复杂(多张虚函数表,所以也有多个指向不同函数表的指针)
  总结: 每个父类都有自己的虚表;子类的成员函数放到了第一个父类的虚表中。(所谓的第一个父类是按照声明顺序来判断的。)  

        多重继承(有虚函数覆盖) :
  多个父类虚函数表中的被覆盖的函数都会替换成子类的函数指针。这样我们就可以任一静态类型的父类来指向子类。

  安全线: 用父类的指针访问子类对象的非覆盖函数,会报错。
  虚函数如果是private的,但是可以通过虚函数表来访问的到的。

79 多重继承的二义性
  多个父类中有相同名称的变量或者函数。子类中要指明是哪个父类的。
  子类中同名的函数会覆盖父类的。

        子类如果和父类函数同名但是参数不同,子类会覆盖父类,但是用using (using Base::fun;)是可以实现父类和子类重载的

80 菱形继承
  N是基类(包含a成员和函数display),A和B分别继承N,C继承A和B。 
  A 和B 中都有a的存储空间。可以通过A和B做限定: c.A::a 和 c.B::display();

81 为什么用 exit()函数
  是历史原因,虽然现在大多数平台下,直接在 main() 函数里面 return 可以退出程序。但是在某些平台下,在 main() 函数里面 return 会导致程序永远不退出(因为代码已经执行完毕,程序却还没有收到要退出的指令)。换句话说,为了兼容性考虑,在特定的平台下,程序最后一行必须使用 exit() 才能正常退出,这是 exit() 存在的重要价值。

exit(1)表示进程非正常退出. 返回 1;
exit(0)表示进程正常退出. 返回 0.

在unix下的多进程中,n是该进程返回给父进程的值

在main函数中exit(0)等价于return 0.

82 广义表
非线性的数据结构,是线性表的一种推广。广义表中放松对表元素的原子限制,容许它们
具有自身的结构。人工智能领域的表处理语言LISP语言中,广义表是一种基本的数据结构,

广义表是n(n≥0)个元素a1,a2,…,ai,…,an的有限序列。
其中:
①ai 或者是原子或者是一个广义表。
②广义表通常记作:
Ls=( a1,a2,…,ai,…,an)。
③Ls是广义表的名字,n为它的长度。
④若ai是广义表,则称它为Ls的子表。
注意:
①广义表通常用圆括号括起来,用逗号分隔其中的元素。
②为了区分原子和广义表,书写时用大写字母表示广义表,用小写字母表示原子。
③若广义表Ls非空(n≥1),则al是LS的表头,其余元素组成的表(a1,a2,…,an)称为Ls的表尾。
④广义表是递归定义的[1]

① E=()
  E是一个空表,其长度为0。
② L=(a,b)
  L是长度为2的广义表,它的两个元素都是原子,因此它是一个线性表
③ A=(x,L)=(x,(a,b))
  A是长度为2的广义表,第一个元素是原子x,第二个元素是子表L。

一个表的"深度"是指表展开后所含括号的层数。

((a,b,(c,(d,e),f)),g) 的深度是4。

广义表的存储结构:
头尾表示法: 表中的数据可能是列表,也可能是单元素,所以节点的结构有两种:一种是表节点,表示列表;另外一种
是元素节点,用来表示单元素。
A:表节点:包括一个指向表头的指针和指向表尾的指针。
B:元素节点:
C:还需要一个标志位,0表示元素;1表示表节点。

孩子兄弟表示法:两种节点形式,一种是有孩子节点,表示列表;另外一种是无孩子节点,用来表示单元素。
在有孩子节点中包括一个指向第一个孩子的指针,和一个指向兄弟节点的指针
无孩子节点中包括一个指向兄弟的指针和该元素的元素值。
为了能区分这两类节点,在节点中还要设置一个标志域:标志1表示有孩子节点,标志0,则
表示无孩子节点。

83 广义表((a,b),c,d)表头和表尾分别是?
头(a,b) // 第一个
表尾(c,d) // 除了第一个剩下的加上括号就是表尾。

84 堆和栈区别



以上是关于程序员面试之——C++的主要内容,如果未能解决你的问题,请参考以下文章

前端面试题之手写promise

程序员面试之——C++

面试常见问答之C++:1 - 10

面试问题之C++语言:OverloadOverride及Overwirte的区别

面试必备 | 常见C++笔试面试题整理

这些 C++ 代码片段有啥作用?