C++基础问题

C++基本问题

gcc 和 g++的区别

简单来说，gcc与g++都是GNU(组织)的一个编译器。需要注意以下几点： 1. gcc与g++都可以编译c代码与c++代码。但是：后缀为.c的，gcc把它当做C程序，而g++当做是C++程序；后缀为.cpp的，两者都会认为是C++程序。 2. 编译阶段，g++会调用gcc，对于c++代码，两者是等价的，但是因为gcc命令不能自动和C＋＋程序使用的库联接，所以通常用g++来完成链接。 3. 编译可以用gcc/g++，而链接可以用g++或者gcc -lstdc++。因为gcc命令不能自动和C＋＋程序使用的库联接（当然可以选择手动链接，使用命令如下），所以通常使用g++来完成联接。但在编译阶段，g++会自动调用gcc，二者等价。 gcc main.cpp -lstdc++

gcc编译的四个步骤

以最简单的hello.c为例子, 一步到位：gcc hello.c 这条命令隐含执行了四个步骤：

预处理 ----> 编译 ----> 汇编 ----> 链接

预处理(Pre-processing) 在该阶段，编译器将C源代码中的包含的头文件如stdio.h添加进来参数：”-E” 用法：gcc -E hello.c -o hello.i 作用：将hello.c预处理输出hello.i文件。
编译(Compiling) 第二步进行的是编译阶段，在这个阶段中，gcc首先要检查代码的规范性、是否有语法错误等，以确定代码的实际要做的工作，在检查无误后，gcc把代码翻译成汇编语言。参数：”-S” 用法：gcc –S hello.i –o hello.s 作用：将预处理输出文件hello.i汇编成hello.s文件。
汇编(Assembling) 汇编阶段是把编译阶段生成的”.s”文件转成二进制目标代码“.o”文件参数：“-c” 用法：gcc –c hello.s –o hello.o 作用：将汇编输出文件hello.s编译输出hello.o文件。
链接(Link) 在成功编译之后，就进入了链接阶段。用法：gcc hello.o –o hello 作用：将编译输出文件hello.o链接成最终可执行文件hello

C++11 新特性

类型推导 decltype实际上有点像auto的反函数，auto能够让你声明一个变量。而decltype则能够从一个变量或表达式中得到类型
nullptr nullptr是为了解决原来C++中NULL的二义性问题而引进的一种新的类型，由于NULL实际上代表的是0，
简化的for循环，能够用于遍历数组、容器、string以及由begin和end函数定义的序列（即有Iterator），for (auto p : m)
lambda表达式，创建并定义匿名的函数对象 Lambda的语法例如以下： [函数对象參数]（操作符重载函数參数）->返回值类型{函数体}
```
vector<int> iv{5, 4, 3, 2, 1};
int a = 2, b = 1;
for_each(iv.begin(), iv.end(), [b](int &x){cout<<(x + b)<<endl;}); // (1)
for_each(iv.begin(), iv.end(), [=](int &x){x *= (a + b);}); // (2)
for_each(iv.begin(), iv.end(), [&](int &x)->int{return x * (a + b);});// (3)
```
[]内的參数指的是Lambda表达式能够取得的全局变量。函数中的b就是指函数能够得到在Lambda表达式外的全局变量假设在[]中传入=的话，即是能够取得全部的外部变量的值假设在[]中传入&的话，即是能够取得全部的外部变量的引用
变长參数的模板，C++11中引入了变长參数模板，所以发明了新的数据类型：tuple，tuple是一个N元组。能够传入1个， 2个甚至多个不同类型的数据 auto t1 = make_tuple(1, 2.0, "C++ 11"); auto t2 = make_tuple(1, 2.0, "C++ 11", {1, 0, 2}); 避免了从前的pair中嵌套pair的丑陋做法。使得代码更加整洁

更加优雅的初始化方法，在引入C++11之前。仅仅有数组能使用初始化列表，其它容器想要使用初始化列表，仅仅能用下面方法：

int arr[3] = {1, 2, 3}
vector<int> v(arr, arr + 3);
//在C++11中，我们能够使用下面语法来进行替换：
int arr[3]{1, 2, 3};
vector<int> iv{1, 2, 3};
map<int, string>{ {1, "a"}, {2, "b"} };
string str{"Hello World"};

