C++程序员面试常见题目

---

• 欢迎大家指正问题

---

 1：请用简单的语言告诉我C++ 是什么？

答：C++是在C语言的基础上开发的一种面向对象编程语言，应用广泛。C++支持多种编程范式 －－面向对象编程、泛型编程和过程化编程。 其编程领域众广，常用于系统开发，引擎开发等应用领域，是最受广大程序员受用的最强大编程语言之一,支持类：类、封装、重载等特性!

2：C和C++的区别？

C++在C的基础上增添类

C是一个结构化语言，它的重点在于算法和数据结构。

C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制），而对于C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。

3: C ++ 在c基础上加了什么？

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

4：什么是面向对象（OOP）？

答：面向对象是一种对现实世界理解和抽象的方法、思想，通过将需求要素转化为对象进行问题处理的一种思想。

5：解释下封装、继承和多态？（面向对象的三个特征）

一、封装：

封装是实现面向对象程序设计的第一步，封装就是将数据或函数等集合在一个个的单元中（我们称之为类）。也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

封装的意义在于保护或者防止代码（数据）被我们无意中破坏。

二、继承：

继承主要实现重用代码，节省开发时间。

子类可以继承父类的一些东西。

继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展. 通过继承创建的新类称为“子类”或“派生类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”和“组合”来实现。

三、多态

多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。

多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态在C++中是通过虚函数实现的。

实现多态，有二种方式，覆盖，重载。

覆盖，是指子类重新定义父类的虚函数的做法。
重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

总结：作用

① 封装可以隐藏实现细节，使得代码模块化
② 继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用
③ 多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

6 多态作用

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

7. 简述多态的实现原理

编译器发现一个类中有虚函数，便会立即为此类生成虚函数表vtable。虚函数表的各表项为指向对应虚函数的指针。编译器还会在此类中隐含插入一个指针 vptr指向虚函数表。调用此类的构造函数时，在类的构造函数中，编译器会隐含执行 vptr 与 vtable 的关联代码，将 vptr 指向对应的 vtable，将类与此类的 vtable 联系了起来。另外在调用类的构造函数时，指向基础类的指针此时已经变成指向具体的类的 this 指针，这样依靠此 this 指针即可得到正确的 vtable。

如此才能真正与函数体进行连接，这就是动态联编，实现多态的基本原理。

注意：一定要区分虚函数，纯虚函数、虚拟继承的关系和区别。牢记虚函数实现原理，因为多态C++面试的重要考点之一，而虚函数是实现多态的基础。

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

引用的特性：

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

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

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

引用的作用：

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

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

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

指针调用的时候，其实也会形参分配存储单元，且需要用“指针变量名”的形式运算，容易产生错误并且可读性差；调用的时候，需要用变量的地址作为实参，调用形式不好看。引用没有这些问题。

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

但是，引用作为返回值注意事项：

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

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

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

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

总结：

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

9：引用和多态的区别

引用和指针可以实现多态。（说各自的含义）

10：指针和引用的区别？

1. 指针是一个变量，只不过这个变量存储的是一个地址，指向内存的一个存储单元；而引用仅是个别名；

2. 引用使用时无需解引用(*)，指针需要解引用；

3. 引用只能在定义时被初始化一次，之后不可变；指针可变；

4. 引用没有 const，指针有 const；

5. 引用不能为空NULL，指针可以为空；

6. “sizeof 引用”得到的是所指向的变量(对象)的大小，而“sizeof 指针”得到的是指针本身的大小；

7. 指针和引用的自增(++)运算意义不一样；

8. 指针可以有多级，但是引用只能是一级（int **p；合法 而 int &&a是不合法的）

9.从内存分配上看：程序为指针变量分配内存区域，而引用不需要分配内存区域。

10：引用使用在源代码级相当于普通的变量一样使用，做函数参数时，内部传递的实际是变量地址

 

① 引用必须被初始化，但是不分配存储空间。指针不必在声明时初始化，在初始化的时候需要分配存储空间
② 引用初始化以后不能被改变，指针可以改变所指的对象
③ 不存在指向空值的引用，但是存在指向空值的指针

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

（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。

（3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。

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

如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。

常引用声明方式：const类型标识符&引用名=目标变量名；

例1

int a;

const int &ra = a;

ra = 1; //错误

a = 1; //正确

例2

string foo();

void bar(string & s);

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

bar(foo());

bar("hello world");

原因在于foo( )和"hello world"串都会产生一个临时对象，而在C++中，这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型，这是非法的。引用型参数应该在能被定义为const的情况下，尽量定义为const。

 

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

