python创建对象后、可以使用什么运算符来调用其成员_c++知识汇总

指针和引用的区别

1.指针是一个新的变量，指向另一个变量的地址，我们可以通过访问这个地址来修改另一个变量；而引用是一个别名，对引用的操作就是对变量的本身进行操作

2.指针可以有多级，引用只有一级

3.传参的时候，使用指针的话需要解引用才能对参数进行修改，而使用引用可以直接对参数进行修改

指针的大小一般是4个字节，引用的大小取决于被引用对象的大小(指的是使用sizeof运算符得到的结果，引用本质上还是使用指针，因此所占内存和指针是一样的)

指针可以为空，引用不可以。

在函数参数传递的时候，什么时候使用指针，什么时候使用引用？

1.需要返回函数内局部变量的内存的时候用指针。使用指针传参需要开辟内存，用完要记得释放指针，不然会内存泄漏。而返回局部变量的引用是没有意义的

2.对栈空间大小比较敏感(比如递归)的时候使用引用。使用引用传递不需要创建临时变量，开销要更小

3.类对象作为参数传递的时候使用引用，这是C++类对象传递的标准方式

堆和栈有什么区别

1.从定义上：堆是由new和malloc开辟的一块内存，由程序员手动管理，栈是编译器自动管理的内存，存放函数的参数和局部变量。

2.从定义上：堆是由new和malloc开辟的一块内存，由程序员手动管理，栈是编译器自动管理的内存，存放函数的参数和局部变量。

3.堆的生长空间向上，地址越来越大，栈的生长空间向下，地址越来越小

堆快一点还是栈快一点？

栈快一点。因为操作系统会在底层对栈提供支持，会分配专门的寄存器存放栈的地址，栈的入栈出栈操作也十分简单，并且有专门的指令执行，所以栈的效率比较高也比较快。而堆的操作是由C/C++函数库提供的，在分配堆内存的时候需要一定的算法寻找合适大小的内存。并且获取堆的内容需要两次访问，第一次访问指针，第二次根据指针保存的地址访问内存，因此堆比较慢。

new和delete是如何实现的，new 与 malloc的异同处

1.在new一个对象的时候，首先会调用malloc为对象分配内存空间，然后调用对象的构造函数。delete会调用对象的析构函数，然后调用free回收内存

2.new与malloc都会分配空间，但是new还会调用对象的构造函数进行初始化，malloc需要给定空间大小，而new只需要对象名

既然有了malloc/free，C++中为什么还需要new/delete呢

答：对于非内部数据对象(eg：类对象)，只用malloc/free无法满足动态对象的要求。这是因为对象在创建的同时需要自动执行构造函数，对象在消亡之前要自动执行析构函数，而由于malloc/free是库函数而不是运算符，不在编译器的控制权限内，也就不能自动执行构造函数和析构函数。因此，不能将执行构造函数和析构函数的任务强加给malloc/free。所以，在c++中需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理和释放内存工作的运算符delete。

什么是内部数据类型和非内部数据类型

内部数据类型是编译器本身就认识的，不需要用户自己定义。如：基本数据类型：int，char，double等都是内部数据类型；

2：非内部数据类型不是编译器本身就认识的，需要用户自己定义才能让编译器识别。如：由class，struct，union等关键字修饰 的变量都是非内部数据类型

为什么库函数不在编译器控制权限内，而运算符在

库函数是已经编译的代码，编译器不会在编译检查，由链接器将库同用户写的代码合成exe文件。而运算符是否正确，编译器在编译扫描分析时就可以判定。

C和C++的区别

1.C是面向过程的语言，C++是面向对象的语言，C++有“封装，继承和多态”的特性。封装隐藏了实现细节，使得代码模块化。继承通过子类继承父类的方法和属性，实现了代码重用。多态则是“一个接口，多个实现”，通过子类重写父类的虚函数，实现了接口重用。

2.C和C++内存管理的方法不一样，C使用malloc/free，C++除此之外还用new/delete

3.C++中还有函数重载和引用等概念

delete和delete[]的区别

1.delete只会调用一次析构函数，而delete[]会调用每个成员的析构函数

2.用new分配的内存用delete释放，用new[]分配的内存用delete[]释放

C++、Java的联系与区别，包括语言特性、垃圾回收、应用场景等(java的垃圾回收机制)

