c++面试题（3）

1.c++编译

源程序－>预处理－>编译和优化->生成目标文件－>链接－>可执行文件

1.预处理

1.宏的替换

2.删除注释

3.处理预处理指令，如#include，#ifdef

2.编译和优化

词法分析 -- 识别单词,确认词类;比如int i;知道int是一个类型，i是一个关键字以及判断i的名字是否合法

语法分析 -- 识别短语和句型的语法属性；

语义分析 -- 确认单词、短语和句型的语义特征；

代码优化 -- 修辞、文本编辑；

代码生成 -- 生成译文。

3.生成目标文件

4.链接

1.gcc -E hello.c -o hello.i（预处理） 
2.gcc -S hello.i -o hello.s（编译） 
3.gcc -c hello.s -o hello.o（汇编） 
4.gcc hello.o -o hello（链接） 
以上四个步骤，可合成一个步骤 
gcc hello.c -o hello（直接编译链接成可执行目标文件） 

gcc -c hello.c或gcc -c hello.c -o hello.o（编译生成可重定位目标文件）

C/C++编译器

1.MSVC

MSVC是微软Windows平台Visual Studio自带的C/C++编译器。

优点：对Windows平台支持好，编译快。

缺点：对C++的新标准支持得少。

2.GCC

优点：类Unix下的标准编译器，支持众多语言，支持交叉编译。

缺点：默认不支持Windows，需要第三方移植才可用于Windows。

3.Cygwin

优点：可以比MingW移植更多的软件到Windows上，对Linux接口模拟比MingW全面。

缺点：软件运行依赖cygwin1.dll，速度受点影响。

4.MingW

和GCC的关系：MingW是编译环境，不是编译器，GCC是MingW中的核心组成。

优点：在Win下可以和Linux一样的方式编译C/C++源码，可以说是Win版的GCC，其生产的Windows PE程序相比Cygwin不依赖任何第三方库，比Cygwin纯粹，理论上也更快速。

缺点：编译速度、编译出的程序在算法上可能都比MSVC慢。

2.变量声明和定义的区别

定义和声明的根本区别：是内存。

定义创建对象，并为这个对象分配了内存；而声明只是将与内存关联的对象名进行外域可见性的扩充，看不到，可以继续声明。

声明有2重含义：
（1） 告诉编译器，这个名字已经匹配到一块内存上，下面的代码用到变量或者对象是在别的地方定义的。声明可以出现多次。
（2） 告诉编译器，这个名字已经被预定了，别的地方再也不能用它来作为变量名或对象名。
定义和声明的最重要区别就是：

定义创建对象并为这个对象分配了内存，声明没有分配内存。

3.内存对齐

1、平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。 
2、性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。 

对齐规则 
每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。 

4.c++内存布局

https://blog.csdn.net/book_zhouqingjun216/article/details/52425582

5.C++内存分配

在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。

 

　　栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。

　　堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。

　　自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。

　　全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。

　　常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多。

6.栈和堆

    管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。

 

　　空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。当然，我们可以修改：

 

　　打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。

 

　　注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。

 

　　碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以参考数据结构，这里我们就不再一一讨论了。

 

　　生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。

 

　　分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。

 

　　分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。

 

　　从这里我们可以看到，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。

7.初始化成员列表

成员初始化列表使用初始化的方式来为数据成员指定初值，而构造函数的函数体是通过赋值的方式来给数据成员指定初值。

功能上面的区别

1. 初始化一个引用成员变量
2. 初始化一个const变量
3. 当我们在初始化一个子类对象的时候，而这个子类对象的父类有一个显示的带有参数的构造函数
4. 当调用一个类类型成员的构造函数，而它拥有一组参数的时候

在这四种情况下是必须要使用成员初始化列表来为这些类型的成员赋初值的。因为这些成员都必须用初始化的方式赋初值。比如引用和const成员变量，这些都是不接受定义之后的赋值的。而对于3的话，是因为子类对象包括父类对象，父类对象既然明确指定了带参的构造函数，那么就必须在构造子类对象的父类部分时显示调用这个构造函数，是不能依赖于合成的默认构造函数的，而这样的话，就必须在成员初始化列表中调用。4也一样，类类型的成员所在类如果有显示定义的构造函数那么也是需要在定义这个成员的同时需要显示调用的。

如果一个类中有这些类型成员的话，是必须要使用成员初始化列表的。

性能方面区别

初始化列表少用

• 一次默认构造函数的调用
• 一个临时对象temp的创建
• 一次拷贝赋值运算符函数的调用
• 一次析构函数的调用

初始化列表性能更高

成员初始化列表的初始化顺序是按照类成员的声明顺序来的，所以在初始化的时候，尽量不要用次序较后的成员来初始化次序较前的成员，这样就会出问题，这也是成员初始化列表的一个弊端。

8.内存泄露、内存溢出

指由于疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏原因

1. 在类的构造函数和析构函数中没有匹配的调用new和delete函数

2. 没有正确地清除嵌套的对象指针

3. 在释放对象数组时在delete中没有使用方括号

4. 指向对象的指针数组不等同于对象数组

5. 缺少拷贝构造函数

6. 缺少重载赋值运算符

7. 关于nonmodifying运算符重载的常见迷思

8. 没有将基类的析构函数定义为虚函数

野指针：指向被释放的或者访问受限内存的指针。

造成野指针的原因：

1. 指针变量没有被初始化（如果值不定，可以初始化为NULL）
2. 指针被free或者delete后，没有置为NULL, free和delete只是把指针所指向的内存给释放掉，并没有把指针本身干掉，此时指针指向的是“垃圾”内存。释放后的指针应该被置为NULL.
3. 指针操作超越了变量的作用范围，比如返回指向栈内存的指针就是野指针。

由内存泄露引出内存溢出话题：

所谓内存溢出就是你要求分配的内存超出了系统能给你的，系统不能满足需求，于是会产生内存溢出的问题。

常见的溢出主要有：

内存分配未成功，却使用了它。 常用解决办法是，在使用内存之前检查指针是否为NULL。如果指针p 是函数的参数，那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc 或new 来申请内存，应该用if(p==NULL)或if(p!=NULL)进行防错处理。

内存分配虽然成功，但是尚未初始化就引用它。 内存分配成功并且已经初始化，但操作越过了内存的边界。 例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在for 循环语句中，循环次数很容易搞错，导致数组操作越界。

使用free 或delete 释放了内存后，没有将指针设置为NULL。导致产生“野指针”。

9.c++空类

大小为1

默认生成

默认构造函数 
析构函数 
拷贝构造函数 
赋值运算符（operator=） 
取址运算符（operator&）（一对，一个非const的，一个const的） 

class Empty

{

  public:

      Empty(); // 缺省构造函数

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

      ~Empty(); // 析构函数

       Empty& operator=( const Empty& ); // 赋值运算符

       Empty* operator&(); // 取址运算符

       const Empty* operator&() const; // 取址运算符 const

};