void bar(String &ra)

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

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

13 常引用的作用

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

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

int &fun(int a) {}

好处：不会生成副本。

规则：不能返回局部变量的引用；不能返回函数内部new分配的内存引用； 如果返回成员的话，返回const

 

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

好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtime error!

注意事项：

（1）不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。

（2）不能返回函数内部new分配的内存的引用。这条可以参照Effective C++[1]的Item 31。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。

（3）可以返回类成员的引用，但最好是const这条原则可以参照EffectiveC++[1]的Item 30       主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。

（4）流操作符重载返回值申明为“引用”的作用：

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

赋值操作符=。这个操作符象流操作符一样，是可以连续使用的，例如：x=j=10;或者(x=10)=100;赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。

＃include

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)

{

    if (n >= 0 && n <= 9) return vals[n];

    else { cout << "subscript error"; return error; }

}

（5）在另外的一些操作符中，却千万不能返回引用：+-*/ 四则运算符。它们不能返回引用，Effective C++[1]的Item23详细的讨论了这个问题。主要原因是这四个操作符没有side effect，因此，它们必须构造一个对象作为返回值，可选的方案包括：返回一个对象、返回一个局部变量的引用，返回一个new分配的对象的引用、返回一个静态对象引用。根据前面提到的引用作为返回值的三个规则，第2、3两个方案都被否决了。静态对象的引用又因为((a+b) == (c+d))会永远为true而导致错误。所以可选的只剩下返回一个对象了。

15. 继承方式

public    父类的访问级别不变

protected    父类的public成员在派生类编程protected，其余的不变

private        父类的所有成员变成private

16 多重继承的二义性

多个父类中有相同名称的变量或者函数。子类中要指明是哪个父类的。
子类中同名的函数会覆盖父类的。

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

17 菱形继承

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

18. 简述C\C++程序编译的内存情况分配

C、C++中内存分配方式可以分为三种：

（1）从静态存储区域分配：内存在程序编译时就已经分配好，这块内存在程序的整个运行期间都存在。速度快、不容易出错，因为有系统会善后。例如全局变量，static变量等。
（2）在栈上分配：在执行函数时，函数内局部变量的存储单元都在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
（3）从堆上分配：即动态内存分配。程序在运行的时候用 malloc 或 new 申请任意大小的内存，程序员自己负责在何时用 free 或 delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活。如果在堆上分配了空间，就有责任回收它，否则运行的程序会出现内存泄漏，另外频繁地分配和释放不同大小的堆空间将会产生堆内碎块。

一个 C、C++程序编译时内存分为 5 大存储区：堆区、栈区、全局区、文字常量区、程序代码区。

19内存分配方式

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

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

自由存储区：用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" 优化成一个地方。

}

20：堆和栈的区别？堆和栈的生命周期？

一、堆栈空间分配区别：

1、栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈；

2、堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。

二、堆栈缓存方式区别：

1、栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放；

2、堆是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。

三、堆栈数据结构区别：

堆（数据结构）：堆可以被看成是一棵树，如：堆排序；

栈（数据结构）：一种先进后出的数据结构。

堆和栈的区别：

一个由c/C++编译的程序占用的内存分为以下几个部分 

1、栈区（stack）   由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 

2、堆区（heap）   一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。

注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。 

3、全局区（静态区）（static），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 

4、文字常量区  ―常量字符串就是放在这里的。 程序结束后由系统释放 

5、程序代码区―存放函数体的二进制代码

对内存的了解

1.栈 - 由编译器自动分配释放

2.堆 - 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收

3.全局区(静态区)，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。- 程序结束释放

4.另外还有一个专门放常量的地方。- 程序结束释放

5 程序代码区，存放2进制代码。

在函数体中定义的变量通常是在栈上，用malloc， calloc， realloc等分配内存的函数分配得到的就是在堆上。在所有函数体外定义的是全局量，加了static修饰符后不管在哪里都存放在全局区(静态区)，在所有函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用，在函数体内定义的static表示只在该函数体内有效。另外，函数中的"adgfdf"这样的字符串存放在常量区。

21 函数参数入栈的顺序？

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

22：栈内存与文字常量区

char str1[] = "abc";

char str2[] = "abc";

const char str3[] = "abc";

const char str4[] = "abc";

const char *str5 = "abc";

const char *str6 = "abc";

char *str7 = "abc";

char *str8 = "abc";

cout << (str1 == str2) << endl;//0  分别指向各自的栈内存

cout << (str3 == str4) << endl;//0  分别指向各自的栈内存