智能指针的原理

智能指针是一个模板类，这个类的构造函数中传入一个普通指针，析构函数中释放传入的指针。智能指针就是一种栈上创建的对象，函数退出时会调用其析构函数，这个析构函数里面往往就是一堆计数之类的条件判断，如果达到某个条件，就把真正指针指向的空间给释放了。
智能指针的作用 C++程序设计中使用堆内存是非常频繁的操作，堆内存的申请和释放都由程序员自己管理。程序员自己管理堆内存可以提高了程序的效率，但是整体来说堆内存的管理是麻烦的，C++11中引入了智能指针的概念，方便管理堆内存。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，野指针，程序发生异常时内存泄露等问题等，使用智能指针能更好的管理堆内存。
不能将指针直接赋值给一个智能指针，一个是类，一个是指针。
智能指针在C++11版本之后提供，包含在头文件中，shared_ptr、unique_ptr、weak_ptr

1. std::auto_ptr

不支持复制（拷贝构造函数）和赋值（operator =），但复制或赋值的时候不会提示出错。所以可能会造成程序崩溃，比如 auto_ptr p1(new string ("auto") ； //#1 auto_ptr p2; //#2 p2 = p1; //#3 在语句#3中，p2接管string对象的所有权后，p1的所有权将被剥夺。前面说过，这是好事，可防止p1和p2的析构函数试图刪同—个对象；但如果程序随后试图使用p1，这将是件坏事，因为p1不再指向有效的数据。如果再访问p1指向的内容则会导致程序崩溃。 auto_ptr是C++98提供的解决方案，C+11已将将其摒弃，摒弃auto_ptr的原因，一句话总结就是：避免潜在的内存崩溃问题。

2. C++11引入的unique_ptr

也不支持复制和赋值，但比auto_ptr好，直接赋值会编译出错。实在想赋值的话，需要使用：std::move。例如：

  std::unique_ptr<int> p1(new int(5)) // #4
  std::unique_ptr<int> p2 = p1; // 编译会出错 //#5
  std::unique_ptr<int> p3 = std::move(p1); // 转移所有权, 现在那块内存归p3所有, p1成为无效的指针. //#6

编译器认为语句#5非法，因此，unique_ptr比auto_ptr更安全。但unique_ptr还有更聪明的地方。有时候，会将一个智能指针赋给另一个并不会留下危险的悬挂指针。当程序试图将一个 unique_ptr 赋值给另一个时，如果源 unique_ptr 是个临时右值，编译器允许这么做；如果源 unique_ptr 将存在一段时间，编译器将禁止这么做

  unique_ptr<string> pu1(new string ("hello world"));
  unique_ptr<string> pu2;
  pu2 = pu1; // #1 not allowed
  unique_ptr<string> pu3;
  pu3 = unique_ptr<string>(new string ("You")); // #2 allowed

其中#1留下悬挂的unique_ptr(pu1)，这可能导致危害。而#2不会留下悬挂的unique_ptr，因为它调用 unique_ptr 的构造函数，该构造函数创建的临时对象在其所有权让给 pu3 后就会被销毁。这种随情况而已的行为表明，unique_ptr 优于允许两种赋值的auto_ptr 。

3. C++11或boost的shared_ptr

基于引用计数的智能指针,可随意赋值，直到内存的引用计数为0时被释放。

4. C++11或boost的weak_ptr，弱引用

引用计数有一个问题就是互相引用形成环，这样两个指针指向的内存都无法释放。需要手动打破循环引用或使用weak_ptr。顾名思义，weak_ptr是一个弱引用，只引用，不计数。如果一块内存被shared_ptr和weak_ptr同时引用，当所有shared_ptr析构了之后，不管还有没有weak_ptr引用该内存，内存也会被释放。所以weak_ptr不保证它指向的内存一定是有效的，在使用之前需要检查weak_ptr是否为空指针。

1. C和C++的区别

C是面向过程的语言，是一个结构化的语言，考虑如何通过一个过程对输入进行处理得到输出；C++是面向对象的语言，主要特征是“封装、继承和多态”。封装隐藏了实现细节，使得代码模块化；派生类可以继承父类的数据和方法，扩展了已经存在的模块，实现了代码重用；多态则是“一个接口，多种实现”，通过派生类重写父类的虚函数，实现了接口的重用。
C和C++动态管理内存的方法不一样，C是使用malloc/free，而C++除此之外还有new/delete关键字。
C++支持函数重载，C不支持函数重载
C++中有引用，C中不存在引用的概念

2. C++中指针和引用的区别

指针是一个新的变量，存储了另一个变量的地址，我们可以通过访问这个地址来修改另一个变量；引用只是一个别名，对引用的任何操作就是对变量本身进行操作
引用只有一级，而指针可以有多级
指针传参的时候，还是值传递，指针本身的值不可以修改，需要通过解引用才能对指向的对象进行操作；引用传参的时候，传进来变量本身，因此变量可以被修改

3. struct和union的区别

结构体：将不同类型的数据组合成一个整体，是自定义类型共同体：不同类型的几个变量共同占用一段内存 1. 共同体中的所有成员占用同一段内存，它们不能同时存在； 2. sizeof(struct)是内存对齐后所有成员长度的总和，sizeof(union)是内存对齐后最长数据成员的长度.

结构体为什么要内存对齐呢？ 1. 平台原因（移植原因）：不是所有的硬件平台都能访问任意地址上的任意数据，某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常 2. 硬件原因：经过内存对齐之后，CPU的内存访问速度大大提升。

4. #define和const的区别

define定义的常量没有类型，所给出的是一个立即数；const定义的常量有类型名字，存放在静态区域
处理阶段不同，#define定义的宏变量在预处理时进行替换，可能有多个拷贝，const所定义的变量在编译时确定其值，只有一个拷贝。
define定义的常量是不可以用指针去指向，const定义的常量可以用指针去指向该常量的地址
define可以定义简单的函数，const不可以定义函数

5. 重载overload，覆盖override，隐藏overwrite

overload
将语义相近的几个函数用同一个名字表示，但是参数列表不同，这就是函数重载，返回值类型可以不同
特征：相同范围（同一个类中）、函数名字相同、参数不同、virtual关键字可有可无
override
派生类覆盖基类的虚函数，实现接口的重用，返回值类型必须相同
特征：不同范围（基类和派生类）、函数名字相同、参数相同、基类中必须有virtual关键字（必须是虚函数）
overwrite
派生类屏蔽了其同名的基类函数，返回值类型可以不同
特征：不同范围（基类和派生类）、函数名字相同、参数不同或者参数相同且无virtual关键字

6. new、delete、malloc、free之间的关系

new/delete,malloc/free都是动态分配内存的方式 1）malloc对开辟的空间大小严格指定，而new只需要对象名 2）new为对象分配空间时，调用对象的构造函数，delete调用对象的析构函数既然有了malloc/free，C++中为什么还需要new/delete呢？运算符是语言自身的特性，有固定的语义，编译器知道意味着什么，由编译器解释语义，生成相应的代码。库函数是依赖于库的，一定程度上独立于语言的。编译器不关心库函数的作用，只保证编译，调用函数参数和返回值符合语法，生成call函数的代码。 malloc/free是库函数，new/delete是C++运算符。对于非内部数据类型而言，光用malloc/free无法满足动态对象都要求。new/delete是运算符，编译器保证调用构造和析构函数对对象进行初始化/析构。但是库函数malloc/free是库函数，不会执行构造/析构。

7. delete和delete[]的区别

delete只会调用一次析构函数，而delete[]会调用每个成员的析构函数用new分配的内存用delete释放，用new[]分配的内存用delete[]释放

多态，虚函数，纯虚函数

多态：不同对象接收相同的消息产生不同的动作。多态包括编译时多态和运行时多态
运行时多态是：通过继承和虚函数来体现的。
编译时多态：运算符重载上。
封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。多态也有代码重用的功能，还有解决项目中紧耦合的问题，提高程序的可扩展性。C++实现多态的机制很简单，在继承体系下，将父类的某个函数给成虚函数（即加上virtual关键字），在派生类中对这个虚函数进行重写，利用父类的指针或引用调用虚函数。通过指向派生类的基类指针或引用，访问派生类中同名覆盖成员函数。对于虚函数调用来说，每一个对象内部都有一个虚表指针，在构造子类对象时，执行构造函数中进行虚表的创建和虚表指针的初始化，该虚表指针被初始化为本类的虚表。所以在程序中，不管你的对象类型如何转换，但该对象内部的虚表指针是固定的，所以呢，才能实现动态的对象函数调用，这就是C++多态性实现的原理。
需要注意的几点总结（基类有虚函数）：
每一个类都有虚表，单继承的子类拥有一张虚表，子类对象拥有一个虚表指针；若子类是多重继承（同时继承多个基类），则子类维护多张虚函数表（针对不同基类构建不同虚表），该子类的对象也将包含多个虚表指针。
虚表可以继承，如果子类没有重写虚函数，那么子类虚表中仍然会有该函数的地址，只不过这个地址指向的是基类的虚函数实现。如果基类3个虚函数，那么基类的虚表中就有三项（虚函数地址），派生类也会有虚表，至少有三项，如果重写了相应的虚函数，那么虚表中的地址就会改变，指向自身的虚函数实现。如果派生类有自己的虚函数，那么虚表中就会添加该项。
派生类的虚表中虚函数地址的排列顺序和基类的虚表中虚函数地址排列顺序相同。

第一：编译器在发现Father 类中有虚函数时，会自动为每个含有虚函数的类生成一份虚函数表，也叫做虚表，该表是一个一维数组，虚表里保存了虚函数的入口地址。第二：编译器会在每个对象的前四个字节中保存一个虚表指针，即（vptr),指向对象所属类的虚表。在程序运行时的合适时机，根据对象的类型去初始化vptr，从而让vptr指向正确的虚表，从而在调用虚函数时，能找到正确的函数。第三：所谓的合适时机，在派生类定义对象时，程序运行会自动调用构造函数，在构造函数中创建虚表并对虚表初始化。在构造子类对象时，会先调用父类的构造函数，此时，编译器只“看到了”父类，并为父类对象初始化虚表指针，令它指向父类的虚表；当调用子类的构造函数时，为子类对象初始化虚表指针，令它指向子类的虚表。虚函数：在基类中用virtual的成员函数。允许在派生类中对基类的虚函数重新定义。基类的虚函数可以有函数体，基类也可以实例化。虚函数要有函数体，否则编译过不去。虚函数在子类中可以不覆盖。构造函数不能是虚函数。纯虚函数：基类中为其派生类保留一个名字，以便派生类根据需要进行定义。包含一个纯虚函数的类是抽象类。纯虚函数后面有 = 0；抽象类不可以实例化。但可以定义指针。如果派生类如果不是先基类的纯虚函数，则仍然是抽象类。抽象类可以包含虚函数。