1.C++ 和Java都是面向对象的语言，C++是编译成可执行文件直接运行的，JAVA是编译之后在JAVA虚拟机上运行的，因此JAVA有良好的跨平台特性，但是执行效率没有C++ 高。

2.C++的内存管理由程序员手动管理，JAVA的内存管理是由Java虚拟机完成的，它的垃圾回收使用的是标记-回收算法

3.C++有指针，Java没有指针，只有引用

4.JAVA和C++都有构造函数，但是C++有析构函数但是Java没有

C++和python的区别

1.python是一种脚本语言，是解释执行的，而C++是编译语言，是需要编译后在特定平台运行的。python可以很方便的跨平台，但是效率没有C++高。

2.python使用缩进来区分不同的代码块，C++使用花括号来区分

3.C++中需要事先定义变量的类型，而python不需要，python的基本数据类型只有数字，布尔值，字符串，列表，元组等等

4.python的库函数比C++的多，调用起来很方便

Struct和class的区别

1.使用struct时，它的成员的访问权限默认是public的，而class的成员默认是private的

2.struct的继承默认是public继承，而class的继承默认是private继承

3.class可以用作模板，而struct不能

define 和const的联系与区别(编译阶段、安全性、内存占用等

联系：它们都是定义常量的一种方法

区别：

1.define定义的常量没有类型，只是进行了简单的替换，可能会有多个拷贝，占用的内存空间大，const定义的常量是有类型的，存放在静态存储区，只有一个拷贝，占用的内存空间小。

2.define定义的常量是在预处理阶段进行替换，而const在编译阶段确定它的值。

3.define不会进行类型安全检查，而const会进行类型安全检查，安全性更高

4.const可以定义函数而define不可以

在C++中const的用法(定义，用途)

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

2.const修饰类的成员函数，表示该函数不会修改类中的数据成员，不会调用其他非const的成员函数(非const对象是可以调用const成员函数的，const对象是不可以调用类中的非const成员函数 与传入的那个this指针有关系)

C++中的static用法和意义

总：static的意思是静态的，可以用来修饰变量，函数和类成员

变量：被static修饰的变量就是静态变量，它会在程序运行过程中一直存在，会被放在静态存储区。局部静态变量的作用域在函数体中，全局静态变量的作用域在这个文件里。

函数：被static修饰的函数就是静态函数，静态函数只能在本文件中使用，不能被其他文件调用，也不会和其他文件中的同名函数冲突。

类：而在类中，被static修饰的成员变量是类静态成员，这个静态成员会被类的多个对象共用。被static修饰的成员函数也属于静态成员，不是属于某个对象的，访问这个静态函数不需要引用对象名，而是通过引用类名来访问。

(静态成员函数要访问非静态成员时，要用过对象来引用。局部静态变量在函数调用结束后也不会被回收，会一直在程序内存中，直到该函数再次被调用，它的值还是保持上一次调用结束后的值。)

注：空类的大小是1， 在C++中空类会占一个字节，这是为了让对象的实例能够相互区别，当该空白类作为基类时，该类的大小就优化为0了，子类的大小就是子类本身的大小。这就是所谓的空白基类最优化。

静态成员存放在静态存储区，不占用类的大小, 普通函数也不占用类大小

C++的STL介绍(这个系列也很重要，建议侯捷老师的这方面的书籍与视频)，其中包括内存管理allocator，函数，实现机理，多线程实现等

1.算法包括排序，复制等常用算法，以及不同容器特定的算法

2.容器就是数据的存放形式，包括序列式容器和关联式容器，序列式容器就是list，vector等，关联式容器就是set，map等。

3.迭代器就是在不暴露容器内部结构的情况下对容器的遍历

STL源码中的hash表的实现

1.STL中的hash表就unordered_map。使用的是哈希进行实现(注意与map的区别)。它记录的键是元素的哈希值，通过对比元素的哈希值来确定元素的值。

2.unordered_map的底层实现是hashtable，采用开链法(也就是用桶)来解决哈希冲突，默认的桶大小是

解决哈希冲突的方式？

1.线性探查。该元素的哈希值对应的桶不能存放元素时，循序往后一一查找，直到找到一个空桶为止，在查找时也一样，当哈希值对应位置上的元素与所要寻找的元素不同时，就往后一一查找，直到找到吻合的元素，或者空桶。

2.二次探查。该元素的哈希值对应的桶不能存放元素时，就往后寻找1^2,2^2,3^2,4^2.....i^2个位置

3.双散列函数法。当第一个散列函数发生冲突的时候，使用第二个散列函数进行哈希，作为步长

4.开链法。在每一个桶中维护一个链表，由元素哈希值寻找到这个桶，然后将元素插入到对应的链表中，STL的hashtable就是采用这种实现方式。

5.建立公共溢出区。当发生冲突时，将所有冲突的数据放在公共溢出区

STL中unordered_map和map的区别

1.unordered_map是使用哈希实现的，占用内存比较多，查询速度比较快，是常数时间复杂度。它内部是无序的，需要实现==操作符。

map底层是采用红黑树实现的，插入删除查询时间复杂度都是O(log(n))，它的内部是有序的，因此需要实现比较操作符(

STL中vector的实现

三个指针 start ,finish, end of storage

1.STL中的vector是封装了动态数组的顺序容器。不过与动态数组不同的是，vector可以根据需要自动扩大容器的大小。具体策略是每次容量不够用时重新申请一块大小为原来容量两倍的内存，将原容器的元素拷贝至新容器，并释放原空间，返回新空间的指针。

C++中vector和list的区别

1.list是由双向链表实现的，因此内存空间是不连续的。只能通过指针访问数据，所以list的随机存取非常没有效率，时间复杂度为o(n); 但由于链表的特点，能高效地进行插入和删除。

2.vector拥有一段连续的内存空间，能很好的支持随机存取，因此vector::iterator支持“+”，“+=”，“

3.list的内存空间可以是不连续，它不支持随机访问，因此list::iterator则不支持“+”、“+=”、“

C++中的重载和重写的区别

函数压榨

1.重载(overload)：在C++程序中，可以将语义、功能相似的几个函数用同一个名字表示，但参数或返回值不同(包括类型、顺序不同)，即函数重载。

(1)相同的范围(在同一个类中)；

(2)函数名字相同；

(3)参数不同；

(4)virtual 关键字可有可无。

2.重写(overwide)：是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

(1)如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏(注意别与重载混淆)。

(2)如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏(注意别与覆盖混淆)。

3.覆盖：是指派生类函数覆盖基类函数，特征是：

(1)不同的范围(分别位于派生类与基类)；

(2)函数名字相同；

(3)参数相同；

(4)基类函数必须有virtual 关键字

c++内存管理

C++的内存空间分为以下5个部分：

静态存储区：内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。它主要存放静态数据(局部static变量，全局static变量)、全局变量和常量。

栈区：在执行函数时，函数(包括main函数)内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。(任何变量都处于栈区，例如int a[] = {1, 2},变量a处于栈区。数组的内容也存在于栈区。)

堆区：亦称动态内存分配。程序在运行的时候用malloc或new申请任意大小的内存，程序员自己负责在适当的时候用free或delete释放内存。动态内存的生存期可以由我们决定，如果我们不释放内存，程序将在最后才释放掉动态内存。 但是，良好的编程习惯是：如果某动态内存不再使用，需要将其释放掉，并立即将指针置位NULL，防止产生野指针。

文字常量区：常量字符串放在这里，程序结束后由系统释放。

程序代码区：存放函数体的二进制代码。

指针：函数指针指向Code区，是程序运行的指令代码，数据指针指向Data,Heap,Stack区，是程序依赖以运行的各种数据

注:当static用来修饰全局变量的时候，它就改变了全局变量的作用域(在声明它的文件之外是不可见的)，但是没有改变它的存放位置，还是在静态存储区中。

堆与栈的区别

1、管理方式不同

2、空间大小不同

3、产生碎片不同

4、生长方向不同

5、分配方式不同

6、分配效率不同(栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高)

堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的

介绍面向对象的三大特性，并且举例说明每一个。

1.封装隐藏了类的实现细节和成员数据，实现了代码模块化，如类里面的private和public；

2.继承使得子类可以复用父类的成员和方法，实现了代码重用；

3.多态则是“一个接口，多个实现”，通过父类调用子类的成员，实现了接口重用，如父类的指针指向子类的对象

多态的实现

C++ 多态包括编译时多态和运行时多态，编译时多态体现在函数重载和模板上，运行时多态体现在虚函数上。

虚函数：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数.

C++虚函数相关(虚函数表，虚函数指针)，虚函数的实现原理

C++的虚函数是实现多态的机制。它是通过虚函数表实现的，虚函数表是每个类中存放虚函数地址的指针数组，类的实例在调用函数时会在虚函数表中寻找函数地址进行调用，如果子类覆盖了父类的函数，则子类的虚函数表会指向子类实现的函数地址，否则指向父类的函数地址。一个类的所有实例都共享同一张虚函数表。

如果多重继承和多继承的话，子类的虚函数表长什么样子？

多重继承的情况下越是祖先的父类的虚函数更靠前，多继承的情况下越是靠近子类名称的类的虚函数在虚函数表中更靠前

实现编译器处理虚函数表应该如何处理

如果类中有虚函数，就将虚函数的地址记录在类的虚函数表中。派生类在继承基类的时候，如果有重写基类的虚函数，就将虚函数表中相应的函数指针设置为派生类的函数地址，否则指向基类的函数地址。

基类的析构函数一般写成虚函数的原因

首先析构函数可以为虚函数，当析构一个指向子类的父类指针时，编译器可以根据虚函数表寻找到子类的析构函数进行调用，从而正确释放子类对象的资源。

如果析构函数不被声明成虚函数，则编译器实施静态绑定，在删除指向子类的父类指针时，只会调用父类的析构函数而不调用子类析构函数，这样就会造成子类对象析构不完全造成内存泄漏。

构造函数为什么一般不定义为虚函数

1.由于对象还未创建成功，编译器无法知道对象的实际类型

2.虚函数的调用需要虚函数表指针，而该指针存放在对象的内存空间中；若构造函数声明为虚函数，那么由于对象还未创建，还没有内存空间，更没有虚函数表地址用来调用虚函数即构造函数了

构造函数或者析构函数中调用虚函数会怎样

在构造函数中调用虚函数，由于当前对象还没有构造完成，此时调用的虚函数指向的是基类的函数实现方式。

在析构函数中调用虚函数，此时调用的是子类的函数实现方式。

纯虚函数

纯虚函数是只有声明没有实现的虚函数，是对子类的约束，是接口继承

包含纯虚函数的类是抽象类，它不能被实例化，只有实现了这个纯虚函数的子类才能生成对象

使用场景：当这个类本身产生一个实例没有意义的情况下，把这个类的函数实现为纯虚函数，比如动物可以派生出老虎兔子，但是实例化一个动物对象就没有意义。并且可以规定派生的子类必须重写某些函数的情况下可以写成纯虚函数。

静态绑定和动态绑定区别

静态绑定发生在编译期，动态绑定发生在运行期；

对象的动态类型可以更改，但是静态类型无法更改；

要想实现动态，必须使用动态绑定；

在继承体系中只有虚函数使用的是动态绑定，其他的全部是静态绑定；

注：1.绝对不要重新定义继承而来的非虚(non-virtual)函数(《Effective C++ 第三版》条款36)，因为这样导致函数调用由对象声明时的静态类型确定了，而和对象本身脱离了关系，没有多态，也这将给程序留下不可预知的隐患和莫名其妙的BUG；

2.绝对不要重新定义一个继承而来的virtual函数的缺省参数值，因为缺省参数值都是静态绑定(为了执行效率)，而virtual函数却是动态绑

深拷贝和浅拷贝的区别

浅拷贝就是将对象的指针进行简单的复制，原对象和副本指向的是相同的资源。

而深拷贝是新开辟一块空间，将原对象的资源复制到新的空间中，并返回该空间的地址。

深拷贝可以避免重复释放和写冲突。例如使用浅拷贝的对象进行释放后，对原对象的释放会导致内存泄漏或程序崩溃。

对象复用的了解，零拷贝的了解

对象复用指得是设计模式，对象可以采用不同的设计模式达到复用的目的，最常见的就是继承和组合模式了。

零拷贝指的是在进行操作时，避免CPU从一处存储拷贝到另一处存储。在Linux中，我们可以减少数据在内核空间和用户空间的来回拷贝实现，比如通过调用mmap()来代替read调用

用程序调用mmap()，磁盘上的数据会通过DMA被拷贝的内核缓冲区，接着操作系统会把这段内核缓冲区与应用程序共享，这样就不需要把内核缓冲区的内容往用户空间拷贝。应用程序再调用write(),操作系统直接将内核缓冲区的内容拷贝到socket缓冲区中，这一切都发生在内核态，最后，socket缓冲区再把数据发到网卡去

C++中的构造函数主要有三种类型：默认构造函数、重载构造函数和拷贝构造函数

1.默认构造函数是当类没有实现自己的构造函数时，编译器默认提供的一个构造函数。

2.重载构造函数也称为一般构造函数，一个类可以有多个重载构造函数，但是需要参数类型或个数不相同。可以在重载构造函数中自定义类的初始化方式。

3.拷贝构造函数是在发生对象复制的时候调用的。

什么情况下会调用拷贝构造函数

1.对象以值传递的方式传入函数参数

2.对象以值传递的方式从函数返回

3.对象需要通过另外一个对象进行初始化

结构体内存对齐方式和为什么要进行内存对齐

因为结构体的成员可以有不同的数据类型，所占的大小也不一样。同时，由于CPU读取数据是按块读取的，内存对齐可以使得CPU一次就可以将所需的数据读进来

内存泄露的定义，如何检测与避免

动态分配内存所开辟的空间，在使用完毕后未手动释放，导致一直占据该内存，即为内存泄漏。

造成内存泄漏的几种原因：

1)类的构造函数和析构函数中new和delete没有配套

2)在释放对象数组时没有使用delete[]，使用了delete

