为什么直接编译不ok呢?gcc默认应该在当前文件夹下寻找自己定义的头文件的啊...然后在连接的时候搞定啊,奇怪.试过了iquote和-L选项都不ok,

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

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

类继承是在编译时刻静态定义的，且可直接使用，类继承可以较方便地改变父类的实现。但是类继承也有一些不足之处。首先，因为继承在编译时刻就定义了，所以无法在运行时刻改变从父类继承的实现。更糟的是，父类通常至少定义了子类的部分行为，父类的任何改变都可能影响子类的行为。如果继承下来的实现不适合解决新的问题，则父类必须重写或被其他更适合的类替换。这种依赖关系限制了灵活性并最终限制了复用性。

在面向对象程序设计语言中，封装是利用可重用成分构造软件系统的特性，它不仅支持系统的可重用性，而且还有利于提高系统的可扩充性；消息传递可以实现发送一个通用的消息而调用不同的方法；封装是实现信息隐蔽的一种技术，其目的是使类的定义和实现分离。

析构函数调用的次序是先派生类的析构后基类的析构，也就是说在基类的的析构调用的时候,派生类的信息已经全部销毁了定义一个对象时先调用基类的构造函数、然后调用派生类的构造函数；析构的时候恰好相反：先调用派生类的析构函数、然后调用基类的析构函数JAVA无析构函数深拷贝和浅拷贝

多态：是对于不同对象接收相同消息时产生不同的动作。C++的多态性具体体现在运行和编译两个方面：

/c/ 拥有自己的 体系架构。众所周知.NET 体系不同于COM 体系， 和ADO是两种数据访问方式。ADO.net 提供对XML 的支持。

答案：都是在堆(heap)上进行动态的内存操作。用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。delete 会调用对象的destructor，而free 不会调用对象的destructor.

答案：当类中含有const、reference 成员变量；基类的构造函数都需要初始化表。

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

答案：全局对象的构造函数会在main 函数之前执行。

1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。
2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。
3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。

答案：struct 的成员默认是公有的，而类的成员默认是私有的。struct 和 class 在其他方面是功能相当的。从感情上讲，大多数的开发者感到类和结构有很大的差别。感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位，而类就象活的并且可靠的社会成员，它有智能服务，有牢固的封装屏障和一个良好定义的接口。既然大多数人都这么认为，那么只有在你的类有很少的方法并且有公有数据（这种事情在良好设计的系统中是存在的!）时，你也许应该使用 struct 关键字，否则，你应该使用

答案：如果不是零，请解释一下编译器为什么没有让它为零。（Autodesk）肯定不是零。举个反例，如果是零的话，声明一个class A[10]对象数组，而每一个对象占用的空间是零，这时就没办法区分A[0],A[1]…了。

dynamic_casts在帮助你浏览继承层次上是有限制的。它不能被用于缺乏虚函数的类型上，它被用于安全地沿着类的继承关系向下进行类型转换。如你想在没有继承关系的类型中进行转换，你可能想到static_cast

在类层次间进行上行转换时，dynamic_cast和的效果是一样的；

在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。

　 在上面的代码段中，如果pb指向一个D类型的对象，pd1和pd2是一样的，并且对这两个指针执行D类型的任何操作都是安全的；

 　但是，如果pb指向的是一个B类型的对象，那么pd1将是一个指向该对象的指针，对它进行D类型的操作将是不安全的（如访问m_szName），而pd2将是一个空指针。

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

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

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

规则：即派生类对于基类的同名函数，只要不是覆盖，就一定是隐藏。

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

C++语言支持函数重载，C语言不支持函数重载。C++提供了C连接交换指定符号extern “C”

 全局变量的生命周期是整个程序运行的时间，而局部变量的生命周期则是局部函数或过程调用的时间段。其实现是由编译器在编译时采用不同内存分配方法。全局变量在main函数调用后，就开始分配，如果是静态变量则是在main函数前就已经初始化了。而局部变量则是在用户栈中动态分配的（还是建议看编译原理中的活动记录这一块）

4．如何定义和实现一个类的成员函数为回调函数？
5．解释堆和栈的区别。

答 、1.限制变量的作用域(文件级的)。

 2.设置变量的存储域(全局数据区)。

答 、1) 引用必须被初始化，指针不必。

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

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

答 、全局变量储存在静态数据区，局部变量在堆栈中。

答 、1.没有回收垃圾资源

答、能，局部会屏蔽全局。要用全局变量，需要使用"::"

局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内

答 、可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个变写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错

答 、可以，在不同的C文件中以static形式来声明同名全局变量。