8. STL库包括两部分内容：容器和算法

容器即存放数据的地方，比如array, vector，分为两类，序列式容器和关联式容器序列式容器，其中的元素不一定有序，但是都可以被排序，比如vector,list,queue,stack，heap, priority-queue, slist 关联式容器，内部结构是一个平衡二叉树，每个元素都有一个键值和一个实值，比如map, set, hashtable, hash_set

算法有排序，复制等，以及各个容器特定的算法迭代器是STL的精髓，迭代器提供了一种方法，使得它能够按照顺序访问某个容器所含的各个元素，但无需暴露该容器的内部结构，它将容器和算法分开，让二者独立设计。

9. const作用

const修饰类的成员变量，表示常量不可能被修改 const修饰类的成员函数，表示该函数不会修改类中的数据成员，不会调用其他非const的成员函数 const函数只能调用const函数，非const函数可以调用const函数

10. 虚函数是怎么实现

每一个含有虚函数的类都至少有有一个与之对应的虚函数表，其中存放着该类所有虚函数对应的函数指针（地址），类的示例对象不包含虚函数表，只有虚指针；派生类会生成一个兼容基类的虚函数表。

11. 堆和栈的区别

栈 stack 存放函数的参数值、局部变量，由编译器自动分配释放
堆heap，是由new分配的内存块，由应用程序控制，需要程序员手动利用delete释放，如果没有，程序结束后，操作系统自动回收
因为堆的分配需要使用频繁的new/delete，造成内存空间不连续，会有大量的碎片
堆的生长空间向上，地址越大，栈的生长空间向下，地址越小