3)没有将基类的析构函数定义为虚函数，当基类指针指向子类对象时，如果基类的析构函数不是virtual，那么子类的析构函数将不会被调用，子类的资源没有正确释放，因此造成内存泄露

4)没有正确的清楚嵌套的对象指针

避免方法：

1.malloc/free要配套

2.使用智能指针；

3.将基类的析构函数设为虚函数；

C++的智能指针有哪些

auto_ptr,shared_ptr,weak_ptr和unique_ptr。

1.auto_ptr是较早版本的智能指针，在进行指针拷贝和赋值的时候，新指针直接接管旧指针的资源并且将旧指针指向空，但是这种方式在需要访问旧指针的时候，就会出现问题。

2.unique_ptr是auto_ptr的一个改良版，不能赋值也不能拷贝，保证一个对象同一时间只有一个智能指针。

3.shared_ptr可以使得一个对象可以有多个智能指针，当这个对象所有的智能指针被销毁时就会自动进行回收。(内部使用计数机制进行维护)

4.weak_ptr是为了协助shared_ptr而出现的。它不能访问对象，只能观测shared_ptr的引用计数，防止出现死锁

如何判断weak_ptr() 对象是否失效

1.expired() 检查引用类型是否删除

2.Lock()会返回shared指针指针会判断该指针是否为空