可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错

static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？

答 、全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用， 因此可以避免在其它源文件中引起错误。

从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围。

static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件

static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;

static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；

static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

程序的局部变量存在于（堆栈）中，全局变量存在于（静态区 ）中，动态申请数据存在于（ 堆）中。

功 能: 把字符串转换成长整型数

如果你不知道答案，请看参考文献1。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去找出象这种

问题的答案。当然如果你不是在找一个书呆子，那么应试者最好希望自己不要知道答案。

这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：

1). 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

2). 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。

3). 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。

大多数应试者能正确回答第一部分，一部分能正确回答第二部分，同是很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数

据和代码范围的好处和重要性。

我只要一听到被面试者说：“const意味着常数”，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着“只读”就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。）如果应试者能正确回答这个问题，我将问他一个附加的问题：下面的声明都是什么意思？

前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：

1). 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。）

2). 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。

3). 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：

1). 并行设备的硬件寄存器（如：状态寄存器）

3). 多线程应用中被几个任务共享的变量

回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。嵌入式系统程序员经常同硬件、中断、RTOS等等打交道，所用这些都要求volatile变量。不懂得volatile内容将会带来灾难。

假设被面试者正确地回答了这是问题（嗯，怀疑这否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。

1). 一个参数既可以是const还可以是volatile吗？解释为什么。

2). 一个指针可以是volatile 吗？解释为什么。

3). 下面的函数有什么错误：

1). 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

2). 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。

3). 这段代码的有个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：

预编译又称为预处理,是做些代码文本的替换工作。处理#开头的指令,比如拷贝#include包含的文件代码，#define宏定义的替换,条件编译等，就是为编译做的预备工作的阶段，主要处理#开始的预编译指令，预编译指令指示了在程序正式编译前就由编译器进行的操作，可以放在程序中的任何位置。

c编译系统在对程序进行通常的编译之前，先进行预处理。c提供的预处理功能主要有以下三种：1）宏定义　2）文件包含　3）条件编译

１、总是使用不经常改动的大型代码体。 
２、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头。

线程是指进程内的一个执行单元,也是进程内的可调度实体.与进程的区别:
(1)地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间;
(2)进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源
(3)线程是处理器调度的基本单位,但进程不是.
(4)二者均可并发执行.

从语法上，在C++中（只讨论C++中）。class和struct做类型定义时只有两点区别：
（一）默认继承权限。如果不明确指定，来自class的继承按照private继承处理，来自struct的继承按照public继承处理；
（二）成员的默认访问权限。class的成员默认是private权限，struct默认是public权限。
除了这两点，class和struct基本就是一个东西。语法上没有任何其它区别。

不能因为学过C就总觉得连C++中struct和class都区别很大，下面列举的说明可能比较无聊，因为struct和class本来就是基本一样的东西，无需多说。但这些说明可能有助于澄清一些常见的关于struct和class的错误认识：
（1）都可以有成员函数；包括各类构造函数，析构函数，重载的运算符，友元类，友元结构，友元函数，虚函数，纯虚函数，静态函数；
（3）虽然这种风格不再被提倡，但语法上二者都可以使用大括号的方式初始化：

A a = {1, 2, 3};不管A是个struct还是个class，前提是这个类/结构足够简单，比如所有的成员都是public的，所有的成员都是简单类型，没有显式声明的构造函数。
（4）都可以进行复杂的继承甚至多重继承，一个struct可以继承自一个class，反之亦可；一个struct可以同时继承5个class和5个struct，虽然这样做不太好。
（5）如果说class的设计需要注意OO的原则和风格，那么没任何理由说设计struct就不需要注意。
（6）再次说明，以上所有说法都是指在C++语言中，至于在C里的情况，C里是根本没有“class”，而C的struct从根本上也只是个包装数据的语法机制。

最后，作为语言的两个关键字，除去定义类型时有上述区别之外，另外还有一点点：“class”这个关键字还用于定义模板参数，就像“typename”。但关键字“struct”不用于定义模板参数。

　　class和struct如果定义了构造函数的话，都不能用大括号进行初始化

　　如果没有定义构造函数，struct可以用大括号初始化。

　　如果没有定义构造函数，且所有成员变量全是public的话，可以用大括号初始化。

返回值类型不同构不成重载 
参数参数顺序不同能构成重载

5) 成员函数中 有无const (函数后面) 也可判断是否重载