12. 关键字static

函数体内： static 修饰的局部变量作用范围为该函数体，不同于auto变量，其内存只被分配一次，因此其值在下次调用的时候维持了上次的值
模块内：static修饰全局变量或全局函数，可以被模块内的所有函数访问，但是不能被模块外的其他函数访问，使用范围限制在声明它的模块内
类中：修饰成员变量，表示该变量属于整个类所有，对类的所有对象只有一份拷贝
类中：修饰成员函数，表示该函数属于整个类所有，不接受this指针，只能访问类中的static成员变量

13. STL中map和set的原理（关联式容器）

map和set的底层实现主要通过红黑树(一种特殊的二叉查找树)来实现 1）每个节点或者是黑色，或者是红色 2）根节点是黑色 3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点为空(NULL)] 4）如果一个节点是红色的，则它的子节点必须是黑色的 5）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。特性4）5）决定了没有一条路径会比其他路径长出2倍，因此红黑树是接近平衡的二叉树。

14. #include和 "file.h" 的区别

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

15. 什么是内存泄漏？

动态分配内存，在使用完毕后未手动释放，导致一直占据该内存，即为内存泄漏。方法：malloc/free要配套，对指针赋值的时候应该注意被赋值的指针是否需要释放；使用的时候记得指针的长度，防止越界；使用智能指针