cout << (str5 == str6) << endl;//1指向文字常量区地址相同

cout << (str7 == str8) << endl;//1指向文字常量区地址相同

结果是：0 0 1 1

解答：str1,str2,str3,str4是数组变量，它们有各自的内存空间；而str5,str6,str7,str8是指针，它们指向相同的常量区域。

23：什么是内存泄漏？面对内存泄漏和指针越界，你有哪些方法？你通常采用哪些方法来避免和减少这类错误？

答：用动态存储分配函数动态开辟的空间，在使用完毕后未释放，结果导致一直占据该内存单元即为内存泄露。

使用的时候要记得指针的长度。

malloc的时候得确定在那里free.

对指针赋值的时候应该注意被赋值指针需要不需要释放.

动态分配内存的指针最好不要再次赋值.

24 内存泄漏？ 指针越界和内存泄漏，有哪些方法？

new/delete, new[]/delete, malloc/free 配套使用
对指针赋值的时候，一定要看原来指向的东西是否需要释放
指针指向的东西释放后，一定要将指针设置为null。

25 栈溢出的原因：

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

26. C++中有了malloc / free , 为什么还需要 new / delete

1、malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。

2、对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。

3、由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。

4、C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。

5、new可以认为是malloc加构造函数的执行。new出来的指针是直接带类型信息的。而malloc返回的都是void指针。

27. 在c++程序中调用被C编译器编译后的函数，为什么要加extern“C”

C++语言支持函数重载，C语言不支持函数重载，函数被C++编译器编译后在库中的名字与C语言的不同，

假设某个函数原型为：

1. void  foo(int x, int y);

该函数被C编译器编译后在库中的名字为:  _foo

而C++编译器则会产生像: _foo_int_int  之类的名字。为了解决此类名字匹配的问题，C++提供了C链接交换指定符号 extern "C"。

28. extern 有什么作用

extern 标识的变量或者函数声明其定义在别的文件中，提示编译器遇到此变量和函数时在其它模块中寻找其定义。

29. 头文件种的ifndef/define/endif 是干什么用的

防止头文件被重复包含

30. C库函数实现

31、C++中空类默认产生哪些类成员函数？

对于一个空类，编译器默认产生4个成员函数：

（1）默认构造函数

（2）析构函数

（3）拷贝构造函数

（4）赋值函数

32. c++空类的成员函数

缺省的构造函数
缺省的拷贝构造函数
缺省的赋值运算符
缺省的析构函数
缺省的取址运算符
缺省的取址运算符const

注意：只有当实际使用这些函数的时候，编译器才会去定义它们。

33、析构函数可以为 virtual 型，构造函数则不能，为什么？

虚函数采用一种虚调用的办法。虚调用是一种可以在只有部分信息的情况下工作的机制，特别允许我们调用一个只知道接口而不知道其准确对象类型的函数。但是如果要创建一个对象，你势必要知道对象的准确类型，因此构造函数不能为 virtual。

34、如果虚函数是非常有效的，我们是否可以把每个函数都声明为虚函数？

不行，这是因为虚函数是有代价的：由于每个虚函数的对象都必须维护一个 v 表，因此在使用虚函数的时候会产生一个系统开销。如果仅是一个很小的类，且不行派生其他类，那么根本没必要使用虚函数。

 

35 什么时候要用虚析构函数

通过基类的指针来删除派生类的对象时，基类的析构函数应该是虚的。否则其删除效果将无法实现。

一般情况下，这样的删除只能够删除基类对象，而不能删除子类对象，形成了删除一半形象，从而千万内存泄漏。

原因：

在公有继承中，基类对派生类及其对象的操作，只能影响到那些从基类继承下来的成员。

如果想要用基类对非继承成员进行操作，则要把基类的这个操作（函数）定义为虚函数。

那么，析构函数自然也应该如此：如果它想析构子类中的重新定义或新的成员及对象，当然也应该声明为虚的。

注意：

如果不需要基类对派生类及对象进行操作，则不能定义虚函数（包括虚析构函数），因为这样会增加内存开销。

36. c++怎样让返回对象的函数不调用拷贝构造函数

拷贝构造函数前加 “explicit” 关键字

37.子类析构时要调用父类的析构函数吗？

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

38.多态，虚函数，纯虚函数

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

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

虚函数：在基类中冠以关键字virtual的成员函数。它提供了一种接口界面。允许在派生类中对基类的虚函数重新定义。虚函数为了重载和多态，在基类中是有定义的，即便定义为空。在子类中可以重写。多态的基础是继承，需要虚函数的支持

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

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

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

