C/C++面试题总结（持续更新~）

﹏ヽ暗。殇╰゛Y 2024-04-17 05:47 78阅读 0赞

# 以下题目总结于：[牛客网][Link 1] #

## **相关总结：** ##

> ### [计算机网络面试题总结][Link 2] ###
> 
> ### [数据结构与算法面试题总结][Link 3] ###
> 
> ### [操作系统面试题总结][Link 4] ###
> 
> ### [设计模式面试题总结][Link 5] ###
> 
> ### [数据库面试总结][Link 6] ###

# **一、C/C++基础部分** #

### 1、说一下static关键字的作用？ ###

参考答案：

① 全局静态变量

在全局变量前加上关键字 static，全局变量就定义成一个全局静态变量。

内存中位置：静态存储区，在整个程序运行期间一直存在。

初始化：未经初始化的全局静态变量会被自动初始化为0（自动对象的值是任意的，除非他被显式初始化）；

作用域：全局静态变量在声明他的文件之外是不可见的，准确地说是从定义之处开始，到文件结尾。

② 局部静态变量

在局部变量之前加上关键字static，局部变量就成为一个局部静态变量。

内存中的位置：静态存储区

初始化：未经初始化的局部静态变量会被自动初始化为0（自动对象的值是任意的，除非他被显式初始化）；

作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域结束。但是当局部静态变量离开作用域后，并没有销毁，而是仍然驻留在内存当中，只不过我们不能再对它进行访问，直到该函数再次被调用，并且值不变；

③ 静态函数

在函数返回类型前加static，函数就定义为静态函数。函数的定义和声明在默认情况下都是extern的，但静态函数只是在声明他的文件当中可见，不能被其他文件所用。

函数的实现使用static修饰，那么这个函数只可在本cpp内使用，不会同其他cpp中的同名函数引起冲突；

注意：不要在头文件中声明static的全局函数，不要在cpp内声明非static的全局函数，如果你要在多个cpp中复用该函数，就把它的声明提到头文件里去，否则cpp内部声明需加上static修饰；

④ 类的静态成员

在类中，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。因此，静态成员是类的所有对象中共享的成员，而不是某个对象的成员。对多个对象来说，静态数据成员只存储一处，供所有对象共用。

⑤ 类的静态函数

静态成员函数和静态数据成员一样，它们都属于类的静态成员，它们都不是对象成员。因此，对静态成员的引用不需要用对象名。

在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员（这点非常重要）。如果静态成员函数中要引用非静态成员时，可通过对象来引用。

从中可看出，调用静态成员函数使用如下格式：<类名>::<静态成员函数名>(<参数表>);

**简洁回答：（推荐）**

> ① 加了 static 关键字的全局变量只能在本文件中使用。
> 
> 例如在 a.c 中定义了 static int a=10;那么在 b.c 中用extern int a 是拿不到 a 的值得，a 的作用域只在 a.c 中。
> 
> ② static 定义的静态局部变量分配在数据段上，普通的局部变量分配在栈上，会因为函数栈帧的释放而被释放掉。
> 
> ③ 对一个类中成员变量和成员函数来说，加了 static 关键字，则此变量/函数就没有了 this 指针了，必须通过类名才能访问

### 思维拓展： ###

### ①[说一下const关键字的作用][const]？ ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2t5NTI1Mjk_size_16_color_FFFFFF_t_70]

### [② 请说一下extern关键字的作用？][_extern] ###

1.  **extern修饰变量的声明**。举例来说，如果文件a.c需要引用b.c中变量int v，就可以在a.c中声明extern int v，然后就可以引用变量v。这里需要注意的是，被引用的变量v的链接属性必须是外链接（external）的，也就是说a.c要引用到v，不只是取决于在a.c中声明extern int v，还取决于变量v本身是能够被引用到的。这涉及到c语言的另外一个话题－－变量的作用域。能够被其他模块以extern修饰符引用到的变量通常是全局变量。还有很重要的一点是，extern int v可以放在a.c中的任何地方，比如你可以在a.c中的函数fun定义的开头处声明extern int v，然后就可以引用到变量v了，只不过这样只能在函数fun作用域中引用v罢了，这还是变量作用域的问题。对于这一点来说，很多人使用的时候都心存顾虑。好像extern声明只能用于文件作用域似的。
2.  **extern修饰函数声明**。从本质上来讲，变量和函数没有区别。函数名是指向函数二进制块开头处的指针。如果文件a.c需要引用b.c中的函数，比如在b.c中原型是int fun(int mu)，那么就可以在a.c中声明extern int fun（int mu），然后就能使用fun来做任何事情。就像变量的声明一样，extern int fun（int mu）可以放在a.c中任何地方，而不一定非要放在a.c的文件作用域的范围中。对其他模块中函数的引用，最常用的方法是包含这些函数声明的头文件。
3.  **此外，extern修饰符可用于指示C或者C++函数的调用规范**。比如在C++中调用C库函数，就需要在C++程序中用extern “C”声明要引用的函数。这是给链接器用的，告诉链接器在链接的时候用C函数规范来链接。主要原因是C++和C程序编译完成后在目标代码中命名规则不同。