16. 定义和声明的区别

声明是告诉编译器变量的类型和名字，不会为变量分配空间定义需要分配空间，同一个变量可以被声明多次，但是只能被定义一次

17. C++文件编译与执行的四个阶段

1）预处理：根据文件中的预处理指令来修改源文件的内容 2）编译：编译成汇编代码 3）汇编：把汇编代码翻译成目标机器指令 4）链接：链接目标代码生成可执行程序

18. STL中的vector

vector就是一个动态增长的数组，里面有一个指针指向一片连续的空间，当空间装不下的时候，会申请一片更大的空间，将原来的数据拷贝过去，并释放原来的旧空间。当删除的时候空间并不会被释放，只是清空了里面的数据。对比array是静态空间一旦配置了就不能改变大小。 vector的动态增加大小的时候，并不是在原有的空间上持续新的空间（无法保证原空间的后面还有可供配置的空间），而是以原大小的两倍另外配置一块较大的空间，然后将原内容拷贝过来，并释放原空间。在原来空间不够存储新值时，每次调用push_back方法都会重新分配新的空间以满足新数据的添加操作。如果在程序中频繁进行这种操作，还是比较消耗性能的。

19. STL中unordered_map和map的区别

map是STL中的一个关联容器，提供键值对的数据管理。底层通过红黑树来实现，实际上是二叉排序树和非严格意义上的二叉平衡树。所以在map内部所有的数据都是有序的，且map的查询. 插入. 删除操作的时间复杂度都是O(logN)。

unordered_map和map类似，都是存储key-value对，可以通过key快速索引到value，不同的是unordered_map不会根据key进行排序。 unordered_map底层是一个防冗余的哈希表，存储时根据key的hash值判断元素是否相同，即unoredered_map内部是无序的。

20. C++的内存管理

在C++中，内存被分成五个区：栈、堆、自由存储区、静态存储区、常量区

栈：存放函数的参数和局部变量，编译器自动分配和释放
堆：new关键字动态分配的内存，由程序员手动进行释放，否则程序结束后，由操作系统自动进行回收
自由存储区：由malloc分配的内存，和堆十分相似，由对应的free进行释放
全局/静态存储区：存放全局变量和静态变量
常量区：存放常量，不允许被修改

21. 构造函数和析构函数

构造函数不能声明为虚函数
因为创建一个对象时需要确定对象的类型，而虚函数是在运行时确定其类型的。而在构造一个对象时，由于对象还未创建成功，编译器无法知道对象的实际类型，是类本身还是类的派生类等等
虚函数的调用需要虚函数表指针，而该指针存放在对象的内存空间中；若构造函数声明为虚函数，那么由于对象还未创建，还没有内存空间，更没有虚函数表地址用来调用虚函数即构造函数了
析构函数最好声明为虚函数首先析构函数可以为虚函数，当析构一个指向派生类的基类指针时，最好将基类的析构函数声明为虚函数，否则可以存在内存泄露的问题。如果析构函数不被声明成虚函数，则编译器实施静态绑定，在删除指向派生类的基类指针时，只会调用基类的析构函数而不调用派生类析构函数，这样就会造成派生类对象析构不完全。
子类析构时，要调用父类的析构函数吗？析构函数调用的次序时先派生类后基类的。和构造函数的执行顺序相反。并且析构函数要是virtual的，否则如果用父类的指针指向子类对象的时候，析构函数静态绑定，不会调用子类的析构。不用显式调用，会自动调用