39：基类的析构函数不是虚函数，会带来什么问题？

派生类的析构函数用不上，会造成资源的泄漏。

40 程序在结束的时候，系统会自动析构所有的全局变量。

事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样

41子类不能继承父类的函数

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

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

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

43 多态类中虚函数表是compilie-Time 还是 Run-time时建立的

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

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

可以； 子类可写，可不写。

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

答：除了static的，其他的都有。

46 谈谈你对拷贝构造函数和赋值运算符的认识

两个不同之处：

① 拷贝构造函数生成新的类对象，而赋值运算符不能。
② 由于拷贝构造函数是直接构造一个新的类对象，所以在初始化这个对象之前不用检验源对象是否和新建对象相同。而赋值运算符则需要这个操作，另外赋值运算中如果原来的对象中有内存分配要先把内存释放掉。

注意：当有类中有指针类型的成员变量时，一定要重写拷贝构造函数和赋值运算符，不要使用默认的。

47. 类成员的重写、重载和隐藏的区别

重写和重载主要有以下几点不同

① 范围的区别：被重写的和重写的函数在两个类中，而重载和被重载的函数在同一个类中。
② 参数的区别：被重写函数和重写函数的参数列表一定相同，而被重载函数和重载函数的参数列表一定不同。
③ virtual 的区别：重写的基类中被重写的函数必须要有 virtual 修饰，而重载函数和被重载函数可以被virtual 修饰，也可以没有。

隐藏和重写、重载有以下几点不同

① 与重载的范围不同：和重写一样，隐藏函数和被隐藏函数不在同一个类中
② 参数的区别：隐藏函数和被隐藏的函数的参数列表可以相同，也可不同，但是函数名肯定要相同。当参数不相同时，无论基类中的参数是否被 virtual 修饰，基类的函数都是被隐藏，而不是被重写

说明：虽然重载和覆盖都是实现多态的基础，但是两者实现的技术完全不相同，达到的目的也是完全不同的，覆盖是动态绑定的多态，而重载是静态绑定的多态。

48：const知道吗？解释其作用。

1.const 修饰类的成员变量，表示成员常量，不能被修改。修饰类成员变量，成员不可以改。

2.const修饰函数承诺在本函数内部不会修改类内的数据成员，不会调用其它非 const 成员函数。修饰函数参数；

3.如果 const 构成函数重载，const 对象只能调用 const 函数，非 const 对象优先调用非 const 函数。

4.const 函数只能调用 const 函数。非 const 函数可以调用 const 函数。

5.类体外定义的 const 成员函数，在定义和声明处都需要 const 修饰符。

主要有三点：

1：定义只读变量，即常量 

2：修饰函数的参数和函数的返回值 

3： 修饰函数的定义体，这里的函数为类的成员函数，被const修饰的成员函数代表不修改成员变量的值

49 const用法

const常量：定义的时候必须初始化。const int a 和 int const a 是一个意思。
const指针： 常量指针 和 指针常量
int a;
const int *p = &a; 常量指针，不能通P改变所值对象的值。但是可以其他方式修改。并且指针
还可以指向其他的int变量。const int *p 和 int const *p一样。
int * const p = &i; 指针常量，p中存放的地址不可以变化，可以通过P改变变量的值，但是指针不能
再指向其他的变量。
注意const int *p 和 int const *p一样
const引用： 可以绑定常量，也可以绑定变量。不能通过这个const引用来改变绑定对象的值。但是变量本身可以改。
非const 引用不能与const 对象绑定；但是const 引用可以绑定非const 变量。

50.请说出const与#define相比，有何优点？

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

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

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

51: 函数的const参数构成重载函数

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

52 C中static有什么作用

① 隐藏。当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性，故使用static在不同的文件中定义同名函数和同名变量，而不必担心命名冲突。
② 保持变量内容的持久。存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和static变量。
③ 默认初始化为0.其实全局变量也具备这一属性，因为全局变量也存储在静态数据区。在静态数据区，内存中所有的字节默认值都是0×00,某些时候这一特点可以减少程序员的工作量。

53：类的static变量在什么时候初始化？函数的static变量在什么时候初始化？

答：类的静态成员变量在类实例化之前就已经存在了，并且分配了内存。函数的static变量在执行此函数时进行初始化。

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

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

关键字static的作用：

1、函数体内 static 变量的作用范围为该函数体，不同于 auto 变量， 该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值

2、在模块内的 static 全局变量可以被模块内所有函数访问，但不能被模块外其他函数访问