### 2、说一下C++和C的区别 ###

参考回答：

① 设计思想上

C++是面向对象的语言，而C是面向过程的结构化编程语言。

② 语法上

C++具有重载、继承和多态三种特性。

C++相比C，增加多许多类型安全的功能，比如强制类型转换。

C++支持范式编程，比如模板类、函数模板等。

### 3、说一说 c++ 中[四种强转类型转换][Link 7]。 ###

参考答案：

C++中四种类型转换是：static\_cast、 dynamic\_cast,、const\_cast、reinterpret\_cast。

① const\_cast

一般用于指针转换。

① 可以将 const 指针转为非 const 指针。

② 可以将const引用转换为非const引用。

② static\_cast

用于各种隐式转换，转换之前，要先将类型转换为void\*，再转换成其他类型，比如非 const 转 const，void\*转指针等, static\_cast 能用于多态向上转化，如果向下转能成功但是不安全，结果未知，因为没有动态类型检查；

③ dynamic\_cast

用于动态类型转换。**只能用于含有虚函数的类**，用于类层次间的向上和向下转化。**只能转指针或引用**。向下转化时，如果是非法的对于指针返回 NULL，对于引用抛异常。

向上转换：指的是子类向基类的转换

向下转换：指的是基类向子类的转换

它通过判断在执行到该语句的时候变量的运行时类型和要转换的类型是否相同来判断是否能够进行向下转换。

④ reinterpret\_cast

几乎什么都可以转，比如将 int 转指针，可能会出问题，尽量少用；

注：为什么不使用 C 的强制转换？

C的强制转换表面上看起来功能强大什么都能转，但是转化不够明确，不能进行错误检查，容易出错。

### 4、请说一下 C/C++ 中指针和引用概念及其区别？ ###

参考答案：

**定义：**

① 引用

引用就是 C++对 C语言的重要扩充。引用就是某一变量的一个别名，对引用的操作与对变量直接操作完全一样。

引用的声明方法：类型标识符 &引用名=目标变量名；

引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似，只是用&代替了\*。

引用使用注意事项：

*  引用必须被初始化；
 *  引用不能改变绑定的对象；
 *  引用只有一级；

② 指针

指针利用地址，它的值直接指向存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。

指针使用注意事项：

*  初始化时要置空；
 *  使用时要考虑指向对象边界问题；
 *  不能对未初始化的指针取值或赋值；
 *  释放时要置空；
 *  如果返回动态分配内存或对象，必须使用指针；

区别：

1.  指针是一个实体，需要分配内存空间。引用只是变量的别名，不需要分配内存空间；
2.  使用 sizeof 看一个指针的大小是 4，而引用则是被引用对象的大小；
3.  指针可以被初始化为 NULL，而引用必须被初始化且必须是一个已有对象的引用；
4.  作为参数传递时，指针需要被解引用才可以对对象进行操作，而直接对引用的修改都会改变引用所指向的对象；
5.  指针在使用中可以指向其它对象，但是引用只能是一个对象的引用，不能被改变；
6.  指针可以有多级指针（\*\*p），而引用至多一级；
7.  指针和引用使用自增运算符的意义不一样；（指针是指向下一个空间，引用时引用的变量值加1）
8.  如果返回动态内存分配的对象或者内存，必须使用指针，引用可能引起内存泄露。

### 5、请你说一下你理解的 c++ 中的[四个智能指针][Link 8]。 ###

参考答案：

C++里面的四个智能指针: auto\_ptr、shared\_ptr、weak\_ptr、unique\_ptr（其中后三个是 c++11 支持，第一个已经被 11 弃用）

为什么要使用智能指针？

智能指针的作用是管理一个指针，因为存在以下这种情况：申请的空间在函数结束时忘记释放，造成内存泄漏。使用智能指针可以很大程度上的避免这个问题，因为智能指针就是一个类，当超出了类的作用域是，类会自动调用析构函数，析构函数会自动释放资源。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。

① auto\_ptr（c++98 的方案，cpp11 已经抛弃）

auto\_ptr用于管理通过new表达式获取的对象，并在auto\_ptr本身被销毁时删除该对象。

采用所有权模式。