22. 静态绑定和动态绑定的介绍

静态绑定和动态绑定是C++多态性的一种特性 1. 对象的静态类型和动态类型静态类型：对象在声明时采用的类型，在编译时确定动态类型：当前对象所指的类型，在运行期决定，对象的动态类型可变，静态类型无法更改 2. 静态绑定和动态绑定静态绑定：绑定的是对象的静态类型，函数依赖于对象的静态类型，在编译期确定动态绑定：绑定的是对象的动态类型，函数依赖于对象的动态类型，在运行期确定只有虚函数才使用的是动态绑定，其他的全部是静态绑定

23. 引用是否能实现动态绑定，为什么引用可以实现

可以。因为引用（或指针）既可以指向基类对象也可以指向派生类对象，这一事实是动态绑定的关键。用引用（或指针）调用的虚函数在运行时确定，被调用的函数是引用（或指针）所指的对象的实际类型所定义的。

24. 深拷贝和浅拷贝的区别

深拷贝和浅拷贝可以简单的理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，如果资源重新分配了就是深拷贝；反之没有重新分配资源，就是浅拷贝。

25. 什么情况下会调用拷贝构造函数（三种情况）

调用拷贝构造函数的情形： 1. 用类的一个对象去初始化另一个对象的时候 2. 当函数的参数是类的对象时，就是值传递的时候，如果是引用传递则不会调用 3. 当函数的返回值是类的对象或者引用的时候

#include <iostream>
#include <string>
using namespace std;
class A{
private:
int data;
public:
A(int i){ data = i;} //自定义的构造函数
A(A && a); //拷贝构造函数
int getdata(){return data;}
};
//拷贝构造函数
A::A(A && a){
  data = a.data;
  cout <<"拷贝构造函数执行完毕"<<endl;
}

int getdata1(A a){ //参数是对象，值传递，调用拷贝构造函数
  return a.getdata();
}

int getdata2(A &a){//参数是引用，引用传递，不调用拷贝构造函数
  return a.getdata();
}

A getA1(){//返回值是对象类型，会调用拷贝构造函数
  A a(0);
  return a;
}
//返回值是引用类型，会调用拷贝构造函数，因为函数体内生成的对象是临时的，离开函数就消失
A& getA2(){
  A a(0);
  return a;
}
int main(){
  A a1(1);
  A b1(a1); //用a1初始化b1，调用拷贝构造函数
  A c1=a1; //用a1初始化c1，调用拷贝构造函数
  int i=getdata1(a1); //函数形参是类的对象，调用拷贝构造函数
  int j=getdata2(a1); //函数形参类型是引用，不调用拷贝构造函数
  A d1=getA1(); //调用拷贝构造函数
  A e1=getA2(); //调用拷贝构造函数
  return 0;
}

26. C++的四种强制转换

static_cast ：编译时期的静态类型检查
static_cast < type-id > ( expression )
该运算符把expression转换成type-id类型，在编译时使用类型信息执行转换，在转换时执行必要的检测（指针越界、类型检查），其操作数相对是安全的
dynamic_cast：运行时的检查
用于在集成体系中进行安全的向下转换downcast，即基类指针/引用->派生类指针/引用
dynamic_cast是4个转换中唯一的RTTI操作符，提供运行时类型检查。
dynamic_cast如果不能转换返回NULL
dynamic_cast转为引用类型的时候转型失败会抛bad_cast
源类中必须要有虚函数，保证多态，才能使用dynamic_cast(expression)
const_cast
去除const常量属性，使其可以修改 ; volatile属性的转换
reinterpret_cast
通常为了将一种数据类型转换成另一种数据类型

28. extern“C”作用

extern "C"的主要作用就是为了能够正确实现C++代码调用其他C语言代码。加上extern "C"后，会指示编译器这部分代码按C语言的进行编译，而不是C++的。