3、在模块内的static 函数只可被这一模块内的其他函数调用，这个函数的使用范围被限制在声明它的模块内

4、 在类的static 成员变量属于整个类所拥有，对类的所以对象只有一份拷贝

5、 在类中的 static 成员函数属于整个类所拥有，这个函数不接收 this 指针，因而只能访问类的 static 成员变量

介绍它最重要的一条：隐藏。（static函数，static变量均可） --> 对应上面的2、3项      当同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。
static：
  局部static变量：局部静态变量，处于内存中的静态存储区；只能初始化一次；作用域是局部。
  全局static变量：全局静态变量，静态存储区；全局静态变量的作用局是声明它的文件，在文件之外是不可见的。其实是从
  定义的地方到文件结尾。
  类的static成员：类的全局变量，被类的所有独享共享，包括派生类的对象。按照这种方式int base::var = 10;进行初始化，不能在构造函数内初始化，但是可以用const修饰的static数据成员在类内初始化。

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

54 static 文件作用域的问题

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

55. c/c++中static

要理解static，就必须要先理解另一个与之相对的关键字auto，其实我们通常声明的不用static修饰的变量，都是auto的，因为它是默认的。auto的含义是由程序自动控制变量的生存周期，通常指的就是变量在进入其作用域的时候被分配，离开其作用域的时候被释放；而static就是不auto，变量在程序初始化时被分配，直到程序退出前才被释放；也就是static是按照程序的生命周期来分配释放变量的，而不是变量自己的生命周期；所以，像这样的例子：

1 2 3 4 5

void func() { int a;   static int b; }

每一次调用该函数，变量a都是新的，因为它是在进入函数体的时候被分配，退出函数体的时候被释放，所以多个线程调用该函数，都会拥有各自独立的变量a，因为它总是要被重新分配的；而变量b不管你是否使用该函数，在程序初始化时就被分配的了，或者在第一次执行到它的声明的时候分配（不同的编译器可能不同），所以多个线程调用该函数的时候，总是访问同一个变量b，这也是在多线程编程中必须注意的！

static的全部用法：

1．类的静态成员：

1 2 3 4 5

class A {   private:     static int s_value; };

在cpp中必须对它进行初始化：

1	int A::s_value = 0; // 注意，这里没有static的修饰！

类的静态成员是该类所有实例的共用成员，也就是在该类的范畴内是个全局变量，也可以理解为是一个名为A::s_value的全局变量，只不过它是带有类安全属性的；道理很简单，因为它是在程序初始化的时候分配的，所以只分配一次，所以就是共用的；

类的静态成员必须初始化，道理也是一样的，因为它是在程序初始化的时候分配的，所以必须有初始化，类中只是声明，在cpp中才是初始化，可以在初始化的代码上放个断点，在程序执行main的第一条语句之前就会先走到那；如果你的静态成员是个类，那么就会调用到它的构造函数；

2．类的静态函数：

1 2 3 4 5

class A {   private:   static void func(int value); };

实现的时候也不需要static的修饰，因为static是声明性关键字；类的静态函数是在该类的范畴内的全局函数，不能访问类的私有成员，只能访问类的静态成员，不需要类的实例即可调用；实际上，它就是增加了类的访问权限的全局函数：void A::fun(int);

静态成员函数可以继承和覆盖,但无法是虚函数；

3．只在cpp内有效的全局变量：

在cpp文件的全局范围内声明：

1	static int g_value = 0;

这个变量的含义是在该cpp内有效，但是其他的cpp文件不能访问这个变量；如果有两个cpp文件声明了同名的全局静态变量，那么他们实际上是独立的两个变量；

如果不使用static声明全局变量：

1	int g_value = 0;

那么将无法保证这个变量不被别的cpp共享，也无法保证一定能被别的cpp共享，因为要让多个cpp共享一个全局变量，应将它声明为extern（外部）的；也有可能编译会报告变量被重复定义；总之不建议这样的写法，不明确这个全局变量的用法；

如果在一个头文件中声明：

1	static int g_vaule = 0;

那么会为每个包含该头文件的cpp都创建一个全局变量，但他们都是独立的；所以也不建议这样的写法，一样不明确需要怎样使用这个变量，因为只是创建了一组同名而不同作用域的变量；

这里顺便说一下如何声明所有cpp可共享的全局变量，在头文件里声明为extern的：

1	extern int g_value; // 注意，不要初始化值！

然后在其中任何一个包含该头文件的cpp中初始化（一次）就好：

1	int g_value = 0; // 初始化一样不要extern修饰，因为extern也是声明性关键字；