答：调用一个DLL中的函数有两种方法：
1．载入时动态链接（load-time dynamic linking），模块非常明确调用某个导出函数，使得他们就像本地函数一样。这需要链接时链接那些函数所在DLL的导入库，导入库向系统提供了载入DLL时所需的信息及DLL函数定位。
2．运行时动态链接（run-time dynamic linking），运行时可以通过LoadLibrary或LoadLibraryEx函数载入DLL。DLL载入后，模块可以通过调用GetProcAddress获取DLL函数的出口地址，然后就可以通过返回的函数指针调用DLL函数了。如此即可避免导入库文件了。

    运算符是语言自身的特性，有固定的语义，编译器知道意味着什么，由编译器解释语义，生成相应的代码。

    库函数是依赖于库的，一定程度上独立于语言的。编译器不关心库函数的作用，只保证编译，调用函数参数和返回值符合语法，生成call函数的代码。

     实际中，一些高级点的编译器，都会对库函数进行特别处理。

      malloc/free是库函数，new/delete是C++运算符。对于非内部数据类型而言，光用malloc/free无法满足动态对象都要求。new/delete是运算符，编译器保证调用构造和析构函数对对象进行初始化/析构。但是库函数malloc/free是库函数，不会执行构造/析构。

3 子类析构时，要调用父类的析构函数吗？

      析构函数调用的次序时先派生类后基类的。和构造函数的执行顺序相反。并且析构函数要是virtual的，否则如果用父类的指针指向子类对象的时候，析构函数静态绑定，不会调用子类的析构。

4 多态， 虚函数， 纯虚函数

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

　    抽象类：定义了纯虚函数的类是抽象类，不能实例化。
        抽象类可以派生自一个抽象类，可以覆盖基类的抽象方法也可以不覆盖。

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

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

（1）与指针调用效果一样。 
（2）引用传参，内存中并没有产生副本。
（3）用指针传递，也要给形参分配存储单元；并且需要使用"*变量的"的形式，可读性差；另外，调用的地方还得用地址作为实参。

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

       重载：多个同名函数，参数不同（个数不同，参数类型不同）；是同一层级的函数；静态绑定；编译期绑定。

15　内存分配方式和区别

　　（１）静态存储区：在编译时就分配好，在整个运行期间都存在。比如全局变量，static变量。

　　（２）常量区：　存放常量的，比如字符串常量。

１６　BOOL，int，float，指针类型，于”零“的比较语句。

18 数组和指针的区别

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

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

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

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

堆：有内存碎片的问题。一定的算法去找合适的内存。效率低。OS有记录空闲内存地址的链表

栈：专门的寄存器存放栈地址。效率高。有大小限制。

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

全局/静态存储区：全局变量，静态变量。

常量存储区：放常量，不允许修改。

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

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

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

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

　　　　修饰类成员变量，成员不可以改。

　　static修饰成员函数，类只有一份，不含this指针。

31 类的static变量在什么时候初始化，函数的static变量什么时候初始化？
         类的静态成员在类实例化之前就存在了； 函数的static变量在执行此函数时进行实例化（第一次调用的时候，只初始化一次）

　　栈大小有限制：分过多的数组； 

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

36 C++函数传参数方式

　　值传递、指针、引用

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

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

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

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

　　标准输入流：stdin

　　标准错误输出流：stderr

42 内存泄漏？ 指针越界和内存泄漏，有哪些方法？
　　对指针赋值的时候，一定要看原来指向的东西是否需要释放
　　指针指向的东西释放后，一定要将指针设置为null。

　　TCP： 面向连接， 有保障， 效率低， 基于流的，重要数据
　　udp:    无连接 无保障 效率高 基于数据报文 不重要的数据

　　sizeof计算的是栈中分配的内存大小
　　A: 类中static的变量，计算static的时候不算在内
　　B: 指针大小是4个字节。
　　     string = 4, 空类=1（对象在内存中都有独一无二的地址，空类会隐含的加一个字节）)， 单一继承的空类占一个字节；虚继承涉及的虚指针占4个字节
　　D:数组： 如果指定数组长度，则总字节数=数组长度 * sizeof（元素类型）,如果没有指定长度，则按照实际元素个数；如果是字符数组，则应考虑末尾空字符。
　　F:对函数取sizeof，在编译阶段会被函数返回值的类型代替。
　　G:sizeof不能返回动态数组的大小。

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

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

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

43 共有继承 受保护继承 私有继承
　　共有继承：可以访问基类中的公有成员，派生类可以访问公有的和受保护的成员；

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

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

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

　　虚函数表是在编译时就建立了，各个虚拟函数这时被组织成了一个虚函数的入口地址的数组。
　　而对象的隐藏成员--虚函数表指针是在运行期-也就是构造函数被调用时进行初始化的，这是实现多态的的关键。、

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

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

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

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