3.Use_count()可以得到引用的个数 但是速度慢

gdb调试

gdb单独调试子进程

$ps -ef | grep 进程名

//通过上述命令的到待调试进程的PID

$gdb

(gdb) attach "PID"

//上面的“PID”即待调试进程的pid

调试器选项follow-fork-mode

set follow-fork-mode mode(parent / child)

多线程程序

1.info threads：显示当前可调试的所有线程

2.thread ID：调试目标ID指定的线程

3.set scheduler-locking[off|on|step]

1.通过设置断点进行调试 b

2.打印log进行调试 info

3.打印中间结果进行调试 print

遇到coredump要怎么调试

coredump是程序由于异常或者bug在运行时异常退出或者终止，在一定的条件下生成的一个叫做core的文件，这个core文件会记录程序在运行时的内存，寄存器状态，内存指针和函数堆栈信息等等。对这个文件进行分析可以定位到程序异常的时候对应的堆栈调用信息

1.使用gdb命令对core文件进行调试

gdb [可执行文件名] [core文件名]

inline关键字说一下 和宏定义有什么区别

inline是内联的意思，可以定义比较小的函数。因为函数频繁调用会占用很多的栈空间，进行入栈出栈操作也耗费计算资源，所以可以用inline关键字修饰频繁调用的小函数。编译器会在编译阶段将代码体嵌入内联函数的调用语句块中。