然后所有包含该头文件的cpp文件都可以用g_value这个名字访问相同的一个变量；

56：解释C++中静态函数和静态变量？

 (1)类静态数据成员在编译时创建并初始化：在该类的任何对象建立之前就存在，不属于任何对象，而非静态类成员变量则是属于对象所有的。类静态数据成员只有一个拷贝，为所有此类的对象所共享。

(2)类静态成员函数属于整个类，不属于某个对象，由该类所有对象共享。

1、static 成员变量实现了同类对象间信息共享。

2、static 成员类外存储，求类大小，并不包含在内。

3、static 成员是命名空间属于类的全局变量，存储在 data 区的rw段。

4、static 成员只能类外初始化。

5、可以通过类名访问（无对象生成时亦可），也可以通过对象访问。

1、静态成员函数的意义，不在于信息共享，数据沟通，而在于管理静态数据成员，完成对静态数据成员的封装。

2、静态成员函数只能访问静态数据成员。原因：非静态成员函数，在调用时 this指针时被当作参数传进。而静态成员函数属于类，而不属于对象，没有 this 指针。

57、哪一种成员变量可以在同一类的实例间共享？

必须使用静态成员变量在一个类的所有实例间共享数据。如果想限制对静态成员变量的访问，必须把它们声明为保护型或私有型。不允许用静态成员去存放某一个对象的数据。静态成员函数是在这个类的所有对象间共享的。如果静态成员数据设为私有的，可以通过共有静态和产能原函数访问。

58、重载与覆盖有什么不同？

虚函数总是在派生类中被改写，这种改写被称为“override”（覆盖）。

override 是指派生类重写基类的虚函数，重写的函数必须有一致的参数表和返回值。Override这个单词好像一直没什么合适的中文词汇来对应。有些人译为“覆盖”，还贴切一些。

overload约定成俗地被翻译为“重载”，是指编写一个与自己已有函数同名但是参数表不同的函数。例如一个函数既可以接受整型数作为参数，也可以接收浮点数作为参数。重载不是一种面向对象的编程，而是一种语法规则，重载与多态没什么直接关系。

1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系。
2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。
3、覆盖要求参数列表相同；重载要求参数列表不同。
4、覆盖关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。

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

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

重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

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

从实现原理上来说：

重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！

重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。

60 struct VS class

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

61.结构体struct和联合体union的区别

答：共用体

构造数据类型,也叫联合体
用途：使几个不同类型的变量共占一段内存(相互覆盖)

结构体是一种构造数据类型
用途：把不同类型的数据组合成一个整体-------自定义数据类型

Structure 与 Union主要有以下区别:

1. struct和union都是由多个不同的数据类型成员组成, 但在任何同一时刻, union中只存放了一个被选中的成员, 而struct的所有成员都存在。在struct中，各成员都占有自己的内存空间，它们是同时存在的。一个struct变量的总长度等于所有成员长度之和。在Union中，所有成员不能同时占用它的内存空间，它们不能同时存在。Union变量的长度等于最长的成员的长度。

2. 对于union的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于struct的不同成员赋值是互不影响的。

(1).结构和联合都是由多个不同的数据类型成员组成,但在任何同一时刻,联合中只存放了一个被选中的成员（所有成员共用一块地址空间）,而结构的所有成员都存在（不同成员的存放地址不同）。

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

62 c/C++的结构体区别：

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

区别是：结构体成员默认是public的，而类是private的；

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

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

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

 

63：设计模式懂嘛，简单举个例子？

答：设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。

比如单例模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点。

适用于：当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时；当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

比如工厂模式，定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。

适用于：当一个类不知道它所必须创建的对象的类的时候；当一个类希望由它的子类来指定它所创建的对象的时候；当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

64：STL库用过吗？常见的STL容器有哪些？算法用过哪几个？

答：STL包括两部分内容：容器和算法。（重要的还有融合这二者的迭代器）

容器，即存放数据的地方。比如array等。

在STL中，容器分为两类：序列式容器和关联式容器。

序列式容器，其中的元素不一定有序，但都可以被排序。如：vector、list、deque、stack、queue、heap、priority_queue、slist；

关联式容器，内部结构基本上是一颗平衡二叉树。所谓关联，指每个元素都有一个键值和一个实值，元素按照一定的规则存放。如：RB-tree、set、map、multiset、multimap、hashtable、hash_set、hash_map、hash_multiset、hash_multimap。

下面各选取一个作为说明。

vector：它是一个动态分配存储空间的容器。区别于c++中的array，array分配的空间是静态的，分配之后不能被改变，而vector会自动重分配（扩展）空间。