auto\_ptr< string> p1 (new string ("I reigned lonely as a cloud.”));  
auto\_ptr<string> p2;  
p2 = p1; //auto\_ptr 不会报错.

此时不会报错，p2 剥夺了 p1 的所有权，但是当程序运行时访问 p1 将会报错。所以 auto\_ptr 的缺点是：存在潜在的内存崩溃问题！（一个内存空间，释放了两次）

② unique\_ptr（替换 auto\_ptr）

unique\_ptr 实现独占式拥有或严格拥有概念，保证同一时间内只有一个智能指针可以指向该对象。它对于避免资源泄露(例如“以 new 创建对象后因为发生异常而忘记调用 delete”)特别有用。

采用所有权模式，还是上面那个例子

> unique\_ptr<string> p3 (new string ("auto")); //\#4  
> unique\_ptr<string> p4； //\#5  
> p4 = p3;//此时会报错！！

编译器认为 p4=p3 非法，避免了 p3 不再指向有效数据的问题。因此，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 。

注：如果确实想执行类似与\#1 的操作，要安全的重用这种指针，可给它赋新值。C++有一个标准库函数std::move()，让你能够将一个 unique\_ptr 赋给另一个。例如：

> unique\_ptr<string> ps1, ps2;  
> ps1 = demo("hello");  
> ps2 = move(ps1);  
> ps1 = demo("alexia");  
> cout << \*ps2 << \*ps1 << endl;

③ shared\_ptr

shared\_ptr 实现共享式拥有概念。多个智能指针可以指向相同对象，该对象和其相关资源会在“最后一个引用被销毁”时候释放。从名字 share 就可以看出了资源可以被多个指针共享，它使用计数机制来表明资源被几个指针共享。可以通过成员函数 use\_count()来查看资源的所有者个数。除了可以通过 new 来构造，还可以通过传入auto\_ptr, unique\_ptr,weak\_ptr 来构造。当我们调用 release()时，当前指针会释放资源所有权，计数减一。当计数等于 0 时，资源会被释放。  
shared\_ptr 是为了解决 auto\_ptr 在对象所有权上的局限性(auto\_ptr 是独占的), 在使用引用计数的机制上提供了可以共享所有权的智能指针。

成员函数：

>  *  use\_count 返回引用计数的个数
>  *  unique 返回是否是独占所有权( use\_count 为 1)
>  *  swap 交换两个 shared\_ptr 对象(即交换所拥有的对象)
>  *  reset 放弃内部对象的所有权或拥有对象的变更, 会引起原有对象的引用计数的减少，get 返回内部对象(指针)，由于已经重载了方法, 因此和直接使用对象是一样的.如 shared\_ptr<int> sp(newint(1)); sp 与 sp.get()是等价的。

④ weak\_ptr

weak\_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared\_ptr 管理的对象，进行该对象的内存管理的是那个强引用的 shared\_ptr.。weak\_ptr 只是提供了对管理对象的一个访问手段。weak\_ptr 设计的目的是为配合shared\_ptr 而引入的一种智能指针来协助 shared\_ptr 工作, 它只可以从一个 shared\_ptr 或另一个 weak\_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。weak\_ptr 是用来解决 shared\_ptr 相互引用时的死锁问题,如果说两个 shared\_ptr 相互引用,那么这两个指针的引用计数永远不可能下降为 0,资源永远不会释放。它是对对象的一种弱引用，不会增加对象的引用计数，和 shared\_ptr 之间可以相互转化，shared\_ptr 可以直接赋值给它，它可以通过调用 lock 函数来获得 shared\_ptr。

class B;
    class A
    {
    public:
        shared_ptr<B> pb_;
        ~A()
        {
            cout<<"A delete\n";
        }
    };
    class B
    {
    public:
        shared_ptr<A> pa_;
        ~B()
        {
            cout<<"B delete\n";
        }
    };
    void fun()
    {
        shared_ptr<B> pb(new B());
        shared_ptr<A> pa(new A());
        pb->pa_ = pa;
        pa->pb_ = pb;
        cout<<pb.use_count()<<endl;
        cout<<pa.use_count()<<endl;
    }
    int main()
    {
        fun();
        return 0;
    }

可以看到 fun 函数中 pa ，pb 之间互相引用，两个资源的引用计数为 2，当要跳出函数时，智能指针 pa，pb 析构时两个资源引用计数会减一，但是两者引用计数还是为 1，导致跳出函数时资源没有被释放（A B 的析构函数没有被调用），如果把其中一个改为 weak\_ptr 就可以了，我们把类 A 里面的 shared\_ptr pb\_; 改为 weak\_ptr pb\_; 运行结果如下，这样的话，资源 B 的引用开始就只有 1，当 pb 析构时，B 的计数变为 0，B 得到释放，B释放的同时也会使 A 的计数减一，同时 pa 析构时使 A 的计数减一，那么 A 的计数为 0，A 得到释放。  
注意的是我们不能通过 weak\_ptr 直接访问对象的方法，比如 B 对象中有一个方法 print(),我们不能这样访问，

pa->pb\_->print();

英文 pb\_是一个 weak\_ptr，应该先把它转化为 shared\_ptr,如：

shared\_ptr p = pa->pb\_.lock();p->print();

### 6、请回答一下数组和指针的区别。 ###

参考答案：

指针和数组的主要区别如下：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2MDc5MDkz_size_16_color_FFFFFF_t_70][]

### 7、请你回答一下野指针是什么？ ###

参考答案：

野指针就是指向一个已释放的内存或者无访问权限的内存区域的指针。

### 8、请你回答一下智能指针有没有内存泄露的情况 ###

参考答案：

当两个对象相互使用一个 shared\_ptr 成员变量指向对方，会造成循环引用，使引用计数失效，从而导致内存泄漏。

### 9、请你来说一下智能指针的内存泄漏如何解决 ###

参考答案：

为了解决循环引用导致的内存泄漏，引入了 weak\_ptr 弱指针，weak\_ptr 的构造函数不会修改引用计数的值，从而不会对对象的内存进行管理，其类似一个普通指针，但不指向引用计数的共享内存，但是其可以检测到所管理的对象是否已经被释放，从而避免非法访问。

### 10、请你回答一下为什么析构函数必须是虚函数？为什么 C++ 默认的析构函数不是虚函数（考点: 虚函数  析构函数） ###

参考答案：

① 一般将基类的析构函数设置为虚函数，当我们new一个子类对象，并用基类指针指向子类对象时，避免释放基类指针后，而未释放子类对象的空间，防止内存泄漏。

② 首先，默认的析构函数所在的类一般不会被其他类继承，而且虚函数需要额外的虚函数表和虚表指针，会占用额外的内存。所以默认构造函数不是虚函数。

### 11、请你来说一下函数指针 ###

参考答案：

① 定义：函数指针是一个指向函数首地址的指针变量。

C在编译时，每一个函数都有一个人口地址，函数指针指向的就是这个人口地址。有了函数指针，可以通过指针来调用函数。就向指针数组一样。

② 用途：

调用函数和做函数的参数，比如回调函数。

③ 示例：

char\*   fun(char \* p)  \{…\};    // 普通函数 fun

char\*   (\*pf)(char \* p);          // 函数指针 pf

pf = fun;   // 函数指针 pf 指向函数 fun

pf(p);        // 通过函数指针 pf 调用函数 fun

### 12、请你来说一下 fork 函数 ###

参考答案：

fork：创建一个和当前进程映像一样的进程可以通过 fork( )系统调用；

相关头文件：

\#include <sys/types.h>  
\#include <unistd.h>  
函数原型： pid\_t  fork(void);

成功调用 fork( )会创建一个新的进程，它几乎与调用 fork( )的进程一模一样，这两个进程都会继续运行。

返回值：

*  在子进程中，成功的 fork( )调用会返回 0。
 *  在父进程中 fork( )返回子进程的 pid。
 *  如果出现错误，fork( )返回一个负值。

最常见的 fork( )用法是创建一个新的进程，然后使用 exec( )载入二进制映像，替换当前进程的映像。这种情况下，派生（fork）了新的进程，而这个子进程会执行一个新的二进制可执行文件的映像。这种“派生加执行”的方式是很常见的。

在早期的 Unix 系统中，创建进程比较原始。当调用 fork 时，内核会把所有的内部数据结构复制一份，复制进程的页表项，然后把父进程的地址空间中的内容逐页的复制到子进程的地址空间中。但从内核角度来说，逐页的复制方式是十分耗时的。现代的 Unix 系统采取了更多的优化，例如 Linux，采用了[写时复制][Link 9]的方法，而不是对父进程空间进程整体复制。

### 13、请你来说一下 C++ 中析构函数的作用 ###

参考答案：

析构函数与构造函数对应，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统会自动执行析构函数，释放动态开辟的内存空间，防止内存泄漏。

注： 类调用析构函数顺序：1）子类本身的析构函数；2）对象成员析构函数；3）基类析构函数。

### 14、请你来说一下静态函数和虚函数的区别 ###

参考答案：

静态函数在编译的时候就已经确定运行时机（即**编译时**确定函数的入口地址），虚函数在**运行**的时候**动态绑定**。虚函数因为用了虚函数表机制，调用的时候会增加一次内存开销。

### 15、请你来说一说重载和覆盖。 ###

参考答案：

重载：其是对于一个类而言的，在类中，两个函数的函数名相同，参数列表不同（参数类型或个数），返回值无要求。

覆盖：前提是子类继承父类，在父类中，有一个虚函数，然后在子类中重新定义了这个函数，这就构成了覆盖。

补充：

隐藏：前提也是子类继承父类，分为两种情况。

① 父类函数和子类函数名相同，但是参数不同，这时父类同名函数有无virtual修饰，都构成隐藏，即子类指针调用同名函数，调用的是子类的函数，父类函数被隐藏。

②父类函数和子类函数名相同，参数也相同，且父类同名函数无virtual修饰。

### 16、请你说一说 strcpy 和 和 strlen。 ###

参考答案：

strcpy 是字符串拷贝函数，原型：char \*strcpy(char\* dest, const char \*src);

从 src 逐字节拷贝到 dest，直到遇到'\\0'结束，因为没有指定长度，可能会导致拷贝越界，造成缓冲区溢出漏洞，安全版本是 strncpy 函数。

strlen 函数是计算字符串长度的函数，返回从开始到'\\0'之间的字符个数。

### 17、请你来回答一下++i  和 i++。 ###

参考答案：

\++i 先自增 1，再返回，i++先返回 i，再自增 1。

### 18、请你说一说你理解的虚函数和多态。 ###

参考答案：

多态的实现主要分为**静态多态**和**动态多态**，静态多态主要是**重载**，在编译的时候就已经确定，**静态绑定**；动态多态是用**虚  
函数机制**实现的，在运行期间**动态绑定**。

**举个栗子：**一个父类类型的指针指向一个子类对象时候，使用父类的指针去调用子类中重写了的父类中的虚函数的时候，会调用子类重写过后的函数，在父类中声明为加了 virtual关键字的函数，在子类中重写时候不需要加 virtual 也是**虚函数**。

虚函数的实现：在有虚函数的类中，类的最开始部分是一个虚函数表的指针，这个指针指向一个虚函数表，表中放了虚函数的地址，实际的虚函数在代码段(.text)中。当子类继承了父类的时候也会继承其虚函数表，当子类重写父类中虚函数时候，会将其继承到的虚函数表中的地址替换为重新写的函数地址。使用了虚函数，会增加访问内存开销，降低效率。

### 19、请你来说一说++i 和 i++ 的实现。 ###

参考答案：

**① ++i 的实现**

int & int::operator++()  
\{  
    \*this += 1;  
    return \*this;  
\}

**② i++的实现**

const int int::operator(int)  
\{  
    int oldvalue = \*this;  
    ++(\*this);  
    return oldvalue;  
\}

### 20、请你来写个函数在 main  函数执行前先运行。 ###

参考答案：

①

编译器：VC++6.0

语言：C

代码：

\#include<stdio.h>

int main()  
\{  
    printf("main\\n");  
    return 0;  
\}

int before\_main()  
\{  
    printf("before\_main\\n");  
    return 0;  
\}

typedef int func();  
\#pragma data\_seg(".CRT$XIU")    //用\#pragma data\_seg建立一个新的数据段并定义共享数据  
static func \* before\[\] = \{ before\_main \};  //定义一个函数数组，数组放的是函数的入口地址

②

编译器：VC++6.0

语言：C++

代码：

\#include<iostream>

using namespace std;

int before\_main()  
\{  
    cout<<"before\_main() called"<<endl;  
    return 0;  
\}

int g\_Value = before\_main();

int main()  
\{  
    cout<<"main() called"<<endl;  
    return 0;  
\}

### 21、以下四行代码的区别是什么？ ###

const char \* arr ="123";

char \* brr = "123";

const char crr\[\] ="123";

char drr\[\] = "123";

参考答案：

const char \* arr = "123";  
//字符串 123 保存在常量区，const 本来是修饰 arr 指向的值不能通过 arr 去修改，但是字符串“123”在常量区，本来就不能改变，所以加不加 const 效果都一样。

char \* brr = "123";  
//字符串 123 保存在常量区，这个 arr 指针指向的是同一个位置，同样不能通过 brr 去修改"123"的值。

const char crr\[\] = "123";  
//这里 123 本来是在栈上的，但是编译器可能会做某些优化，将其放到常量区。

char drr\[\] = "123";  
//字符串 123 保存在栈区，可以通过 drr 去修改。

### 22、请你来说一下 C++ 里是怎么定义常量的？常量存放在内存的哪个位置？ ###

参考答案：

常量在 C++里的定义就是一个const 加上对象类型，常量定义必须初始化。

对于局部对象，常量存放在栈区。

对于全局对象，编译期一般不分配内存，常量存放在全局/静态存储区。

对于字面值常量，比如字符串，存放在常量存储区。

### 23、请你来回答一下 const  修饰成员函数的目的是什么？ ###

参考答案：

const 修饰的成员函数表明函数调用不会对对象做出任何更改，事实上，如果确认不会对对象做更改，就应该为函数加上 const 限定，这样无论 const 对象还是普通对象都可以调用该函数。

补充：

【const与函数重载】  
第一种情况：const修饰非指针（引用）形参  
void func(int i);  
void func(const int i);  
编译error：函数重定义。

第二种情况：const修饰指针（引用）形参  
void func(char \* a);  
void func(const char \* a);  
编译OK，可重载。

第三种情况：实际与第一种相同  
void func(char \* a);  
void func( char \* const a);  
编译error：函数重定义。

第四种情况：修饰类成员函数  
class CBase  
\{  
void func();  
void func( )const;  
\}  
编译OK，可重载。  
解释：成员函数隐含this指针。

### 24、请你来说一说隐式类型转换。 ###

参考答案：

首先，对于内置类型，低精度的变量给高精度变量赋值会发生隐式类型转换，低精度类型会转化为高精度类型。其次，对于只存在单个参数的构造函数的对象构造来说，函数调用可以直接使用该参数传入，编译器会自动调用其构造函数生成临时对象。

### 25、请你来说一说 C++函数栈空间的最大值 ###

参考答案：

Windows 默认是 2 M，不过可以调整。

Linux 默认是 8 M，不过可以调整。

### 26、  请你来说一说 extern“C” ###

参考答案：

C++调用 C函数需要 extern C，因为 C 语言没有函数重载。

### 27、请你回答一下 [new/delete与 与 malloc/free  的区别][new_delete_ _ malloc_free]。 ###

参考答案：

首先，new/delete 是 C++的关键字，而 malloc/free 是 C语言的库函数，后者使用必须指明申请内存空间的大小，对于类类型的对象，后者不会调用构造函数和析构函数。

下图引用自：[https://blog.csdn.net/cmm0401/article/details/77206594][new_delete_ _ malloc_free]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2MDc5MDkz_size_16_color_FFFFFF_t_70 1][]

### 28、请你说说你了解的[RTTI][]。 ###

参考答案：

RTTI (Run Time Type Identification) 指的是运行时类型识别。程序能够使用基类的指针或引来检查这些指针或引用所指的对象的实际派生类型。

RTTI提供了两个非常有用的操作符：**typeid** 和 **dynamic\_cast**。

① **typeid操作符：**返回指针和引用所指的实际类型，返回类型为 type\_info。

关于 typeid 的注意事项：

*  typeid 返回一个 type\_info 的对象引用。
 *  如果想通过基类的指针指向派生类的数据类型，基类就必须要带有虚函数，否则，在使用typeid 时，就只能返回定义时所使用的数据类型。
 *  typeid 只能获取对象的实际类型，即便这个类含有虚函数，也只能判断当前对象是基类还是派生类，而不能判断当前指针是基类还是派生类。

② **dynamic\_cast操作符：**将基类类型的指针或引用安全地转换为其派生类类型的指针或引用。

关于 dynamic\_cast 的注意事项：

*  只能应用与指针和引用的转换，即只能转化为某一个类型的指针或某一个类型的引用，而不能是某类型本身。
 *  要转化的类型中必须包含虚函数，如果没有虚函数，转换就会失败。
 *  如果转换成功，返回子类的地址，如果转换失败，返回NULL。

### 29、请你说说虚函数表具体是怎样实现运行时多态的? ###

参考答案：

对于存在虚函数的基类的对象，基类对象的头部存放指向虚函数表的指针，子类若重写基类的虚函数，对应虚函数表中，该函数的地址会被重写的子类函数的地址替换。

### 30、请你说说 C 语言中是怎么进行[函数调用][Link 10]的？ ###

参考答案：

每一个函数调用都会分配函数栈，在栈内进行函数执行过程。调用前，先把返回地址压栈，然后把当前函数的堆栈指针（ESP）压栈。

### 31、请你说说 C 语言参数压栈顺序？ ###

参考答案：

根据参数列表从右向左依次压栈。

### 32、请你说说 C++ 如何处理返回值？ ###

参考答案：

生成一个临时变量，把它的引用作为函数参数传入函数内。

### 33、请你回答一下 C++ 中拷贝构造函数的形参能否进行值传递？ ###

参考答案：

不能。如果是值传递的话，调用拷贝构造函数时，首先将实参传给形参，这样又会调用拷贝构造函数，如此，会造成无限递归调用拷贝构造函数。

### 34、请你回答一下 malloc 与 new 的区别。 ###

参考答案：

malloc：本身是一个函数，需要知道申请内存的大小，返回的指针需要强转。

new：本身不是函数，是一个关键字，不用指定申请内存大小，动态开辟空间，返回指针不用强转。

### 35、请你说一说select。 ###

参考答案：

函数原型： int select ( int maxfdp1, fd\_set \*readset, fd\_set \*writeset, fd\_set \*exceptset, const struct timeval \*timeout )

select 在使用前，先将需要监控的描述符对应的 bit 位置 1，然后将其传给 select,当有任何一个事件发生时，select 将会返回所有的描述符，需要在应用程序自己遍历去检查哪个描述符上有事件发生，效率很低，并且其不断在内核态和用户态进行描述符的拷贝，开销很大。

## ##

### 补充： [select总结][select] ###

### 36、请你说说 fork，wait，exec 函数。 ###

参考答案：

父进程产生子进程使用 fork 拷贝出来一个父进程的副本，此时只拷贝了父进程的页表，两个进程都读同一块内存，当有进程写的时候使用写实拷贝机制分配内存，exec 函数可以加载一个 elf 文件去替换父进程，从此父进程和子进程就可以运行不同的程序了。fork 从父进程返回子进程的 pid，从子进程返回 0，调用了 wait 的父进程将会发生阻塞，直到有子进程状态改变,执行成功返回 0，错误返回-1。exec 执行成功则子进程从新的程序开始运行，无返回值，执行失败返回-1。

# 二、STL容器和算法 #

### 37、请你来说一下 map 和 和 set  有什么区别，分别又是怎么实现的？ ###

参考答案：

**实现机制：**map 和 set 都是 C++的关联容器，其底层实现都是红黑树（RB-Tree）。由于 map 和 set 所开放的各种操作接口，RB-tree 也都提供了，所以几乎所有的 map 和 set 的操作行为，都只是转调 RB-tree 的操作行为。

**map 和 set 区别在于：**

**①**  map 中的元素是 key-value（关键字—值）对：关键字起到索引的作用，值则表示与索引相关联的数据；set 与之相对就是关键字的简单集合，set 中每个元素只包含一个关键字key。

**②**  set 的迭代器是 const 的，不允许修改元素的值；map 允许修改 value，但不允许修改 key。其原因是因为map 和 set 是根据关键字排序来保证其有序性的。

**对于set**，如果允许修改 key 的话，那么首先需要删除该键，然后调节平衡，再插入修改后的键值，调节平衡，如此一来，严重破坏了 map 和 set 的结构，导致 iterator 失效，不知道应该指向改变前的位置，还是指向改变后的位置。所以 STL 中将 set 的迭代器设置成 const，不允许修改迭代器的值；

**对于map**，map 的迭代器则不允许修改 key 值，允许修改 value 值。

**③**  map 支持下标操作，set 不支持下标操作。map 可以用 key 做下标，map 的下标运算符\[ \]将关键码作为下标去执行查找，如果关键码不存在，则插入一个具有该关键码和 mapped\_type 类型默认值的元素至 map 中，因此下标运算符\[ \]在 map 应用中需要慎用，const\_map 不能用，只希望确定某一个关键值是否存在而不希望插入元素时也不应该使用，mapped\_type 类型没有默认值也不应该使用。如果 find 能解决需要，尽可能用 find。

### 38、请你来介绍一下 STL 的 的 allocaotr（空间配置器）。 ###

参考答案：

STL 的空间配置器用于封装 STL 容器在内存管理上的底层细节。在 C++中，其内存配置和释放如下：

new 运算分两个阶段：

(1) 调用 operator new 配置内存;

(2) 调用对象构造函数构造对象内容

delete 运算分两个阶段：

(1) 调用对象析构函数；

(2) 调用 operator delete 释放内存

为了精密分工，STL allocator 将两个阶段操作区分开来：

*  内存配置由 alloc::allocate()函数负责，内存释放由alloc::deallocate()函数负责；
 *  对象构造由::construct()函数负责，对象析构由::destroy()函数负责。

同时为了提升内存管理的效率，减少申请小内存造成的内存碎片问题，SGI STL 采用了两级空间配置器。

*  当分配的空间大小超过 128B 时，会使用第一级空间配置器；
 *  当分配的空间大小小于 128B 时，将使用第二级空间配置器。

第一级空间配置器直接使用 malloc()、realloc()、free()函数进行内存空间的分配和释放，而第二级空间配置器采用了内存池技术，通过空闲链表来管理内存。

## ##

### 39、请你讲讲 STL  有什么基本组成？他们之间的关系是怎样的？ ###

参考答案：

STL 主要由：以下六部分组成：  
①容器 ② 迭代器 ③ 仿函数 ④ 算法 ⑤ 分配器 ⑥ 配接器

他们之间的关系：

**分配器：**给**容器**分配存储空间。

**算法：**通过**迭代器**获取**容器**中的内容。

**仿函数：**可以协助**算法**完成各种操作。

**配接器：**用来套接适配**仿函数。**

### 40、请你说一说 STL  中 map 数据的存放形式。 ###

参考答案：

对于map，数据以红黑树形式存放。

补充：

对于unordered\_map，数据以哈希表形式存放。

### 41、请你说说 STL 中 map 与 与 unordered\_map ###

参考答案：

① Map 映射，map 的所有元素都是 **pair**，同时拥有**键值**（key）和**实值**（value）。pair 的第一元素被视为键值，第二元素被视为实值。所有元素都会根据元素的键值自动被排序。**不允许键值**重复。

底层实现：红黑树

适用场景：有序键值对不重复映射

② Multimap

多重映射。multimap 的所有元素都是 pair，同时拥有实值（value）和键值（key）。pair 的第一元素被视为键值，第二元素被视为实值。所有元素都会根据元素的键值自动被排序。允许键值重复。

底层实现：红黑树

适用场景：有序键值对可重复映射

### 42、请你说一说 vector  和 list  的区别，应用，越详细越好 ###

参考答案：

1、概念：

1）Vector

连续存储的容器，动态数组，在堆上分配空间。

底层实现：数组

两倍容量增长：  
vector 增加（插入）新元素时，如果未超过当时的容量，则还有剩余空间，那么直接添加到最后（插入指定位置），然后调整迭代器。如果没有剩余空间了，则会重新配置原有元素个数的两倍空间，然后将原空间元素通过复制的方式初始化新空间，再向新空间增加元素，最后析构并释放原空间，之前的迭代器会失效。

性能

访问：O(1)

插入：在最后插入（空间够）：很快

在最后插入（空间不够）：需要内存申请和释放，以及对之前数据进行拷贝。

在中间插入（空间够）：内存拷贝

在中间插入（空间不够）：需要内存申请和释放，以及对之前数据进行拷贝。

删除：在最后删除：很快

在中间删除：内存拷贝

适用场景：经常随机访问，且不经常对非尾节点进行插入删除。

2）List

动态链表，在堆上分配空间，每插入一个元数都会分配空间，每删除一个元素都会释放空间。

底层：双向链表

性能  
访问：随机访问性能很差，只能快速访问头尾节点。  
插入：很快，一般是常数开销  
删除：很快，一般是常数开销

适用场景：经常插入删除大量数据

2、区别：

1）vector 底层实现是数组；list 是双向 链表。  
2）vector 支持随机访问，list 不支持。  
3）vector 是顺序内存，list 不是。  
4）vector 在中间节点进行插入删除会导致内存拷贝，list 不会。  
5）vector 一次性分配好内存，不够时才进行 2 倍扩容；list 每次插入新节点都会进行内存申请。  
6）vector 随机访问性能好，插入删除性能差；list 随机访问性能差，插入删除性能好。

3、应用

vector 拥有一段连续的内存空间，因此支持随机访问，如果需要高效的随即访问，而不在乎插入和删除的效率，使用 vector。

list 拥有一段不连续的内存空间，如果需要高效的插入和删除，而不关心随机访问，则应使用 list。

# 三、编译与底层 #

### 43、请你来说一下一个 C++ 源文件从文本到可执行文件经历的过程？ ###

参考答案：

对于 C++源文件，从文本到可执行文件一般需要四个过程：

预处理阶段：对源代码文件中文件包含关系（头文件）、预编译语句（宏定义）进行分析和替换，生成预编译文件。

**相关命令：gcc  -E  man.c  -o  main.i**

编译阶段：将经过预处理后的预编译文件转换成特定汇编代码，生成汇编文件。

**相关命令：gcc  -S  man.i  -o  main.s**

汇编阶段：将编译阶段生成的汇编文件转化成机器码，生成可重定位目标文件。

**相关命令：gcc  -c  man.s  -o  main.o**

链接阶段：将多个目标文件及所需要的库连接成最终的可执行目标文件。

**相关命令：gcc   man.o  -o  main**

### 44、请你来回答一下 include 头文件的顺序以及双引号”” 和尖括号<> 的区别。 ###

参考答案：

对于使用双引号包含的头文件，查找头文件路径的顺序为：

**当前头文件目录**→**编译器设置的头文件目录**→**系统变量指定的头文件路径**

对于使用尖括号包含的头文件，查找头文件的路径顺序为：

**编译器设置的头文件路径**→**系统变量指定的头文件路径**

[Link 1]: https://www.nowcoder.com/ta/review-c
[Link 2]: https://blog.csdn.net/qq_26079093/article/details/100023882
[Link 3]: https://blog.csdn.net/qq_26079093/article/details/100060370
[Link 4]: https://blog.csdn.net/qq_26079093/article/details/100046606
[Link 5]: https://blog.csdn.net/qq_26079093/article/details/100060547
[Link 6]: https://blog.csdn.net/qq_26079093/article/details/100060114
[const]: https://blog.csdn.net/lucky52529/article/details/89331013
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2t5NTI1Mjk_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/83da9b830d074db6a7db96a326e02adc.png
[_extern]: https://blog.csdn.net/qq_26079093/article/details/102542255
[Link 7]: https://blog.csdn.net/ydar95/article/details/69822540
[Link 8]: https://blog.csdn.net/qccz123456/article/details/80973228
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2MDc5MDkz_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/3fdb4245785d409fb6131f7d53b2f31b.png
[Link 9]: https://blog.csdn.net/qq_32131499/article/details/94561780
[new_delete_ _ malloc_free]: https://blog.csdn.net/cmm0401/article/details/77206594
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2MDc5MDkz_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/489794d1e19e463593c80cdbdbf9dc3f.png
[RTTI]: https://blog.csdn.net/weixin_34337265/article/details/86392595
[Link 10]: https://blog.csdn.net/weixin_41891854/article/details/80278688
[select]: https://www.cnblogs.com/Anker/archive/2013/08/14/3258674.html