1、内联函数在编译时展开，而宏在预编译时展开

2、在编译的时候，内联函数直接被嵌入到目标代码中去，而宏只是一个简单的文本替换。

3、内联函数可以进行诸如类型安全检查、语句是否正确等编译功能，宏不具有这样的功能。

4、宏不是函数，而inline是函数

5、宏在定义时要小心处理宏参数，一般用括号括起来，否则容易出现二义性。而内联函数不会出现二义性。

6、inline可以不展开，宏一定要展开。因为inline指示对编译器来说，只是一个建议，编译器可以选择忽略该建议，不对该函数进行展开。

7、宏定义在形式上类似于一个函数，但在使用它时，仅仅只是做预处理器符号表中的简单替换，因此它不能进行参数有效性的检测，也就不能享受C++编译器严格类型检查的好处，另外它的返回值也不能被强制转换为可转换的合适的类型，这样，它的使用就存在着一系列的隐患和局限性。

模板的用法与适用场景 实现原理

用template 关键字进行声明，接下来就可以进行模板函数和模板类的编写了

编译器会对函数模板进行两次编译：第一次编译在声明的地方对模板代码本身进行编译，这次编译只会进行一个语法检查，并不会生成具体的代码。第二次编译时对代码进行参数替换后再进行编译，生成具体的函数代码。