29. typdef和define区别

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

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

  typedef (int*) pINT;
  #define pINT2 int* 
  pINT a,b; // 效果同int *a; int *b; 表示定义了两个整型指针变量。
  pINT2 a,b; // 效果同int *a, b;表示定义了一个整型指针变量a和整型变量b

30. volatile关键字在程序设计中有什么作用

volatile是用来解决变量在“共享”环境下容易出现读取错误的问题。变量如果加了voletile修饰，则会从内存中重新装载内容，而不是直接从寄存器中拷贝内容。在本次线程内，当读取一个变量时，为了提高读取速度，编译器进行优化时有时会先把变量读取到一个寄存器中；以后，再读取变量值时，就直接从寄存器中读取；当变量值在本线程里改变时，会同时把变量的新值copy到该寄存器中，以保持一致。当变量因别的线程值发生改变，上面寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致。 volatile可以避免优化、强制内存读取的顺序，但是volatile并没有线程同步的语义，C++标准并不能保证它在多线程情况的正确性。C++11开始有一个很好用的库，那就是atomic类模板，在头文件中，多个线程对atomic对象进行访问是安全的，并且提供不同种类的线程同步。它默认使用的是最强的同步，所以我们就使用默认的就好。

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

对比值传递，引用传参的好处： 1）在函数内部可以对此参数进行修改 2）提高函数调用和运行的效率（所以没有了传值和生成副本的时间和空间消耗）如果函数的参数实质就是形参，不过这个形参的作用域只是在函数体内部，也就是说实参和形参是两个不同的东西，要想形参代替实参，肯定有一个值的传递。函数调用时，值的传递机制是通过“形参=实参”来对形参赋值达到传值目的，产生了一个实参的副本。即使函数内部有对参数的修改，也只是针对形参，也就是那个副本，实参不会有任何更改。函数一旦结束，形参生命也宣告终结，做出的修改一样没对任何变量产生影响。

用引用作为返回值最大的好处就是在内存中不产生被返回值的副本,但是有以下的限制： 1）不能返回局部变量的引用。因为函数返回以后局部变量就会被销毁 2）不能返回函数内部new分配的内存的引用。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak 3）可以返回类成员的引用，但是最好是const。因为如果其他对象可以获得该属性的非常量的引用，那么对该属性的单纯赋值就会破坏业务规则的完整性。

32. 纯虚函数

纯虚函数是只有声明没有实现的虚函数，是对子类的约束，是接口继承包含纯虚函数的类是抽象类，它不能被实例化，只有实现了这个纯虚函数的子类才能生成对象普通函数是静态编译的，没有运行时多态

33. 什么是野指针

野指针不是NULL指针，是未初始化或者未清零的指针成因： 1）指针变量没有被初始化 2）指针指向的内存被释放了，但是指针没有置NULL 3）指针超过了变量了的作用范围，比如b[10]，指针b+11

34. C++中内存泄漏的几种情况

内存泄漏是指己动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。 1）类的构造函数和析构函数中new和delete没有配套 2）在释放对象数组时没有使用delete[]，使用了delete 3）没有将基类的析构函数定义为虚函数，当基类指针指向子类对象时，如果基类的析构函数不是virtual，那么子类的析构函数将不会被调用，子类的资源没有正确释放，因此造成内存泄露 4）没有正确的清除嵌套的对象指针

35. 栈溢出的原因以及解决方法

栈溢出是指函数中的局部变量造成的溢出（注：函数中形参和函数中的局部变量存放在栈上），栈的大小通常是1M-2M,所以栈溢出包含两种情况，一是分配的的大小超过栈的最大值，二是分配的大小没有超过最大值，但是接收的buf比原buf小。

函数调用层次过深,每调用一次,函数的参数. 局部变量等信息就压一次栈
局部变量体积太大。

解决办法大致说来也有两种：

增加栈内存的数目；如果是不超过栈大小但是分配值小的，就增大分配的大小
使用堆内存；具体实现由很多种方法可以直接把数组定义改成指针,然后动态申请内存;也可以把局部变量变成全局变量,一个偷懒的办法是直接在定义前边加个static,呵呵,直接变成静态变量(实质就是全局变量)

36. C++标准库vector以及迭代器