set：其内部元素会根据元素的键值自动被排序。区别于map，它的键值就是实值，而map可以同时拥有不同的键值和实值。

算法，如排序，复制……以及个容器特定的算法。这点不用过多介绍，主要看下面迭代器的内容。

迭代器是STL的精髓，我们这样描述它：迭代器提供了一种方法，使它能够按照顺序访问某个容器所含的各个元素，但无需暴露该容器的内部结构。它将容器和算法分开，好让这二者独立设计。

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

int func(x)

{

    int countx = 0;

    while (x)

    {

       countx++;

       x = x&(x - 1);

    }

    return countx;

}

假定x=9999。答案：8

思路：将x转化为2进制，看含有的1的个数。

66、试写出程序结果：

int  a = 4;

int  &f(int  x)

{

    a = a + x;

    return  a;

}

int main(void)

{

    int   t = 5;

    cout << f(t) << endl;  a = 9

       f(t) = 20;             a = 20

       cout << f(t) << endl;     t = 5, a = 20  a = 25

       t = f(t);                a = 30 t = 30

       cout << f(t) << endl;

}    t = 60

}

67.有哪几种情况只能用intialization list而不能用assignment?

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

68.C++是不是类型安全的？

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

69.main函数执行以前，还会执行什么代码？

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

70 main函数执行之后还能执行代码吗？

用_onexit注册一个函数,在main执行之后就会调用这个函数.

 

71 数组和指针的区别

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

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 };

int *ptr = (int *)(&a + 1)  // a的地址加1后，其实是加了 4*5  = 20那么多。每次把一个地址加1，都是走数据结构那么大的步长。

72.简述数组与指针的区别？

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

(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 字节

}

73： int(*s[10])(int)表示的是什么？

Int (*s[10])(int)函数指针数组，每个指针指向一个int func(int param)的函数。 S[10]里面每个元素都是函数指针，指向函数的类型是

int fun(int a)

void add(int a, int b)

{

    cout << a + b << endl;

}

 

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

p1 = add;

74：将程序跳转到指定内存地址

要对绝对地址0x100000赋值，我们可以用

(unsigned int*)0x100000=1234; 那么要是想让程序跳转到绝对地址是0x100000去执行，应该怎么做？
*((void(*)())0x100000) ();

首先要将0x100000强制转换成函数指针, 即:

(void(*)())0x100000

然后再调用它 :

       *((void(*)())0x100000)();

用typedef可以看得更直观些:

typedef void(*)() voidFuncPtr;

*((voidFuncPtr)0x100000)();

75：int id[sizeof(unsigned long)];这个对吗？为什么？

正确 这个 sizeof是编译时运算符，编译时就确定了,可以看成和机器有关的常量。

76：复杂声明

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型。

77：全局变量和局部变量有什么区别？是怎么实现的？操作系统和编译器是怎么知道的？

生命周期不同：

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

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

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

78 delete与delete[ ] 区别

delete只会调用一次析构函数，而delete[] 会调用没一个成员的析构函数。

delete 与 new 配套使用； delete[] 与new[]配套使用。

对于内建的简单数据类型，delete和delete[] 功能相同。

对于复杂数据类型,delete和delete[]不同，前者删除单个对象,后者删除数组

79 抽象类和接口的区别

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

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

80 C++是不是类型按群的？

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

81.分别写出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)

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

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

83 switch参数类型

可以是：byte short int long bool
不能是： float double（这种浮点型的不能精确的比较，所以不能） string
但是在c++ 11里面， string可以作为switch的条件了。

84 频繁出现的短小的函数，在c/C++中分别如何实现

c中用宏定义； C++ 内联函数

85 C++函数传参数方式

值传递、指针、引用

86 定义宏注意什么？

定义部分的每个形参和整个表达式都必须用括号括起来。

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

宏效率高，编译时替换，没有类型检查，可能有副作用。

内联函数有类型检查，效率高，替换，当然也有可能不替换。一般函数短可以用内联，长的话编译器可以优化不内联。

函数，调用过程入栈、出栈，效率低。

88 内联函数在编译时是否做类型检查

内联函数要做类型检查，这是内联函数比宏的优势

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

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

标准输入流：stdin

标准输出流：stdout

标准错误输出流：stderr

90 如何判断浮点数是否是0.5

fabs(x - 0.5)< DBL_DEPSILON

91  #include #include "file.h"

前者是从标准库路径寻找
后者是从当前工作路径

91 sizeof

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

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