成员初始化列表的概念，为什么用成员初始化列表会快一些(性能优势)？

因为使用成员初始化列表进行初始化的话，会直接使用传入参数的拷贝构造函数进行初始化，省去了一次执行传入参数的默认构造函数的过程，否则会调用一次传入参数的默认构造函数。所以使用成员初始化列表效率会高一些。

(使用初始化列表主要是基于性能问题，对于内置类型，如int, float等，使用初始化类表和在构造函数体内初始化差别不是很大，但是对于类类型来说，最好使用初始化列表,成员变量的初始化顺序

成员是按照他们在类中出现的顺序进行初始化的，而不是按照他们在初始化列表出现的顺序初始化的)

有三种情况是必须使用成员初始化列表进行初始化的：

1.常量成员的初始化，因为常量成员只能初始化不能赋值

2.引用类型

3.没有默认构造函数的对象必须使用成员初始化列表的方式进行初始化

用过C11吗，知道C11新特性吗？

1.自动类型推导auto：auto的自动类型推导用于从初始化表达式中推断出变量的数据类型。通过auto的自动类型推导，可以大大简化我们的编程工作

2.nullptr是为了解决原来C++中NULL的二义性问题而引进的一种新的类型，因为NULL实际上代表的是0，而nullptr是void类型的

3.lambda表达式：它类似Javascript中的闭包，它可以用于创建并定义匿名的函数对象，以简化编程工作。

4.thread类和mutex类

5.新的智能指针 unique ptr和shared ptr

C++的调用惯例(简单一点C++函数调用的压栈过程)

1.从栈空间分配存储空间

2.从实参的存储空间复制值到形参栈空间

3.进行运算

数组作为参数的函数调用方式是地址传递，形参和实参都指向相同的内存空间，调用完成后，形参指针被销毁，但是所指向的内存空间依然存在，不能也不会被销毁。

当函数有多个返回值的时候，不能用普通的 return 的方式实现，需要通过传回地址的形式进行，即地址/指针传递。

C++的四种强制转换

四种强制类型转换操作符分别为：static_cast、dynamic_cast、const_cast、reinterpret_cast

1.static_cast:用于各种隐式转换。具体的说，就是用户各种基本数据类型之间的转换，比如把int换成char，float换成int等。以及派生类(子类)的指针转换成基类(父类)指针的转换。

特性与要点：

1.它没有运行时类型检查，所以是有安全隐患的。

2.在派生类指针转换到基类指针时，是没有任何问题的，在基类 指针转换到派生类指针的时候，会有安全问题。

static_cast不能转换const，volatile等属性

dynamic_cast:用于动态类型转换。具体的说，就是在基类指针到派生类指针，或者派生类到基类指针的转换

1.dynamic_cast能够提供运行时类型检查，只用于含有虚函数的类

2.dynamic_cast如果不能转换返回NULL。

const_cast：:

1.用于去除const常量属性，使其可以修改 ，也就是说，原本定义为const的变量在定义后就不能进行修改的，但是使const_cast操作之后，可以通过这个指针或变量进行修改; 另外还有volatile属性的转换。

4.reinterpret_cast:

1.几乎什么都可以转，用在任意的指针之间的转换，引用之间的转换，指针和足够大的int型之间的转换，整数到指针的转换等。但是不够安全。

string的底层实现

1.string继承自basic_string,其实是对char进行了封装，封装的string包含了char数组，容量，长度等等属性

string可以进行动态扩展，在每次扩展的时候另外申请一块原空间大小两倍的空间(2*n)，然后将原字符串拷贝过去，并加上新增的内容

一个函数或者可执行文件的生成过程或者编译过程是怎样的

预处理，编译，汇编，链接

1.预处理： 对预处理命令进行替换等预处理操作

2.编译：代码优化和生成汇编代码

3.汇编：将汇编代码转化为机器语言

4.链接：将目标文件彼此链接起来

set，map和vector的插入复杂度

1.set,map的插入复杂度就是红黑树的插入复杂度，是log(N)

2.unordered_set,unordered_map的插入复杂度是常数，最坏是O(N).

3.vector的插入复杂度是O(N),最坏的情况下(从头插入)就要对所有其他元素进行移动，或者扩容重新拷贝

定义和声明的区别

1.声明是告诉编译器变量的类型和名字，不会为变量分配空间

2.定义就是对这个变量和函数进行内存分配和初始化。需要分配空间，同一个变量可以被声明多次，但是只能被定义一次

typdef和define区别

#define是预处理命令，在预处理是执行简单的替换，不做正确性的检查

typedef是在编译时处理的，它是在自己的作用域内给已经存在的类型一个别名

被free回收的内存是立即返还给操作系统吗？为什么

如果每次free掉的内存都还给OS的话，尤其是在小字节的情况下，那么造成的情况，就是一大块的内存被你弄的千疮百孔，也就是说一块内存，里面有很多gap

内存管理一般会有一个free block list，free掉的东西就放在这里来。那么你可能会释放很散乱的内存过来，没关系，我们在这里会尝试合并这些散乱的block，而malloc首先找的也是free block list，而非从OS申请新的内存

引用作为函数参数以及返回值的好处

1.在函数内部可以对此参数进行修改

2.提高函数调用和运行的效率(因为没有了传值和生成副本的时间和空间消耗)

限制

1.不能返回局部变量的引用。因为函数返回以后局部变量就会被销毁

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

3.可以返回类成员的引用，但是最好是const。因为如果其他对象可以获得该属性的非常量的引用，那么对该属性的单纯赋值就会破坏业务规则的完整性。

友元函数和友元类

友元函数：友元函数是指某些虽然不是类成员函数却能够访问类的所有成员的函数

友元类：友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。

注意事项

1.友元关系不能被继承

2.友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明

3.友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明。

4.必须先定义包含成员函数的类，才能将成员函数设为友元。另一方面，不必预先声明类和非成员函数来将它们设为友元。

说一下volatile关键字的作用

它修饰的变量的值十分容易被改变，所以编译器就不会对这个变量进行优化(CPU的优化是让该变量存放到CPU寄存器而不是内存)，进而提供稳定的访问。每次读取volatile的变量时，系统总是会从内存中读取这个变量，并且将它的值立刻保存。

STL中的sort()算法是用什么实现的，stable_sort()呢

STL中的sort是用快速排序和插入排序结合的方式实现的，stable_sort()是归并排序。

vector会迭代器失效吗？什么情况下会迭代器失效

1.当vector在插入的时候，如果原来的空间不够，会将申请新的内存并将原来的元素移动到新的内存，此时指向原内存地址的迭代器就失效了，first和end迭代器都失效

2.当vector在插入的时候，end迭代器肯定会失效

3.当vector在删除的时候，被删除元素以及它后面的所有元素迭代器都失效

为什么C++没有实现垃圾回收

1.首先，实现一个垃圾回收器会带来额外的空间和时间开销。你需要开辟一定的空间保存指针的引用计数和对他们进行标记mark。然后需要单独开辟一个线程在空闲的时候进行free操作。

2.垃圾回收会使得C++不适合进行很多底层的操作