每种容器类型都定义了自己的迭代器类型，每种容器都定义了一队命名为begin和end的函数，用于返回迭代器。迭代器是容器的精髓，它提供了一种方法使得它能够按照顺序访问某个容器所含的各个元素，但无需暴露该容器的内部结构，它将容器和算法分开，让二者独立设计。

38. C++中vector和list的区别

vector和数组类似，拥有一段连续的内存空间。vector申请的是一段连续的内存，当插入新的元素内存不够时，通常以2倍重新申请更大的一块内存，将原来的元素拷贝过去，释放旧空间。因为内存空间是连续的，所以在进行插入和删除操作时，会造成内存块的拷贝，时间复杂度为o(n)。
list是由双向链表实现的，因此内存空间是不连续的。只能通过指针访问数据，所以list的随机存取非常没有效率，时间复杂度为o(n); 但由于链表的特点，能高效地进行插入和删除。
vector拥有一段连续的内存空间，能很好的支持随机存取，因此vector::iterator支持“+”，“+=”，“<”等操作符。
list的内存空间可以是不连续，它不支持随机访问，因此list::iterator则不支持“+”. “+=”. “<”等
vector::iterator和list::iterator都重载了“++”运算符。
总之，如果需要高效的随机存取，而不在乎插入和删除的效率，使用vector;
如果需要大量的插入和删除，而不关心随机存取，则应使用list。

39. C语言的函数调用过程

函数的调用过程： 1）从栈空间分配存储空间 2）从实参的存储空间复制值到形参栈空间 3）进行运算形参在函数未调用之前都是没有分配存储空间的，在函数调用结束之后，形参弹出栈空间，清除形参空间。数组作为参数的函数调用方式是地址传递，形参和实参都指向相同的内存空间，调用完成后，形参指针被销毁，但是所指向的内存空间依然存在，不能也不会被销毁。当函数有多个返回值的时候，不能用普通的 return 的方式实现，需要通过传回地址的形式进行，即地址/指针传递。传值：传值，实际是把实参的值赋值给行参，相当于copy。那么对行参的修改，不会影响实参的值传址：实际是传值的一种特殊方式，只是他传递的是地址，不是普通的赋值，那么传地址以后，实参和行参都指向同一个对象，因此对形参的修改会影响到实参。

41. 友元函数和友元类

友元提供了不同类的成员函数之间、类的成员函数和一般函数之间进行数据共享的机制。通过友元，一个不同函数或者另一个类中的成员函数可以访问类中的私有成员和保护成员。友元的正确使用能提高程序的运行效率，但同时也破坏了类的封装性和数据的隐藏性，导致程序可维护性变差。

1）友元函数有元函数是可以访问类的私有成员的非成员函数。它是定义在类外的普通函数，不属于任何类，但是需要在类的定义中加以声明。 friend 类型函数名(形式参数); 一个函数可以是多个类的友元函数，只需要在各个类中分别声明。

2）友元类友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。 friend class 类名;

使用友元类时注意： (1) 友元关系不能被继承。 (2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。 (3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明

42. < algorithm >中的实用函数

gcd(x, y) 求两个数的最大公约数，如gcd(6, 8) 就返回2。
reverse(a + 1, a + n + 1) 将数组中的元素反转。a 是数组名，n是长度，跟 sort 的用法一样。值得一提的是，对于字符型数组也同样适用。
unique(a + 1, a + n + 1) 去重函数。跟sort的用法一样。不过他返回的值是最后一个数的地址，所以要得到新的数组长度应该这么写： _n = unique(a + 1, a + n + 1) - a - 1.
lower_bound(a + 1, a + n + 1, x); upper_bound(a + 1, a + n + 1, x) lower_bound是查找数组中第一个大于等于x的数，返回该地址，同理也是 pos = lower_bound(a + 1, a + n + 1, x) - a upper_bound是查找第一个大于x的数，用法和lower_bound一样复杂度是二分的复杂度，O(logn)。（其实就是代替了手写二分）
fill(a + 1, a + n + 1, x) 将数组a中的每一个元素都赋成x，跟memset的区别是，memset函数按照字节填充 int数组：fill(arr, arr + n, 要填入的内容); vector也可以：fill(v.begin(), v.end(), 要填入的内容); fill(vector.begin(), cnt, val); // 从当前起始点开始，将之后的cnt个元素赋值为val。

Previouscpp Nextpython

Last updated 5 years ago

Was this helpful?