92 sizeof VS strlen

sizeof() 返回值类型为size_t(unsigned int)
sizeof是运算符，strlen是函数
sizeof的参数可以是类型，变量或函数。而strlen只能用char*做参数，必须以'\0'结尾
数组指针作为sizeof参数会退化为指针，但是传递给strlen的无论是数组还是指针不会退化为指针。

③ 编译器在编译时就计算出了sizeof 的结果。而strlen 函数必须在运行时才能计算出来。并且 sizeof计算的是数据类型占内存的大小，而 strlen 计算的是字符串实际的长度。
④ 数组做 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运行的时才会计算处理，而且是字符个数，不算最后的结尾字符。

 

1 2 3 4 5 6 7 8 9 10 11 12 13

#include #include #include using namespace std; int main() {   int a[] = {1, 2, 3, 4, 5};   cout << sizeof(a) << endl; //20 //  cout << strlen(a) << endl;   char b[] = {'a', 'b'};   cout << strlen(b) << endl; //6   cout << sizeof(b) << endl; //2 }

 

93 空指针和悬挂指针

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

94 阻止类实例化

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

95 sprintf/strcpy/memcpy

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

96 隐藏

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

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

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

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

98 打印文件名行号

cout << __FILE__ << " " << __LINE__ << endl;

99：pragma once ， ifdefine

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

100 全局变量和局部变量

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

101：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这一步，可以避免上述错。

102： extern "C "

#ifndef XXXXXXX

#define XXXXXXX //避免重复包含头文件， #pragma once 可以实现同样的功能

 

#ifdef __CPLUSCPLUS

extern "C"{

#endif

#ifdef __cplusplus

}

#endif

# endif

103  C和 c++ 互相调用

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

C++ 调用C： 比在一个.h文件中有个 foo(int),其实现是在 .c中，
当C++ 包含这个.h文件的时候就要用extern "C"， 否则编译器编译的不一样，根本调用不到。
c++ 调用一个C语言编写的DLL时，当包括.DLL的头文件或声明接口函数时，应加入extern "C"

c调用C++ ： 非类成员函数的话，就用extern “C”；

如果要调用成员函数（虚函数，重载函数），可以提供封装函数，封装函数内部调用实际的东西。

104  字符数组和字符串

注意最后一个'\0'.

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

char *p = "abc";   // 是以'\0'结尾

105 字节对齐，类对象占据内存

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

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

struct S2

{

    int i;

    char c;

};
规律：i 的地址低， C的地址高，结构体是往高地址扩展的。
A：结构体变量首地址能被其最宽基本类型成员的大小整除。（首地址能整除）
B：结构体每个成员相对于结构体首地址的偏移都是成员大小的整数倍，如有需要，会在成员之间加上填充字节。（偏移量能整除）
C: 结构体总大小为结构体最宽基本类型成员的整数倍，如有需要，会在最后一个成员之后加上填充字节。（结尾填充）
D：如果成员是复合类型，比如另外一个结构体，应该考虑子成员。

但是：还有一个影响sizeof的重要参数还没有提及：pack指令。
#paragma pack(n) // n是字节对齐数，取值是1，2，4，8，16； 默认是8
如果这个值比结构体成员的sizeof小， 那么该成员的偏移量应该以此为准： 也就是结构体成员的偏移量取二者最小值。

下面代码演示了：单独对一个结构体的字节对齐方式进行设置。
#pragma pack(push) // 将当前pack设置压栈保存

#pragma pack(2)// 必须在结构体定义之前使用

struct S1

{

    char c;

    int i;

};

struct S3

{

    char c1;

    S1 s;

    char c2

};

pack影响的的是偏移量。

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

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

＃include

    union

    {

       int i;

       char x[2];

    }a;

    void main()

    {

       a.x[0] = 10;

       a.x[1] = 1;

       printf("%d", a.i);

    }

106 虚函数表

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

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

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);

Base base;

Fun pFun = NULL;

cout << "虚函数表地址" << (int*)(&base) << endl;

cout << "虚函数表第一个函数地址：" << (int*)*(int*)(&base) << endl;

pFun = (Fun)*((int*)*(int*)(&base));

pFun();

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

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

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

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

多重继承（有虚函数覆盖） ：
多个父类虚函数表中的被覆盖的函数都会替换成子类的函数指针。这样我们就可以任一静态类型的父类来指向子类。
安全线： 用父类的指针访问子类对象的非覆盖函数，会报错。
虚函数如果是private的，但是可以通过虚函数表来访问的到的。

107 为什么用 exit()函数

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

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

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

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