　    　c++的结构体和class几乎一样。结构体可以继承，可以有函数，可以实现多态。

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

　　A：包含全部的C语言部分。
　　B：面向对象部分，封装，继承，多态。
　　C：泛型编程部分，模板，方便使用。

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

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

59 宏，内联函数，函数 区别：

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

 且在这个块的首地址处记录分配的大小，以便delete语句正确执行，并且，堆的大小如果大于申请的大小，多余的部分还会记录到空闲链表。
　　申请大小限制：栈的大小有限制； 堆的话比较大。
　　效率：栈快， 自动的； 堆慢，容易产生内存碎片。
　　存储的内容：在函数调用时，先入栈的是函数调用的下一条语句的地址，然后从左到右函数入栈，然后是局部变量
　　　　　　　　静态局部变量不入栈； 堆的头部用一个字节大小存堆的大小。堆中的具体内容程序员安排。

　　传递给函数的数据在函数中不被改变

　　代码模块化，扩展代码模块，实现代码重用。

　　隐藏：派生类的函数屏蔽了同名的基类函数：
　　派生类函数与基类函数同名，参数不同，无论有无virtual关键字，基类函数被隐藏（不是重载）
　　派生类函数与基类函数同名，参数相同，基类无virtual， 基类被隐藏。

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

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

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

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

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

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

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

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

　　　　　　　　　　　　　时候会找到这个变量的物理地址。

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

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

　　因为C++ 重载，而C不重载，函数名编译的结果都不一样。 
　　如果C++ 直接调用C的函数，因为二者编译的不同，就会失败。

　　　　　　　　当C++ 包含这个.h文件的时候就要用extern "C"， 否则编译器编译的不一样，根本调用不到。
　　　　　　　　c++ 调用一个C语言编写的DLL时，当包括.DLL的头文件或声明接口函数时，应加入extern "C"

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

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

　　字节对齐：有助于加快计算机的取数速度，否则就得多花指令周期了。宽度为2的基本数据类型都位于能被2整除的地址上，
　　　　　　　 4的位于能被4整除的地址上。

　　pack影响的的是偏移量。

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

　　对于联合体： int从首地址开始占据4个自己； char从首地址开始占据2个字节，有重合。

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

　　隐式类型转换：int 类型 和float类型相加，会转成float
　　　　　　　　　 用于类层次结构中，基类和子类之间指针和引用的转换；
　　　　　　　　　 当进行上行转换，也就是把子类的指针或引用转换成父类表示，这种转换是安全的；
　　　　　　　　　 当进行下行转换，也就是把父类的指针或引用转换成子类表示，这种转换是不安全的，也需要程序员来保证；
　　　　　　　　　 基本数据类型之间的转换，如把int转换成char，把int转换成enum等等，这种转换的安全性需要程序员来保证；
　　　　　　　　　  把void指针转换成目标类型的指针，是极其不安全的；

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

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

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

　　注意： 如果没有虚函数，那么就没有这个虚函数表的指针。虚函数表的指针（占4字节大小）影响sizeof的结果。

　　v-Table: 虚函数的地址表。在有虚函数的类实例中，这个表被分配在了这个实例的内存中，当用父类型指针操作
　　　　　　一个子类的时候，这张虚函数表像一个地图一样，指明了实际调用的函数。
　   C++ 编译器保证：虚函数表的指针存在于对象实例中最前面的位置。

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

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

　　一般继承（有虚函数覆盖）：
　　总结：子类的覆盖的函数放在原来虚函数的位置。

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

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

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

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

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

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

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

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

　　E是一个空表，其长度为0。
　　L是长度为2的广义表，它的两个元素都是原子，因此它是一个线性表
　　A是长度为2的广义表，第一个元素是原子x，第二个元素是子表L。

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

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

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

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

　　A 管理方式： 栈：编译器管理； 堆：程序释放，容易泄露。
　　B 空间大小： 栈：默认是1M， 堆：可以看做没有限制。 
　　C 是否产生碎片：栈：没有碎片。 堆：产生碎片。
　　D 生长方向：栈：向内存地址减小的方向； 堆： 地址增大的方向。
　　E 分配方式： 栈：有静态分配 堆：都是动态分配的。
　　F 分配效率： 栈：寄存器存了栈的地址，压栈/出栈有专门的指令，栈的效率很高。 
　　　　　　　　堆：分配、管理内存的算法复杂，空闲链块查找，合并，用了后，要更新
　　　　空闲链块的记录。效率低。 如果碎片太多，可能还要像OS申请更多内存。