-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathatom.xml
55 lines (32 loc) · 125 KB
/
atom.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title>Ninokz</title>
<subtitle>你干嘛，哎哟</subtitle>
<link href="https://ninokz.github.io/atom.xml" rel="self"/>
<link href="https://ninokz.github.io/"/>
<updated>2024-10-29T06:40:19.089Z</updated>
<id>https://ninokz.github.io/</id>
<author>
<name>Ninokz</name>
</author>
<generator uri="https://hexo.io/">Hexo</generator>
<entry>
<title>HelloWorld</title>
<link href="https://ninokz.github.io/2024/10/29/HelloWorld/"/>
<id>https://ninokz.github.io/2024/10/29/HelloWorld/</id>
<published>2024-10-29T06:39:22.229Z</published>
<updated>2024-10-29T06:40:19.089Z</updated>
<category term="Learning" scheme="https://ninokz.github.io/categories/Learning/"/>
</entry>
<entry>
<title>C++ Interview Record</title>
<link href="https://ninokz.github.io/2024/10/29/C++%20Interview%20Record/"/>
<id>https://ninokz.github.io/2024/10/29/C++%20Interview%20Record/</id>
<published>2024-10-29T06:27:44.971Z</published>
<updated>2024-10-29T08:03:46.134Z</updated>
<content type="html"><![CDATA[<h3 id="C-Summary"><a class="header-anchor" href="#C-Summary"></a>C++ Summary</h3><p>This markdown is a file which helps me to review cc for interview. 🤓</p><hr><h4 id="内存管理-🔧"><a class="header-anchor" href="#内存管理-🔧"></a>内存管理 🔧</h4><h5 id="图示"><a class="header-anchor" href="#图示"></a>图示</h5><figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line">|Text| low address //代码区（文本段）</span><br><span class="line">|---------------|</span><br><span class="line">|data|// 数据区</span><br><span class="line">|segment|</span><br><span class="line">|---------------|</span><br><span class="line">|HEAP|// 向高地址增长</span><br><span class="line">|---------------|</span><br><span class="line">| 空闲 |</span><br><span class="line">| 内存 |</span><br><span class="line">|---------------|</span><br><span class="line">|stack| high address // 向低地址增长</span><br></pre></td></tr></table></figure><p><strong>代码段</strong>：它包含可执行指令（机器代码），代码段通常是只读，即程序代码区</p><p><strong>数据段</strong>：</p><p><strong>初始化数据段</strong>：所有<strong>全局、静态static和常量数据</strong>都存储在数据段中，即静态存储区 .data (<code>const</code>变量虽然属于常量，但是本质还是变量，不存储于代码段)</p><p><strong>Data 段</strong>：</p><ul><li>分为 <strong>已初始化数据段</strong> 和 <strong>常量数据段</strong>。</li><li><strong>已初始化数据段</strong>：存储显式初始化为非 0 的全局变量和静态变量。</li><li><strong>常量数据段</strong>：存储只读的数据，如字符串字面量和 <code>const</code> 修饰的全局变量。</li></ul><p><strong>未初始化数据段</strong>：所有未初始化的全局变量和静态变量都存储在该段中，也称为BSS段.bss</p><p><strong>BSS 段</strong>：</p><ul><li>存储所有未显式初始化或初始化为 0 的全局变量和静态变量。</li><li>这些变量在程序运行时自动初始化为 0。</li><li>BSS 段在编译后的可执行文件中并不占用实际空间，因为它只记录了需要多少空间，而在程序运行时由操作系统分配和清零。</li></ul><p><strong>堆段</strong>：当程序在运行时使用<code>calloc</code>和<code>malloc</code>函数分配内存时，内存在堆中分配，向高地址增长<br><strong>栈段</strong>：栈用于存储<strong>局部变量</strong>、<strong>函数参数</strong>和其他与函数相关的信息，向低地址增长</p><h5 id="堆栈区别"><a class="header-anchor" href="#堆栈区别"></a>堆栈区别</h5><table><thead><tr><th></th><th>堆</th><th>栈</th></tr></thead><tbody><tr><td><strong>管理方式</strong></td><td>堆中资源由程序员控制（容易产生memory leak）</td><td>栈资源由编译器自动管理，无需手工控制</td></tr><tr><td><strong>内存管理机制</strong></td><td>系统有一个记录空闲内存地址的链表，当系统收到程序申请时，遍历该链表，寻找第一个空间大于申请空间的堆结点，删除空闲结点链表中的该结点，并将该结点空间分配给程序</td><td>只要栈的剩余空间大于所申请空间，系统为程序提供内存，否则报异常提示栈溢出</td></tr><tr><td><strong>空间大小</strong></td><td>堆是不连续的内存区域</td><td>栈是一块连续的内存区域</td></tr><tr><td><strong>碎片问题</strong></td><td>对于堆，频繁的new/delete会造成大量碎片，使程序效率降低</td><td>对于栈，它是有点类似于数据结构上的一个先进后出的栈，进出一一对应，不会产生碎片</td></tr><tr><td><strong>生长方向</strong></td><td>向高地址方向增长。</td><td>向低地址方向增长</td></tr><tr><td><strong>分配效率</strong></td><td>堆由C/C++函数库提供，效率低</td><td>栈是其系统提供的数据结构，<strong>计算机在底层对栈提供支持，效率高</strong></td></tr></tbody></table><h5 id="变量问题"><a class="header-anchor" href="#变量问题"></a>变量问题</h5><p><strong>作用域</strong>：</p><p>全局变量：全局作用域，可以通过extern作用于其他非定义的源文件。</p><p>静态全局变量 ：全局作用域+文件作用域，所以无法在其他文件中使用。只能在本源文件中使用</p><p>局部变量：局部作用域，函数内的变量等</p><p>静态局部变量 ：局部作用域，只被初始化一次，直到程序结束</p><p><strong>所在空间</strong>：</p><p>除了局部变量在栈上外，其他都在静态存储区</p><p><strong>生命周期</strong>：</p><p>局部变量在栈上，出了作用域就回收内存；而全局变量、静态全局变量、静态局部变量都在静态存储区，直到程序结束才会回收内存</p><p><strong>静态变量什么时候初始化</strong></p><p>C语言：全局和静态变量初始化发生在任何代码执行之前，属于编译期初始化。</p><p>C++标准规定：全局或静态对象当且仅当对象首次用到时才进行构造</p><p><strong>静态成员函数不能访问非静态成员</strong></p><p>静态成员函数不属于任何一个对象，因此<strong>C++规定静态成员函数没有this指针</strong>，只能访问静态成员，不能访问普通成员</p><table><thead><tr><th>区域名称</th><th>用途</th><th>内存管理</th><th>生命周期</th><th>典型存储内容</th></tr></thead><tbody><tr><td><strong>静态存储区</strong></td><td>存储全局变量、静态变量和常量</td><td>自动分配</td><td>从程序开始到结束</td><td>全局变量、静态变量、常量字符串</td></tr><tr><td><strong>栈区</strong></td><td>存储局部变量、函数参数和返回地址</td><td>自动分配和释放</td><td>函数调用期间</td><td>局部变量、函数参数、返回地址</td></tr><tr><td><strong>堆区</strong></td><td>动态内存分配</td><td>手动分配和释放</td><td>由程序员控制</td><td>动态分配的内存（如对象、数组）</td></tr><tr><td><strong>常量区</strong></td><td>存储程序代码和常量</td><td>自动分配</td><td>程序运行期间</td><td>字符串字面量、程序代码</td></tr></tbody></table><p><strong><code>static</code></strong></p><p><strong>隐藏</strong>：静态函数或静态全局变量只能在本源文件中使用</p><p><strong>持久性</strong>：在数据段分配内存，维护值直到程序结束</p><p><strong>默认值0</strong>：默认初始化为 0</p><h5 id="内存泄露"><a class="header-anchor" href="#内存泄露"></a>内存泄露</h5><p><code>new</code>和<code>malloc</code>申请资源使用后，没有用<code>delete</code>和<code>free</code>释放；子类继承父类时，父类析构函数不是虚函数；资源句柄未释放；智能指针<code>shared_ptr</code>形成环形引用，无法释放</p><h5 id="内存碎片"><a class="header-anchor" href="#内存碎片"></a>内存碎片</h5><h5 id="内存池"><a class="header-anchor" href="#内存池"></a>内存池</h5><h5 id="内存泄漏检测方法"><a class="header-anchor" href="#内存泄漏检测方法"></a>内存泄漏检测方法</h5><p>Windows上除了使用VS自带的性能检测窗口观察内存分配，还可以使用<code>_CrtDumpMemoryLeaks();</code>调试时输出窗口会输出内存泄漏的消息。</p><p>Linux上使用 Val grind</p><hr><h4 id="内存模型🍳"><a class="header-anchor" href="#内存模型🍳"></a>内存模型🍳</h4><h5 id="内存分区模型"><a class="header-anchor" href="#内存分区模型"></a>内存分区模型</h5><h5 id="内存顺序模型"><a class="header-anchor" href="#内存顺序模型"></a>内存顺序模型</h5><p><strong>概念</strong>：内存模型是描述编程语言在支持多线程编程中对共享内存访问的顺序,主要目的是为了确保在多线程环境中，程序行为是可预测的且一致的。</p><p>内存顺序模型是为了解决多线程程序中的内存一致性和可见性问题而引入的。在多线程环境下，不同线程可能同时访问和修改共享的内存，这会引发一系列并发性问题，如竞态条件、数据竞争等。内存顺序模型的目的是通过定义不同操作之间的执行顺序和可见性规则，来保证多线程程序的正确性和可预测性</p><blockquote><p>在多线程环境下，不同的线程可以同时访问和修改相同的内存位置。这种并发访问会导致**数据竞争（Data Race）<strong>和</strong>指令重排序（Instruction Reordering）**等问题。因此，需要一种机制来约束线程之间的内存访问顺序，这就是内存模型的核心任务</p><p>现代处理器和编译器为了优化性能，可能会对指令进行重排序（Out-of-Order Execution）或缓存一致性操作,在多线程环境下可能导致不可预期的行为,<strong>缓存效应（Cache Effects）<strong>与</strong>指令重排序（Instruction Reordering）</strong></p><ul><li><strong>缓存效应（Cache Effects）</strong>：一个线程的内存修改可能被暂时保存在其本地缓存中，而其他线程看到的仍然是旧值。</li><li><strong>指令重排序（Instruction Reordering）</strong>：编译器或CPU可能会改变指令的执行顺序以优化性能，这可能导致一个线程看到的内存操作顺序与另一个线程不一致。</li></ul></blockquote><p><strong>内存顺序</strong>：</p><p><strong>关系</strong></p><blockquote><p><strong>sequenced-before</strong></p><p>单线程下A指令序列先于B</p><p><strong>happens-before</strong></p><p>多线程下A指令序列先于B</p><p><strong>synchronizes-with</strong></p><p>线程修改某变量的之后的结果能被其它线程可见</p><p><strong>Carries dependency</strong></p><p>同一个线程内，表达式A sequenced-before 表达式B，并且表达式B的值是受表达式A的影响的一种关系</p></blockquote><p><strong>6种顺序</strong></p><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">enum</span> <span class="title class_">memory_order</span> {</span><br><span class="line"> memory_order_relaxed,<span class="comment">// no sync</span></span><br><span class="line"> memory_order_consume,<span class="comment">// message passing 执行于本操作之前的所有操作后</span></span><br><span class="line"> memory_order_acquire,<span class="comment">// message passing 执行于本操作之前的所有读操作后</span></span><br><span class="line"> memory_order_release,<span class="comment">// message passing 执行于本操作之前的所有写操作后</span></span><br><span class="line"> memory_order_acq_rel,<span class="comment">// message passing</span></span><br><span class="line"> memory_order_seq_cst<span class="comment">// total order</span></span><br><span class="line">};</span><br></pre></td></tr></table></figure><p>由上至下为宽松到严格</p><hr><h4 id="关键字-🔑"><a class="header-anchor" href="#关键字-🔑"></a>关键字 🔑</h4><h5 id="volatile-与mutable"><a class="header-anchor" href="#volatile-与mutable"></a><code>volatile </code>与<code>mutable</code></h5><ul><li>概念</li></ul><p><code>mutable</code>：被mutable修饰的变量，将永远处于可变的状态，即使处于<code>const</code>修饰</p><p><code>volatile </code>：关键字可以用来提醒编译器使用 volatile 声明的变量随时有可能改变，要求取内存读取值而非寄存器读取</p><p><code>volatile </code>主要有三个应用场景：</p><p>（1）外围设备的特殊功能寄存器。</p><p>（2）在中断服务函数中修改全局变量。</p><p>（3）在多线程中修改全局变量(多线程中修改全局变量存在什么问题？怎么解决?)</p><h5 id="const"><a class="header-anchor" href="#const"></a><code>const</code></h5><ul><li>概念</li></ul><p>对被修饰对象进行限定，在初始化后对象在后续过程中不能进行修改操作，类似于将其视作常量。4种修饰类型：修饰变量、修饰指针、修饰引用、修饰函数</p><p>对于局部常量，存放在栈区； 对于全局常量，编译期⼀般不分配内存，有时编译器会把放在符号表中以提⾼访问效率；字⾯值常量，⽐如字符串，放在常量区；</p><p><code>const </code>指针</p><p>底层const和顶层const</p><p><strong>顶层</strong>const：指的是const修饰的变量<strong>本身</strong>是一个常量，无法修改，指的是指针，就是 * 号的右边</p><p><strong>底层</strong>const：指的是const修饰的变量<strong>所指向的对象</strong>是一个常量，指的是所指变量，就是 * 号的左边</p><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="type">const</span> <span class="type">int</span> a = <span class="number">5</span>; <span class="comment">// 顶层const</span></span><br><span class="line"><span class="type">int</span> b = <span class="number">9</span>;</span><br><span class="line"></span><br><span class="line"><span class="type">const</span> <span class="type">int</span>* c = &a; <span class="comment">// 底层const, 指向对象不可更改</span></span><br><span class="line"><span class="type">int</span>* <span class="type">const</span> d = &b; <span class="comment">// 顶层const, 指针自身不能更改</span></span><br><span class="line"><span class="type">const</span> <span class="type">int</span>* <span class="type">const</span> e = &a; <span class="comment">// 前一个为底层const 后一个为顶层const</span></span><br></pre></td></tr></table></figure><p><strong>顶层const</strong>和<strong>底层const</strong>：从以下代码看出const修饰的影响，前者表示指针本身是常量（不可更改），后者表示指针所指对象是常量（对象不可更改）。通常意义上来讲顶层const的限制弱于底层 const。所以在进行拷贝操作时，<strong>顶层const基本上不受影响，而底层const的限制性更大</strong>，当进行拷贝考入考出时，左右对象必须是相同的底层const资格（因为执行对象拷贝时有限制，常量的底层const不能赋值给非常量的底层const）</p><p>需要记住<em><strong>const修饰对象将会导致一个不可更改的对象即可</strong></em>。对待这个东西我个人的处理看待方式就是，先搞清楚目标对象是什么样的const，然后再做处理，也许和指针引用搭配的时候是有点绕。在确定对象是在当前过程中readonly的，那么我们就应该对其const修饰，对于非内部数据的输入参数，应该将单纯的值类型<code>A a</code>更改为<code>const A& a</code>，避免了拷贝，同时避免了对其修改，提高了效率</p><h5 id="this"><a class="header-anchor" href="#this"></a><code>this</code></h5><ul><li>概念</li></ul><p>在类的非静态成员函数中，<code>this</code>指针是隐式可用的，它指向调用成员函数的对象实例。</p><p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mrow></mrow><mn>1</mn></msup></mrow><annotation encoding="application/x-tex">^{1}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141em;"></span><span class="mord"><span></span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span></span></span></span></span></span></span></span></span></span></span></span>在类<code>T</code>的成员函数内，<code>this</code>的类型是<code>T* const</code>。这意味着<code>this</code>是一个指向<code>T</code>类型的常量指针，你不能改变<code>this</code>指针的指向，即不能让<code>this</code>指向另一个对象，但可以修改这个对象的成员（除非成员是<code>const</code>）底层const。</p><p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mrow></mrow><mn>2</mn></msup></mrow><annotation encoding="application/x-tex">^{2}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141em;"></span><span class="mord"><span></span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span></span>在 const 成员函数中，<code>this</code>指针的类型是<code>const T* const</code>，这意味着你既不能改变<code>this</code>指针的指向，也不能通过<code>this</code>指针修改对象的成员</p><ul><li>补充</li></ul><p>1.可否delete this?</p><p><code>delete this</code> 是合法的，但是要非常小心使用。<code>delete this</code> 语句用于在对象的成员函数中释放该对象的内存，但这种操作需要确保在调用该语句之后，不再访问已释放的内存，否则会导致未定义的行为或程序崩溃</p><p>2.类的析构函数中<code>delete this</code>？</p><p>无限递归导致 stack overflow</p><p>3.<code>this</code>赋值<code>nullptr</code>后调用成员函数？</p><p>访问成员函数将导致未定义行为，唯一的例外是静态成员函数。静态成员函数不依赖于任何对象，因此不需要 <code>this</code> 指针。可以使用 <code>nullptr</code> 调用静态成员函数，因为静态成员函数不涉及对象的成员访问</p><h5 id="inline"><a class="header-anchor" href="#inline"></a><code>inline</code></h5><ul><li><strong>概念</strong></li></ul><p>内联函数是C++中的一种函数声明方式，它告诉（<strong>建议</strong>）编译器在调用函数时将函数的代码插入到调用处，而不是像普通函数那样通过跳转执行。这样做可以减少函数调用的开销，提高程序的执行效率。编译器不一定会遵循<code>inline</code>关键字，它可能会根据具体情况决定是否将函数内联。</p><p>优点：</p><p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mrow></mrow><mn>1</mn></msup></mrow><annotation encoding="application/x-tex">^{1}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141em;"></span><span class="mord"><span></span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span></span></span></span></span></span></span></span></span></span></span></span>内联函数同宏函数一样将在被调用处进行代码展开，省去了参数压栈、栈帧开辟与回收，结果返回等，从而提高程序运行速度。</p><p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mrow></mrow><mn>2</mn></msup></mrow><annotation encoding="application/x-tex">^{2}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141em;"></span><span class="mord"><span></span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span></span>内联函数相比宏函数来说，在代码展开时，会做安全检查或自动类型转换（同普通函数），而<strong>宏定义则不会</strong>。</p><p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mrow></mrow><mn>3</mn></msup></mrow><annotation encoding="application/x-tex">^{3}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141em;"></span><span class="mord"><span></span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">3</span></span></span></span></span></span></span></span></span></span></span></span>在类中声明同时定义的成员函数，自动转化为内联函数，因此内联函数可以访问类的成员变量，宏<strong>定义则不能</strong>。</p><p>缺点：</p><p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mrow></mrow><mn>1</mn></msup></mrow><annotation encoding="application/x-tex">^{1}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141em;"></span><span class="mord"><span></span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span></span></span></span></span></span></span></span></span></span></span></span>包括可能导致代码体积增加，因为函数的代码会被复制到每个调用处，以及可能增加编译时间</p><ul><li><strong>补充</strong></li></ul><h5 id="sizeof"><a class="header-anchor" href="#sizeof"></a><code>sizeof</code></h5><ul><li><strong>概念</strong></li></ul><p><code>sizeof(var)</code>返回变量所占大小、<code>sizeof(pointer)</code>返回4或者8，这个与编译对象目标平台有关，<code>sizeof(array)</code>返回 类型大小*数组长度</p><p><code>size_of</code>是在编译期在确定</p><p><code>sizeof(空结构体)</code> 在C中是0，在C++中是1。C++标准规定，不同的对象不能拥有相同的内存地址</p><p>对类进行<code>sizeof</code>，看类中函数是不是虚函数。如果不是虚函数，则结果是1,如果是虚函数，则大小是4或者8</p><h5 id="extern"><a class="header-anchor" href="#extern"></a><code>extern </code></h5><ul><li><strong>概念</strong></li></ul><p>被 extern 限定的函数或变量是 extern 类型的；被 <code>extern "C"</code> 修饰的变量和函数是按照 C 语言方式编译和链接的</p><h5 id="explict"><a class="header-anchor" href="#explict"></a><code>explict</code></h5><ul><li><strong>概念</strong></li></ul><p><code>explicit </code>修饰构造函数时，可以防止<strong>隐式转换和复制初始化</strong>；<code>explicit </code>修饰转换函数时，可以防止隐式转换</p><h5 id="cast"><a class="header-anchor" href="#cast"></a><code>?_cast</code></h5><ul><li><strong>概念</strong></li></ul><p>引入 <code>static_cast</code>、<code>dynamic_cast</code>、<code>const_cast</code>、<code>reinterpret_cast</code> 等类型转换关键字，主要是为了<strong>提供类型转换的安全性和可控性</strong>。与C语言中的传统类型转换（使用强制类型转换操作符 <code>(type)</code>）相比，这些关键字更加清晰、可读，并且在编译时提供更多的类型检查。</p><p>引入原因</p><p><strong>安全性</strong>:提供更严格的类型检查，避免类型转换中的潜在错误。在编译时检测类型转换的合法性，减少运行时错误。</p><p><strong>可读性</strong>:通过不同的关键字表示不同类型的转换，代码意图更明确。提高代码的可维护性，程序员可以更清晰地理解转换的目的和风险。</p><p><strong>控制性</strong>:允许程序员在不同的上下文中选择合适的转换类型。提供对类型转换过程的精细控制，避免滥用强制类型转换。</p><p><strong>兼容性</strong>:保持与旧代码和C语言代码的兼容性，同时引入更现代化的类型转换机制。</p><p>类型</p><ol><li><p><code>static_cast</code></p><p><code>static_cast</code>是最常用的类型转换形式，用于<strong>基本数据类型之间的转换</strong>，如整型和浮点型、指针类型之间的转换（只要它们是相关的类型），以及类层次结构中<strong>向上</strong>（子类指针或引用转换为基类指针或引用）的转换。</p></li><li><p><code>dynamic_cast</code></p><p><code>dynamic_cast</code>专门用于处理类的层次结构中的<strong>向下</strong>转换（基类指针或引用转换为派生类指针或引用），并在运行时检查类型的安全性。它要求至少有一个基类声明为虚拟的（即至少有一个虚函数）。</p></li><li><p><code>const_cast</code></p><p><code>const_cast</code>用于修改类型的<code>const</code>或<code>volatile</code>属性，比如将一个<code>const</code>指针转换为非<code>const</code>指针，允许修改所指向的数据。它不能改变非<code>const</code>对象的<code>const</code>性质，也不能改变对象的类型。</p></li><li><p><code>reinterpret_cast</code></p><p>用于进行任意类型的指针转换。通常用于底层、硬件相关或系统编程中，进行较低级别的类型转换。</p></li></ol><h5 id="struct-union-class"><a class="header-anchor" href="#struct-union-class"></a><code>struct</code> <code>union</code> <code>class</code></h5><ol><li>C++区别</li></ol><table><thead><tr><th>union</th><th>struct</th><th>class</th></tr></thead><tbody><tr><td>定义多个成员，使用一个</td><td>定义多个成员，使用多个</td><td>定义多个成员，使用多个</td></tr><tr><td>默认public</td><td>默认public</td><td>默认private</td></tr><tr><td>不可以定义模板参数</td><td>不可以定义模板参数</td><td>可以定义模板参数</td></tr></tbody></table><ol start="2"><li><p>C\C++\C#之间的<code>struct</code> 和 <code>class</code> 区别</p><p>C:<code>struct</code> 只能定义数据成员，不能包含成员函数\没有访问控制</p><p>C++:参见1.</p><p>C#:<code>struct</code> 是一种值类型，而 <code>class</code> 是一种引用类型，分配内存位置不同，前者不可继承</p></li><li><p><code>struct</code>字节对齐</p><p>为什么：许多硬件平台对特定类型的数据访问有最优的内存对齐要求。正确对齐的数据可以直接从内存读取，而<strong>未对齐的数据可能需要多次访问才能完成读取</strong>，这样会降低性能。</p><p>数据对齐：起始位置的偏移量必须是该变量类型大小的整数倍</p><ol><li>结构体变量的首地址是其最宽基本成员类型大小的整数倍。</li><li>结构体每个成员相对于结构体首地址的偏移量都是成员大小的整数倍。</li><li>结构体的总大小为结构体最宽基本成员类型大小的整数倍。</li></ol></li></ol><h5 id="new-delete-malloc-free"><a class="header-anchor" href="#new-delete-malloc-free"></a><code>new</code> <code>delete</code> <code>malloc</code> <code>free</code></h5><table><thead><tr><th>特性</th><th><code>new</code> / <code>delete</code></th><th><code>malloc</code> / <code>free</code></th></tr></thead><tbody><tr><td>语言支持</td><td>C++ 运算符</td><td>C 标准库函数，也可在 C++ 中使用</td></tr><tr><td>类型安全</td><td>类型安全，编译时进行类型检查</td><td>类型不安全，需要显式类型转换</td></tr><tr><td>构造函数调用</td><td><code>new</code> 分配内存并调用构造函数</td><td><code>malloc</code> 只分配内存，不调用构造函数</td></tr><tr><td>析构函数调用</td><td><code>delete</code> 调用析构函数并释放内存</td><td><code>free</code> 只释放内存，不调用析构函数</td></tr><tr><td>申请内存</td><td>无须指定内存块的大小，编译器会根据类型信息自行计算</td><td>显式地指出所需内存的大小</td></tr><tr><td>内存分配失败处理</td><td>抛出 <code>std::bad_alloc</code> 异常</td><td>返回 <code>nullptr</code></td></tr><tr><td>数组支持</td><td><code>new[]</code> 和 <code>delete[]</code> 提供数组分配和释放支持</td><td>需要手动计算大小和类型转换</td></tr><tr><td>使用语法</td><td>简洁，适用于对象和数组的分配</td><td>复杂，需要显式类型转换</td></tr><tr><td>内存对齐</td><td>自动处理内存对齐</td><td>取决于具体的实现，可能需要手动处理</td></tr><tr><td>性能和优化</td><td>通常更优化，特别是在处理复杂对象时</td><td>性能依赖于具体的标准库实现</td></tr><tr><td>运算符重载</td><td>支持运算符重载，自定义内存分配策略</td><td>不支持运算符重载</td></tr><tr><td>异常处理</td><td>提供异常处理机制</td><td>需要手动检查返回值并处理错误</td></tr><tr><td>代码示例</td><td><code>MyClass* obj = new MyClass(); delete obj; </code></td><td><code>MyClass* obj = (MyClass*)malloc(sizeof(MyClass)); free(obj); </code></td></tr><tr><td>返回类型</td><td><code>new</code>返回目标对象类型的指针</td><td><code>malloc</code>返回<code>void</code>的指针</td></tr></tbody></table><h5 id="NULL-nullptr"><a class="header-anchor" href="#NULL-nullptr"></a><code>NULL</code> <code>nullptr</code></h5><ul><li><strong>概念</strong></li></ul><p><strong><code>NULL</code></strong>：<code>NULL</code>通常被定义为整数<code>0</code>，或者是一个宏定义，如<code>#define NULL 0</code>或<code>#define NULL ((void*)0)</code>。它的实际类型可能因编译器而异。</p><p><strong><code>nullptr</code></strong>：<code>nullptr</code>是C++11引入的一个新的关键字，它表示一个指向任何类型的空指针。<code>nullptr</code>的类型是<code>std::nullptr_t</code>，可以隐式转换为任何指针类型。</p><h5 id="auto-decltype"><a class="header-anchor" href="#auto-decltype"></a><code>auto</code> <code>decltype</code></h5><ul><li><strong>概念</strong></li></ul><p>auto 和 decltype都是类型推断关键字；</p><p><code>auto</code> 关键字用于在变量声明时根据初始化表达式自动推导变量的类型。</p><p><code>decltype</code> 关键字用于从表达式中推导出类型，它不会对表达式求值，只是获取其类型</p><p><code>auto</code> 会去掉引用和顶层 <code>const</code>，<code>auto</code> 必须有一个初始化表达式。</p><p><code>decltype</code> 会保留表达式的引用和 <code>const</code> 属性，<code>decltype</code> 可以用于没有初始化表达式的场合。</p><h5 id="macro"><a class="header-anchor" href="#macro"></a>macro</h5><table><thead><tr><th></th><th>宏</th><th>const</th><th>inline</th><th>typedef</th></tr></thead><tbody><tr><td>定义</td><td>字符替换</td><td>常量声明</td><td>函数声明</td><td>定义新别名</td></tr><tr><td>内存</td><td>不分配内存</td><td>分配</td><td>\</td><td>\</td></tr><tr><td>处理</td><td>预处理器</td><td>编译器</td><td>编译器</td><td>编译器</td></tr><tr><td>安全检查</td><td>无</td><td>有</td><td>有</td><td>有</td></tr><tr><td>存储</td><td>代码段</td><td>数据段</td><td>\</td><td>\</td></tr><tr><td>阶段</td><td>预编译执行</td><td>编译阶段</td><td>编译阶段</td><td>编译阶段</td></tr></tbody></table><hr><h4 id="STL-📦"><a class="header-anchor" href="#STL-📦"></a>STL 📦</h4><h5 id="引入"><a class="header-anchor" href="#引入"></a>引入</h5><ul><li><h5 id="概念"><a class="header-anchor" href="#概念"></a>概念</h5></li></ul><p><strong>容器</strong>：数据结构，容器通过迭代器暴露其元素，使得算法可以操作这些元素</p><p><strong>迭代器</strong>：访问容器的泛型指针，让用户通过特定的接口访问容器的数据，不需要了解容器内部的底层数据结构</p><p><strong>算法</strong>：数据操作方式</p><p><strong>函数对象（仿函数）</strong>：函数对象是重载了函数调用操作符（<code>()</code>）的类实例。STL中的函数对象可以用作算法的某些操作，如定义比较行为（<code>less</code>，<code>greater</code>等），定义算法作用与容器的行为。</p><p><code>sort(a.begin(), a.end(),less<int>());</code></p><p><strong>适配器</strong>：可以修改或扩展迭代器、容器和仿函数的行为，使其能够以新的方式被算法使用或操作。(stack\queue)</p><p><strong>空间配置器</strong>：在更底层被容器使用来管理内存分配的，但它通常对于 STL 的使用者是透明的，除非需要自定义内存管理行为。<strong>【可以作为说是STL优化策略】</strong>【堆中申请内存】</p><p>容器以 class template 完成;<br>算法以 function templates 完成;<br>仿函数是一种将 operator() 重载的 class template;<br>迭代器是一种将 operator++ 和 operator* 等指针习惯常行为重载的 class template;<br>配接器中的 container adapter 和 iterator adapter 都是一种 class template, 而 function adapter.</p><h5 id="容器分类"><a class="header-anchor" href="#容器分类"></a>容器分类</h5><p><strong>概念</strong></p><p>1总览</p><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br></pre></td><td class="code"><pre><span class="line">STL:</span><br><span class="line"><span class="comment">//序列式容器: string,vector,array,deque,list,forward_list</span></span><br><span class="line"><span class="comment">//容器适配器: stack,queue,priority_queue</span></span><br><span class="line"><span class="comment">//关联式容器: </span></span><br><span class="line"><span class="comment">//红黑树结构：map,set,multimap,multiset</span></span><br><span class="line"><span class="comment">//哈希结构：unordered_map,unordered_set,unordered_multimap,unordered_multiset</span></span><br><span class="line"></span><br><span class="line">vector:可变大小数组</span><br><span class="line">deque:双端队列</span><br><span class="line">list:双向链表</span><br><span class="line">array:固定大小数组</span><br><span class="line">string:类似于vector但是专门保存字符</span><br><span class="line">forward_list:前向链表</span><br><span class="line"></span><br><span class="line">map:关联数组：key-value pair 有序</span><br><span class="line">set：只保存关键字的容器：key is value 有序</span><br><span class="line">mutilmap：关键字可重复出现</span><br><span class="line">mutilset：关键字可重复出现</span><br><span class="line"></span><br><span class="line">unordered_map:hash函数组织map 无序</span><br><span class="line">unordered_set:hash函数组织set 无序</span><br><span class="line">unordered_mutilmap:hash函数组织map 无序 关键字可重复出现</span><br><span class="line">unordered_mutilset:hash函数组织set 无序 关键字可重复出现</span><br></pre></td></tr></table></figure><p>2表格</p><table><thead><tr><th>容器</th><th>底层数据结构</th><th>时间复杂度</th><th>有无序</th><th>可不可重复</th><th>其他</th></tr></thead><tbody><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#array">array</a></td><td>数组</td><td>随机读改 O(1)</td><td>无序</td><td>可重复</td><td>支持随机访问</td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#vector">vector</a></td><td>数组</td><td>随机读改、尾部插入、尾部删除 O(1) 头部插入、头部删除 O(n)</td><td>无序</td><td>可重复</td><td>支持随机访问</td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#deque">deque</a></td><td>双端队列</td><td>头尾插入、头尾删除 O(1)</td><td>无序</td><td>可重复</td><td>一个中央控制器 + 多个缓冲区，支持首尾快速增删，支持随机访问</td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#forward_list">forward_list</a></td><td>单向链表</td><td>插入、删除 O(1)</td><td>无序</td><td>可重复</td><td>不支持随机访问</td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#list">list</a></td><td>双向链表</td><td>插入、删除 O(1)</td><td>无序</td><td>可重复</td><td>不支持随机访问</td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#stack">stack</a></td><td>deque / list</td><td>顶部插入、顶部删除 O(1)</td><td>无序</td><td>可重复</td><td>deque 或 list 封闭头端开口，不用 vector 的原因应该是容量大小有限制，<strong>扩容耗时</strong></td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#queue">queue</a></td><td>deque / list</td><td>尾部插入、头部删除 O(1)</td><td>无序</td><td>可重复</td><td>deque 或 list 封闭头端开口，不用 vector 的原因应该是容量大小有限制，<strong>扩容耗时</strong></td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#priority_queue">priority_queue</a></td><td>vector + max-heap</td><td>插入、删除 O(log2n)</td><td>有序</td><td>可重复</td><td>vector容器+heap处理规则</td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#set">set</a></td><td>红黑树</td><td>插入、删除、查找 O(log2n)</td><td>有序</td><td>不可重复</td><td></td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#multiset">multiset</a></td><td>红黑树</td><td>插入、删除、查找 O(log2n)</td><td>有序</td><td>可重复</td><td></td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#map">map</a></td><td>红黑树</td><td>插入、删除、查找 O(log2n)</td><td>有序</td><td>不可重复</td><td></td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#multimap">multimap</a></td><td>红黑树</td><td>插入、删除、查找 O(log2n)</td><td>有序</td><td>可重复</td><td></td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#unordered_set">unordered_set</a></td><td>哈希表</td><td>插入、删除、查找 O(1) 最差 O(n)</td><td>无序</td><td>不可重复</td><td></td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#unordered_multiset">unordered_multiset</a></td><td>哈希表</td><td>插入、删除、查找 O(1) 最差 O(n)</td><td>无序</td><td>可重复</td><td></td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#unordered_map">unordered_map</a></td><td>哈希表</td><td>插入、删除、查找 O(1) 最差 O(n)</td><td>无序</td><td>不可重复</td><td></td></tr><tr><td><a href="https://github.com/huihut/interview/tree/master/STL#unordered_multimap">unordered_multimap</a></td><td>哈希表</td><td>插入、删除、查找 O(1) 最差 O(n)</td><td>无序</td><td>可重复</td><td></td></tr></tbody></table><table><thead><tr><th>算法</th><th>底层算法</th><th>时间复杂度</th><th>可不可重复</th></tr></thead><tbody><tr><td><a href="http://www.cplusplus.com/reference/algorithm/find/">find</a></td><td>顺序查找</td><td>O(n)</td><td>可重复</td></tr><tr><td><a href="https://github.com/gcc-mirror/gcc/blob/master/libstdC++-v3/include/bits/stl_algo.h#L4808">sort</a></td><td><a href="https://en.wikipedia.org/wiki/Introsort">内省排序</a></td><td>O(n*log2n)</td><td>可重复</td></tr></tbody></table><ul><li><strong>补充</strong></li></ul><ol><li>为什么空间配置其使用<strong>内存池</strong>机制实现</li></ol><p>内存池实现机制采用allocate 包装 malloc，deallocate包装free，如果将内存申请交给每个STL容器自己去申请管理，一是不安全容易内存泄漏二是频繁申请小块内存导致内存碎片，影响程序运行效率。</p><ol start="2"><li>为什么空间配置器是一级和二级的，为什么要二级空间配置器(1大1小)</li></ol><p>一级空间配置器对于大块内存非常有效，直接与内存管理机制交互减少额外开销，但是频繁分配和释放小块内存的场景，将会导致性能下降和内存碎片,所以引入二级空间配置器，底层原理是链表构成的内存</p><ol start="3"><li>STL内存管理</li></ol><p>STL内存管理使用二级内存配置器来优化内存分配和回收。这种机制通过减少系统调用（例如 <code>malloc</code> 和 <code>free</code>）的次数来提高性能，特别是在频繁进行小块内存操作的场景下，</p><p><strong>一级内存配置器（first level allocator）</strong>：直接使用标准的内存分配和回收方法，如 <code>malloc</code> 和 <code>free</code>。当申请的内存大小超过128字节时，默认使用一级内存配置器</p><p><strong>二级内存配置器（second level allocator）</strong>：主要用于处理小块内存请求，尤其是小于128字节的请求。二级内存配置器的设计目的是减少内存碎片和提高内存分配效率。减少了对系统级内存管理函数调用，对于小块内存的请求能快速响应，提高了内存分配的速度，通过固定大小的内存块管理，可以有效减少内存碎片。</p><h6 id="vector"><a class="header-anchor" href="#vector"></a>vector</h6><ul><li>概念</li></ul><p>动态增长数组，底层是类似于一个array，但是比array灵活，内部数据连续存储，是一种可以动态增长的序列容器，元素在内存连续存放，随机存取时间复杂度O(1)，尾端操作最佳性能，头部操作O(n)。</p><p>增加元素时若超过自身最大容量，则扩充自身容量2倍（不同的编译器，vector有不同的扩容大小。在vs下是1.5倍，在GCC下是2倍）扩充空间需要经过的步骤：重新配置空间，元素移动，释放旧的内存空间。一旦vector空间重新配置，则指向原来vector的所有迭代器都失效了，因为vector的地址改变了</p><ul><li>补充</li></ul><ol><li><p>为什么加倍扩充，而申请固定容量？扩容为啥1.5倍或2倍？</p><p>加倍扩容将会有更多的空余空间，不然假设我们一边扩一个一边加一个将导致不停的内存拷贝复制，时间复杂度本来是O(1)将会增长为O(n)</p><p>使用k=2增长因子的问题在于，每次扩展的新尺寸必然刚好大于之前分配的总和，也就是说，之前分配的内存空间不可能被使用。这样对内存不友好，最好把增长因子设为(1, 2)，也就是1-2之间的某个数值。1.5倍扩容能更好的利用之前的内存块，降低碎片问题。</p></li><li><p><code>push_back</code>和<code>emplace_back</code>区别</p><p>emplace_back() 和 push_back() 的主要区别，就在于底层实现的机制不同。push_back() 向容器尾部添加元素时，首先会创建这个元素，然后再将这个元素拷贝或者移动到容器中（如果是拷贝的话，事后会自行销毁先前创建的这个元素）；而 emplace_back() 在实现时，则是直接在容器尾部创建这个元素，省去了拷贝或移动元素的过程</p></li><li><p>迭代器失效</p><p>resize、reserve、insert、assign、push_back等会引起其底层空间改变的操作，都有可能使迭代器失效，实际就是迭代器底层对应指针所指向的 空间被销毁了</p></li><li><p>使用vector交换技巧释放空间</p><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">std::<span class="built_in">vector</span><<span class="type">int</span>>(vec).<span class="built_in">swap</span>(vec); <span class="comment">// shrink</span></span><br><span class="line">std::<span class="built_in">vector</span><<span class="type">int</span>>().<span class="built_in">swap</span>(vec); <span class="comment">// 清空内容，且释放内存</span></span><br></pre></td></tr></table></figure></li><li><p>元素类型可以是引用吗</p><p>vector的底层实现要求连续的对象排列，<strong>引用并非对象，没有实际地址，因此vector的元素类型不能是引用</strong></p><ol><li><strong>引用的不可重新绑定性</strong>：引用一旦被绑定到某个对象，就不能被重新绑定。容器在内部需要能够移动和复制元素，这对于引用类型来说是不可能的，因为引用类型一旦创建就绑定到某个对象，无法重新指向其他对象。</li><li><strong>引用类型的内存管理</strong>：容器在内部可能会重新分配内存并移动元素位置，这对于引用类型是不适用的。因为引用本质上是某个对象的别名，而不是独立存在的对象，因此无法被复制或移动</li></ol></li></ol><h6 id="list"><a class="header-anchor" href="#list"></a>list</h6><ul><li><p>概念</p></li><li><p>补充</p></li></ul><h6 id="deque"><a class="header-anchor" href="#deque"></a>deque</h6><ul><li>概念</li></ul><p><strong>双端队列</strong>， 用空间换了时间，支持首尾（中间不能）快速增删（与vector最大差异），<strong>支持随机访问</strong>。<code>deque</code> 的内部实现通常不是一个连续的内存区域，而是由一系列固定大小的数组（称为块或段）构成，这些数组通过一些额外的中央控制结构（如索引数组）连接</p><p><strong>优点：</strong></p><ol><li><strong>两端插入/删除操作高效</strong>：<code>std::deque</code> 允许在容器的前端和后端进行快速插入和删除操作，时间复杂度大约是 O(1)，这比 <code>std::vector</code> 的前端插入和删除效率要高得多。【这也是vector最大差异】</li><li><strong>随机访问</strong>：与 <code>std::vector</code> 类似，<code>std::deque</code> 也支持通过索引进行快速随机访问，访问时间复杂度为 O(1)</li></ol><p><strong>缺点：</strong></p><ol><li><strong>内存使用可能更高</strong>：由于 <code>std::deque</code> 的实现通常需要额外的中央控制结构来管理各个块，以及块内的间接寻址，这可能导致其比 <code>std::vector</code> 使用更多的内存。</li><li><strong>缓存利用率可能较低</strong>：虽然 <code>std::deque</code> 支持随机访问，但其元素可能分布在不连续的内存块中，这可能导致在遍历时缓存命中率低于 <code>std::vector</code>。</li><li><strong>某些操作可能较慢</strong>：虽然在两端的操作很快，但在 <code>std::deque</code> 的中间插入或删除元素仍然需要移动一部分元素，这可能比在 <code>std::vector</code> 中慢，尤其是当元素分布在多个内存块中时</li></ol><ul><li>补充</li></ul><ol><li><code>deque</code>的中控器</li></ol><p><code>deque</code> 的中控器是一个指针数组，每个指针指向一个固定大小的内存块（称为缓冲区），这些缓冲区存储实际的数据元素。中控器本身通常是动态分配的，可以根据需要扩展或缩小，以容纳更多的缓冲区。这种结构允许 <code>deque</code> 在两端动态增长而无需重新分配整个容器的内存，这是 <code>vector</code> 扩展时通常需要做的事情。</p><h6 id="map"><a class="header-anchor" href="#map"></a>map</h6><ul><li>概念</li></ul><p>底层实现为一个<strong>自平衡的二叉搜索树</strong>（红黑树，红黑树的旋转操作比AVL树少，红黑树的这种宽松平衡使其在<strong>插入和删除操作中相对更高效</strong>，因为它不需要像AVL树那样频繁地进行平衡调整，但是这也意味着在最坏情况下，红黑树的查找操作可能会稍慢于AVL树，因为其<strong>树高可能稍高</strong>），意味着在对数时间复杂度内完成插入、查找和删除的操作，内部元素排列是有序的。</p><ul><li>补充</li></ul><p>红黑树？</p><blockquote><p>中所有节点非红即黑。</p><p>根节点必为黑节点。</p><p>红节点的子节点必为黑（黑节点子节点可为黑）</p><p><strong>从根到叶子的任何路径上黑结点数相同</strong></p><p>O(<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>l</mi><mi>o</mi><msub><mi>g</mi><mn>2</mn></msub><mi>n</mi></mrow><annotation encoding="application/x-tex">log_2n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">o</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord mathnormal">n</span></span></span></span>) 查询</p></blockquote><h6 id="set"><a class="header-anchor" href="#set"></a>set</h6><ul><li>概念</li></ul><p>底层是一个基于红黑树实现，存储唯一的元素（不重复），按照特定的顺序进行排序的，关联容器。并且set仅存储单个值而非键值对，他的值就是键。</p><ul><li>补充</li></ul><ol><li>为什么map和set和插入删除效率比其他序列容器高，而且每次insert之后，以前保存的iterator不会失效</li></ol><p>**关于效率：**set和map是一种关联式容器，底层实现是红黑树实现的，他们的插入和删除效率高于其他容器是因为插入删除操作均是在节点进行操作，对红黑树节点的操作也只是指针操作，节点的存储内存不变。所以效率高，而vector往中间插入会涉及到对后序的内存中的元素复制再拷贝。</p><p><strong>关于迭代器失效：</strong> 在 <code>std::map</code> 和 <code>std::set</code> 中，插入和删除操作不会使指向其他元素的迭代器失效。这是因为这些操作只影响到特定的节点，并且由于红黑树的性质，树的其他部分保持有效</p><ol start="2"><li>map和set不能像vector一样有个reserve函数来预分配数据</li></ol><p>vector是一种序列式容器，底层实现是一个连续的内存空间，可以动态添加删除数据。而map&set基于红黑树结构他们并不支持连续的内存布局，<strong>他们的底层设计和数据结构</strong>决定了它们不支持 <code>reserve</code> 功能，</p><h6 id="priority-queue"><a class="header-anchor" href="#priority-queue"></a>priority_queue</h6><ul><li>概念</li></ul><p><code>std::priority_queue</code> 默认使用 <code>std::vector</code> 作为其底层容器，并使用 <code>std::less</code> 作为比较函数，这意味着最大的元素总是位于队列的前端。它<strong>不提供遍历其元素的能力</strong>，因为 <code>std::priority_queue</code> 只允许访问最顶端的元素。插入和删除操作（添加和移除队列中的元素）的时间复杂度大约是 O(log n)</p><h5 id="容器其它补充"><a class="header-anchor" href="#容器其它补充"></a>容器其它补充</h5><p>迭代器 ++it 与 it++</p><ul><li>概念</li></ul><p><code>++it</code>（前缀递增）</p><p><strong>行为</strong>：首先增加迭代器的值（即让迭代器指向下一个元素），然后返回增加后的迭代器的引用。普通<code>++i</code>就是这样，<code>++i</code> 首先将 <code>i</code> 的值增加+1再返回</p><p><strong>性能</strong>：通常推荐使用前缀递增，因为它不需要创建迭代器的临时副本。在迭代器或者对象本身较大时，使用前缀递增可以避免不必要的复制，从而提高效率</p><p><code>it++</code>（后缀递增）</p><p><strong>行为</strong>：首先创建当前迭代器的一个副本，然后增加原迭代器的值（让原迭代器指向下一个元素），最后返回副本。这意味着返回的是增加之前的迭代器的值。普通<code>i++</code>就是这样，<code>i++</code> 首先返回 <code>i</code> 当前的值（增加前的值），然后再+1</p><p><strong>性能</strong>：后缀递增需要创建迭代器的一个临时副本，这可能导致额外的性能开销，尤其是对于那些复制成本较高的迭代器（如某些容器的迭代器）</p><p>STL线程安全性</p><ul><li>概念</li></ul><p><strong>单线程访问</strong>：所有 STL 容器都是线程安全的。</p><p><strong>多线程只读访问</strong>：多个线程可以安全地同时读取同一个容器。</p><p><strong>多线程读写访问</strong>：需要使用同步机制（如互斥锁）来保护对容器的访问，以防止数据竞争。</p><p>容器动态链接可能产生的问题</p><ul><li>概念</li></ul><p>一般程序中，局部容器、参数传递容器、参数传递容器的引用以及参数传递容器的指针通常可以正常运行。然而，当涉及到动态链接库（DLL）时，给动态库函数传递容器对象本身可能会导致内存堆栈破坏的问题。</p><p>标准库实现差异；编译器和ABI兼容性；内存分配器不一致</p><hr><h4 id="析构与构造-📚"><a class="header-anchor" href="#析构与构造-📚"></a>析构与构造 📚</h4><ul><li>概念</li></ul><table><thead><tr><th></th><th>解释</th><th style="text-align:left">备注</th></tr></thead><tbody><tr><td>普通构造函数</td><td>完成对象的初始化工作</td><td style="text-align:left">含参数</td></tr><tr><td>默认构造函数</td><td>完成对象的初始化工作</td><td style="text-align:left">无参数</td></tr><tr><td>拷贝构造函数</td><td>复制构造函数用于复制本类的对象，拷贝构造函数在用一个对象初始化另一个新对象时被调用</td><td style="text-align:left">默认实现是浅拷贝而非深拷贝</td></tr><tr><td>转换构造函数</td><td>转换构造函数用于将其他类型的变量，隐式转换为本类对象</td><td style="text-align:left"></td></tr><tr><td>移动构造函数</td><td>特殊的构造函数，用于在对象之间转移资源的所有权，而不是复制资源</td><td style="text-align:left">接受一个右值引用作为参数；noexcept不抛出异常</td></tr><tr><td>委托构造函数</td><td>构造函数可以委托同类型的另一个构造函数对对象进行初始化</td><td style="text-align:left"></td></tr></tbody></table><p>构造过程：</p><ol><li><p><strong>内存分配</strong>：首先为对象分配内存，包括其所有成员变量。</p></li><li><p>成员初始化</p><ul><li><p><strong>使用初始化列表</strong>：如果提供了初始化列表，则成员变量将通过在列表中指定的构造函数直接初始化。这意味着对于类类型成员，将直接调用相应的构造函数（可能是参数化构造函数或复制构造函数），而对于内置类型成员，则直接进行赋值。</p><p>初始化列表只做一次赋值操作，相比构造函数体内进行赋值的话，构造函数体内进行赋值会等于是一次默认构造加一次赋值。</p></li><li><p><strong>未使用初始化列表</strong>：如果没有为类类型的成员变量提供初始化列表，则这些成员变量首先通过默认构造函数进行初始化。之后，如果在构造函数体内有赋值操作，这些成员变量将经历一次赋值操作。</p></li></ul></li><li><p><strong>执行构造函数体</strong>：完成成员的初始化后，执行构造函数体中的代码</p></li></ol><p>对于类类型的成员变量，如果在构造函数体内对它们进行赋值，而不是在初始化列表中直接初始化，会发生以下情况：</p><ul><li><strong>默认构造阶段</strong>：在进入构造函数体之前，类类型的成员需要被初始化。如果没有在初始化列表中明确指定如何初始化，那么这些成员将通过默认构造函数进行初始化。这是成员对象的生命周期的开始。</li><li><strong>赋值操作</strong>：在构造函数体内，对这些已经默认构造的成员进行赋值，实际上是调用赋值操作符。这不是成员对象的初始化，而是在一个已经构造的对象上进行的赋值。</li></ul><p>浅拷贝(Shallow Copy) 深拷贝(Deep Copy) 零拷贝</p><p>构造\析构执行顺序</p><p>构造：<strong>基类构造函数->成员对象的构造函数->派生类构造函数</strong></p><p>有多个成员类对象则构造函数的调用顺序是对象在类中<strong>被声明的顺序</strong>，而不是它们出现在成员初始化表中的顺序</p><blockquote><p>构造子类构造函数的参数</p><p>子类调用基类构造函数</p><p>基类设置vptr</p><p>基类初始化列表内容进行构造</p><p>基类函数体调用</p><p>子类设置vptr</p><p>子类初始化列表内容进行构造</p><p>子类构造函数体调用</p></blockquote><ul><li>补充</li></ul><ol><li><p>构造函数与析构函数进行内联</p><p>将构造函数和析构函数声明为inline是没有什么意义即编译器并不真正对声明为 <code>inline </code>的构造和析构函数进行内联操作</p><p>原因：因为编译器会在构造和析构函数中添加额外的操作（申请/释放内存，构造/析构对象等），致使构造函数/析构函数并不像看上去的那么精简。即实际上这两个函数很复杂，编译器不会对其<code>inline</code></p></li><li><p>虚函数内联</p><p>当是指向派生类的指针（多态性）调用 <code>inline </code>的虚函数时，不会内联展开；当是对象本身调用 inline 的虚函数时，会内联展开。</p><p>虚函数是为了实现运行时多态性而设计的，它允许在派生类中重写基类中的同名函数，而在运行时动态地确定应该调用哪个版本的函数，内联函数允许在调用处直接展开函数的代码，以减少函数调用的开销。但是，对于虚函数来说，编译器需要在运行时确定实际调用的函数版本，这与内联函数的特性相矛盾。因此，虚函数通常不会被声明为内联函数。虚函数的实现通常涉及虚函数表（vtable）和虚函数指针（vptr），而内联函数的展开是在编译期间完成的，这两者的机制不兼容</p><table><thead><tr><th>内联问题</th></tr></thead><tbody><tr><td>虚函数内联（类中本身调用才展开，指针调用情况下不会）</td></tr><tr><td>构造函数内联（没意义）</td></tr><tr><td>析构函数内联（没意义）</td></tr></tbody></table></li><li><p>什么时候合成构造函数</p><p>没有任何构造函数，但他含有一个成员对象，该成员对象含有默认构造函数</p><p>没有任何构造函数的类派生自一个带有默认构造函数的基类</p><p>带有虚函数的类</p><p>含有虚基类</p></li><li><p>什么时候合成拷贝构造函数</p><p>被当做参数交给某个函数</p><p>如果返回的对象是一个函数参数或类的成员变量，而不是局部对象，则会调用拷贝构造函数</p><p>没有拷贝构造函数，但是含有一个类类型的成员变量，该类型含有拷贝构造函数</p><p>没有拷贝构造函数，但是该类继承自含有拷贝构造函数的基类</p><p>带有虚函数的类</p><p>含有虚基类</p></li><li><p>返回一个局部对象，返回值的创建</p><p>返回一个局部对象，编译器会优先调用移动构造函数来创建返回值，而不是拷贝构造函数</p></li></ol><hr><h4 id="多态与虚函数-🧊"><a class="header-anchor" href="#多态与虚函数-🧊"></a>多态与虚函数 🧊</h4><p>多态</p><ul><li>概念</li></ul><ol><li><strong>编译时多态</strong>：也称为<strong>静态多态</strong>，主要通过方法重载和运算符重载实现。在编译时，编译器就决定了应该使用哪个函数，基于函数签名（如参数类型和数量）来进行区分。</li><li><strong>运行时多态</strong>：也称为<strong>动态多态</strong>，主要依赖于继承和接口实现。在运行时，系统根据对象的实际类型来决定调用哪个实现，这种决定通常依赖于虚函数。</li></ol><ul><li>补充</li></ul><ol><li>引用和指针才能展现多态，非引用或者指针呢？</li></ol><p>非指针和非引用将导致<strong>切割问题</strong>：指针类型的时候按照多态的行为去解释（即去查虚函数表，然后实现运行时多态），而非指针类型，直接使用基类类型不会按照多态行为解释（虚函数表指针丢失）</p><p>虚xxx</p><ul><li>概念</li></ul><ol><li>普通虚函数（Virtual Functions）</li></ol><p><strong>定义与目的</strong>：通过在函数声明前添加<code>virtual</code>关键字来定义虚函数。虚函数允许派生类重写（override）基类中的成员函数，<strong>实现运行时多态</strong></p><p><strong>运行时多态</strong>：虚函数的调用是在运行时决定的，而非编译时。这意味着当通过基类指针或引用调用一个虚函数时，将执行对象实际类型的函数版本</p><p><strong>编译时多态</strong>：函数重载或者模板【问模板的原理？】</p><ol start="2"><li>纯虚函数（Pure Virtual Functions）</li></ol><p><strong>定义</strong>：纯虚函数是一种没有实现的虚函数，通过在函数声明的结尾处添加<code>= 0</code>来指定</p><p><strong>抽象基类</strong>：包含至少一个纯虚函数的类称为抽象基类。抽象基类不能实例化对象</p><ol start="3"><li>虚析构函数（Virtual Destructors）</li></ol><p><strong>目的</strong>：确保通过基类指针删除派生类对象时能够调用正确的析构函数，从而避免资源泄漏</p><p><strong>实现</strong>：将基类的析构函数声明为虚函数</p><ol start="3"><li>虚继承</li></ol><p><strong>解决问题</strong>：用于解决多重继承中的菱形继承问题（钻石问题），避免基类被多次继承导致的成员重复</p><p>实现：编译器会为使用虚继承的类构建一个虚基类表。这个表用于存储虚基类相对于派生类对象的偏移量</p><ul><li>补充</li></ul><table><thead><tr><th>不可以为虚函数的函数</th><th>备注</th></tr></thead><tbody><tr><td>构造函数 （不可以）</td><td>虚指针未初始化，矛盾</td></tr><tr><td>内联函数 （不推荐）</td><td>派生类指针调用不会内联展开；对象本身调用内联展开</td></tr><tr><td>静态函数 （不可以）</td><td>因为不属于对象属于类，静态成员函数没有this指针</td></tr><tr><td>友元函数 （不可以）</td><td>因为友元函数不属于类的成员函数，不能被继承，不会进入虚表</td></tr></tbody></table><ol><li><p>静态函数可以声明为虚函数吗</p><p>不可以，静态函数不是对象的实际成员，无法和实例进行绑定</p></li><li><p>构造函数可以为虚函数吗</p><p><strong>不可以，虚函数表和虚指针是在对象被创建完成后才进行初始化</strong>的。在对象的构造函数执行之前，对象的内存空间已经分配，但<strong>虚指针尚未初始化</strong>。因此，在构造函数中无法使用虚函数表和虚指针来实现动态绑定</p><blockquote><p>当一个虚函数被调用时,它通过虚表(vtable)来解析，而虚函数的调用需要我们通过虚指针去查询虚表进行访问，但此时我们的虚指针的构造是跟随着对象构造函数一起走的，既然我们的虚指针还未初始化那我们访问虚表的行为可能就是未知的，得不到相应调用。此时就会导致一个悖论:</p><p><strong>解释1：虚指针还未还没有初始化,对象未完成构造,编译器就需要使用它来调用构造函数</strong>;</p><p><strong>解释2：虚函数是在运行时动态确定其类型的。在构造一个对象时对象还未创建成功，编译器无法知道对象的实际类型，无法进行调用</strong></p><p><em>'鸡和蛋相互依赖:鸡来自蛋,而蛋又是由鸡生的。这导致了一个看似无法解决的循环因果关系,同样,在构造函数和虚函数的情况下,也存在一种循环依赖:</em></p><ol><li><em>为了调用虚函数,对象需要通过vptr访问其虚表。</em></li><li><em>但是,访问虚表我们需要一个已经初始化好了的vptr才行，而虚指针是在构造函数执行期间初始化的,对象完成构造后才能得到虚指针</em></li><li><em>如果构造函数本身是一个虚函数,那么在调用构造函数之前,就需要访问尚未初始化的虚指针进而访问虚表，很明显这有问题。</em></li></ol><p><em>这就产生了一个类似于"先有鸡还是先有蛋"的悖论:为了调用构造函数(虚函数),需要虚指针访问虚表;但为了初始化虚指针,需要先调用构造函数’</em></p></blockquote><p>对象的虚指针（指向虚表的指针）设置通常是在<strong>构造函数开始执行的早期阶段进行</strong>的，这是为了确保即使在<strong>构造过程中，对象的虚函数也能正确解析到当前构造阶段对应类的实现</strong>。这意味着，虚指针和虚表的设置发生在对象的构造过程中，而不是在构造函数完成后【是逐步逐步完成的】。</p><blockquote><p>假设有三个类，<code>Base</code>，<code>Derived1</code>继承自<code>Base</code>，以及<code>Derived2</code>继承自<code>Derived1</code>。每个类都有其虚函数和相应的虚表。</p><p>构造<code>Derived2</code>对象时的过程：</p><ul><li>当<code>Derived2</code>的构造函数被调用时，它首先会调用<code>Derived1</code>的构造函数。</li><li>在<code>Derived1</code>的构造函数执行之前，<code>Base</code>的构造函数会被自动调用。</li><li><strong>在<code>Base</code>构造函数执行的早期阶段</strong>，对象的虚指针被设置为指向<code>Base</code>的虚表。这确保了即使在<code>Base</code>构造函数内部，任何虚函数调用都能正确地解析到<code>Base</code>类的实现。</li><li>然后，控制权回到<code>Derived1</code>的构造函数，在它开始执行的早期，对象的虚指针更新为指向<code>Derived1</code>的虚表。</li><li>同样地，当<code>Derived2</code>的构造函数开始执行时，对象的虚指针最终被更新为指向<code>Derived2</code>的虚表。</li><li>当<code>Derived2</code>的构造函数执行完毕，整个对象被完全构造完成，此时虚指针指向<code>Derived2</code>的虚表，确保任何对虚函数的调用都会解析到<code>Derived2</code>或它正确的基类实现。</li></ul><p>因此，虚指针的设置和更新发生在每个构造阶段的开始，确保了即使在构造过程中发生虚函数调用，也能够调用到正确版本的函数【但是一般不在构造函数中调用虚函数，不推荐】。这也意味着虚指针和虚表的“生成”（或更准确地说，虚指针的设置）是在构造对象的过程中逐步完成的，而不是在整个对象构造完成后</p></blockquote></li><li><p>析构函数可以为虚函数吗</p><p>有一个指向派生类对象的基类指针，并且通过这个基类指针删除对象时，如果基类的析构函数不是虚的，那么只有基类的析构函数会被调用，导致派生类部分可能不会被正确清理，从而造成资源泄漏或其他问题。这是因为在这种情况下，编译器无法确定要调用哪个析构函数，因为它只依据指针的静态类型来做决定。</p></li><li><p>构造函数和析构函数可以调用虚函数吗</p><p>对于构造函数：此时子类的对象还没有完全构造，编译器会去虚函数化，只会用当前类的函数， 如果是纯虚函数，就会调用到纯虚函数，会导致构造函数抛异常</p><p>对于析构函数： 同样，由于对象不完整，编译器会去虚函数化，函数调用本类的虚函数，如果本类虚函数是纯虚函数，就会到账析构函数抛出异常</p><p>语法上讲可以，但不推荐这种做法【effective C++: <strong>绝不在构造和析构过程中调用虚函数</strong>】</p><blockquote><p>《Effective C++》的解释是： 派生类对象构造期间进入基类的构造函数时，对象类型变成了基类类型，而不是派生类类型。 同样，进入基类析构函数时，对象也是基类类型</p><ul><li>在构造函数中调用虚函数,调用的是当前<strong>正在构造</strong>的类的版本,而不是最终的重写版本</li><li>在析构函数中调用虚函数,调用的是当前<strong>正在析构</strong>的类的版本,而不是原始的基类版本</li></ul></blockquote><p>父类对象会在子类之前进行构造，此时子类部分的数据成员还未初始化，因此调用子类的虚函数时不安全的，故而C++不会进行动态联编【<strong>构造函数和析构函数调用虚函数时都不使用动态联编</strong>】</p></li></ol><p>vptr 与 vtable</p><ul><li><p>概念</p><ul><li><p>虚指针 vptr</p><p><strong>定义</strong>：虚指针是一个指针，每个使用虚函数的对象都会持有一个指向相应虚表的虚指针。</p><p><strong>作用</strong>：虚指针使得对象能够在运行时通过虚表找到正确的虚函数实现。当对象的虚函数被调用时，编译器通过对象的虚指针访问虚表，从而找到对应的函数实现进行调用。<strong>在构造函数执行时会对虚表指针进行初始化</strong></p></li><li><p>虚表 vtable</p><p><strong>定义</strong>：虚表是一个包含指向类的虚函数地址的数组。<strong>每个</strong>有虚函数的类或包含虚函数的类的派生类都有一个为它生成的虚表，这个表是一个函数指针数组，每个元素指向一个虚函数的实现。如果类中有虚函数，每个对象实例会包含一个指向其类虚函数表的指针（通常在对象内存布局的开始位置）。</p><p><strong>作用</strong>：当调用对象的虚函数时，编译器会使用虚表来决定需要调用的实际函数。这允许在运行时进行函数的动态绑定，是实现多态的关键。</p></li><li><p>工作原理</p><p><strong>初始化</strong>：当一个对象被创建时，编译器会自动在对象的内存布局中添加一个虚指针（vptr），并将其初始化为指向该类的虚表</p><blockquote><p>在构造函数中创建虚表并对虚表初始化。在构造子类对象时，会先调用父类的构造函数，此时，编译器只“看到了”父类，并为父类对象初始化虚表指针，令它指向父类的虚表；当调用子类的构造函数时，为子类对象初始化虚表指针，令它指向子类的虚表</p><p>即导致一种情况：覆盖</p><p>当派生类对基类的虚函数没有重写时，派生类的虚表指针指向的是基类的虚表；当派生类对基类的虚函数重写时，派生类的虚表指针指向的是自身的虚表；当派生类中有自己的虚函数时，在自己的虚表中将此虚函数地址添加在后面</p></blockquote><p><strong>继承与多态</strong>：如果一个类被继承，派生类会有它自己的虚表（如果它覆盖了基类的虚函数或添加了新的虚函数）。当通过基类指针或引用调用虚函数时，运行时会查找对象实际类型的虚表，从而调用正确的函数实现</p><p>继承中的虚函数表</p><ol><li><p><strong>无新虚函数，无覆盖</strong>：</p><p>如果派生类没有引入新的虚函数，也没有重写基类的任何虚函数，则派生类可以直接使用基类的虚函数表。</p></li><li><p><strong>覆盖基类虚函数</strong>：</p><p>如果派生类重写（覆盖）了基类的虚函数，派生类的虚函数表将包含指向新实现的指针，替换掉原有函数的位置。这保证了通过基类指针调用虚函数时，能够执行到派生类中的覆盖版本。</p></li><li><p><strong>引入新的虚函数</strong>：</p><p>如果派生类引入了新的虚函数，这些新函数会被添加到虚函数表的末尾。派生类的虚函数表首先包含指向从基类继承的所有虚函数（包括被覆盖的和未被覆盖的）的指针，随后是新增虚函数的指针。</p></li></ol></li></ul></li><li><p>补充</p><ol><li>vptr和vtable是什么时候创建</li></ol><p><strong>虚表是在编译阶段为每个含有虚函数的类生成的，而虚指针在类的对象实例化过程中，具体是在构造函数执行过程中初始化，并指向相应的虚表</strong></p><p>虚表和虚指针创建和初始化的过程，涉及到类的实例化：</p><p>**编译阶段：**编译器在编译阶段识别出哪些类含有虚函数，并为这些类生成虚表。虚表中存储了虚函数的地址。如果类有继承，并且子类覆盖了基类的虚函数，子类的虚表中会用子类函数的地址替换相应的基类函数地址。<br>**构造函数执行阶段：**当创建一个类的对象时，该对象的构造函数会被调用。在构造函数的执行过程中，对象的虚指针（vptr）被初始化，指向其对应类的虚表。如果有继承关系，每个构造函数（从基类到派生类）在其执行过程中都可能更新vptr以指向正确的虚表，以反映当前构造阶段对象的动态类型。<br>**构造函数完成后：**一旦对象的构造函数（包括所有基类和派生类的构造函数，如果有继承的话）执行完成，对象的vptr将最终指向最派生类的虚表。此时，对象已经完全构建好，可以正常使用虚函数了。</p><blockquote><p>虚指针 (vptr)</p><ul><li><strong>创建和初始化时机</strong>：每个含有虚函数的类的对象都会有一个虚指针。这个虚指针是在对象创建时自动被编译器添加到对象中的。对于类的每个实例，虚指针在对象的构造函数中被初始化。</li><li><strong>指向</strong>：虚指针指向相应的虚表。</li></ul><p>所以我们说只有在vptr完成初始化后才能访问到虚表</p><p>虚表 (vtable)</p><ul><li><strong>创建时机</strong>：虚表是在编译时期创建的。对于每一个含有虚函数的类，编译器会生成一个虚表。虚表是类的一个静态属性，因此对于该类的所有实例来说，<strong>虚表是共享的</strong>。</li><li><strong>初始化时机</strong>：虚表在编译期间就已经被初始化了。编译器会将类中所有的虚函数地址填入虚表中。这意味着，当程序编译完成后，每个含有虚函数的类对应的虚表中已经填充了所有虚函数的地址。</li><li><strong>填入虚函数地址</strong>：虚函数的地址是在编译器编译时期填入虚表的。<strong>这个过程发生在程序编译阶段，而不是运行时或者类的初始化时期</strong></li></ul></blockquote></li></ul><hr><h4 id="引用与指针-📎"><a class="header-anchor" href="#引用与指针-📎"></a>引用与指针 📎</h4><h5 id="区别"><a class="header-anchor" href="#区别"></a>区别</h5><p>在编译的时候，则是将“指针变量名-指针变量的地址”添加到符号表中，所以说，指针包含的内容是可以改变的，允许拷⻉和赋值，有<code>const</code>和⾮ <code>const</code>区别，甚⾄可以为空，<code>sizeof</code>指针得到的是指针类型的⼤⼩。</p><p>引⽤来说，它只是⼀块内存的别名，在添加到符号表的时候，是将"引⽤变量名-引⽤对象的地址"添加到符号表中，符号表⼀经完成不能改变，所以引⽤必须⽽且只能在定义时被绑定到⼀块内存上，后续不能更改，也不能为空，也没有 <code>const</code> 和⾮<code>const</code>区别。</p><ul><li><p>指针是一个变量，存储地址，引用是别名</p></li><li><p>指针可以有多级，引用只有一级</p></li><li><p>指针可以为空，引用必须初始化</p></li><li><p>指针在初始化后可以改变指向，而引用在初始化之后不可再改变</p></li><li><p>当把指针作为参数进行传递时，也是将实参的一个拷贝传递给形参，两者指向的地址相同，但不是同一个变量，在函数中改变这个变量的指向不影响实参。而使用引用作为参数传值对这个引用进行修改则会引起源对象变化</p></li></ul><h5 id="参数传递方式"><a class="header-anchor" href="#参数传递方式"></a>参数传递方式</h5><p>指针传递、引用传递、值传递</p><h5 id="指针分辨"><a class="header-anchor" href="#指针分辨"></a>指针分辨</h5><p>右左法则：使用右左法则时，你从变量名开始，然后根据优先级（括号 > 数组/函数 > 指针）向右看，如果到达声明的末尾，就转向左边继续</p><p><code>int *p[10]</code></p><ul><li><strong>分析</strong>: 首先看到的是 <code>[]</code>，表示 <code>p</code> 是一个数组；然后移动到左边，看到 <code>*</code>，表示数组的元素是指针；最后到最左边，看到 <code>int</code>，表示这些指针指向整型数据。</li><li><strong>结论</strong>: <code>p</code> 是一个有10个元素的数组，每个元素是指向 <code>int</code> 类型数据的指针。</li></ul><p><code>int (*p)[10]</code></p><ul><li><strong>分析</strong>: 首先看到的是 <code>(*p)</code>，括号表示 <code>p</code> 是被 <code>*</code> 解引用的，所以 <code>p</code> 是一个指针；然后外面是 <code>[]</code>，表示这个指针指向的是一个数组；最后是 <code>int</code>，表示数组的元素是整型数据。</li><li><strong>结论</strong>: <code>p</code> 是一个指针，指向一个有10个整型元素的数组。</li></ul><p><code>int *p(int)</code></p><ul><li><strong>分析</strong>: 这是一个函数声明。首先看到的是 <code>(int)</code>，表示有一个整型参数的函数；然后到左边，看到 <code>*p</code>，这里 <code>p</code> 是函数名，<code>*</code> 表示函数返回的是指针；最后到最左边，<code>int</code> 表示这个指针指向整型数据。</li><li><strong>结论</strong>: <code>p</code> 是一个函数，接受一个整型参数，返回一个指向整型数据的指针。</li></ul><p><code>int (*p)(int)</code></p><ul><li><strong>分析</strong>: 首先看到的是 <code>(*p)</code>，括号里的 <code>*</code> 表示 <code>p</code> 是一个指针；外面的 <code>(int)</code> 表示这个指针指向的是一个接受整型参数的函数；最后是 <code>int</code>，表示这个函数返回整型数据。</li><li><strong>结论</strong>: <code>p</code> 是一个指针，指向一个函数，该函数接受一个整型参数并返回一个整型数据。</li></ul><h5 id="左右值引用"><a class="header-anchor" href="#左右值引用"></a>左右值引用</h5><p><strong>左值</strong>：<strong>指的是表达式结束后依然存在的对象</strong>。左值可以出现在赋值表达式的左侧。例如，变量、对数组元素的引用、解引用指针、返回引用的函数调用都是左值。</p><p><strong>右值</strong>：<strong>通常指的是表达式结束就不再存在的临时对象</strong>。右值不能出现在赋值表达式的左侧。字面量（除了字符串字面量外）、返回非引用的函数调用、算术表达式的结果都是右值。</p><p><strong>右值引用</strong></p><p>优点：</p><ol><li>支持移动语义：<strong>右值引用允许将资源（如动态分配的内存）从一个对象移动到另一个对象，而不是传统的复制，从而提高性能和效率</strong>。</li><li>可用于完美转发：右值引用可以用于实现完美转发，即在函数模板中将参数以原始形式传递给其他函数，保留参数的值类别（左值或右值）【即左值被处理后仍然是左值】</li></ol><p>引用折叠：</p><p>出现了左值引用最后折叠的结果都是左值引用，只有右值应用和右值引用折叠才能变成右值引用</p><blockquote><p>T& & => T&</p><p>T& && => T&</p><p>T&& & => T&</p><p>T&& && => T&&</p></blockquote><h5 id="野指针-与-悬空指针"><a class="header-anchor" href="#野指针-与-悬空指针"></a>野指针 与 悬空指针</h5><p>野指针（Wild Pointer）</p><p>野指针是指未初始化的指针。其指向的内存地址是不确定的，因为它没有被明确初始化为NULL或指向有效的内存地址。使用野指针的结果是不可预测的，因为它可能指向任何内存地址，包括系统保留的内存。尝试访问或操作野指针所指向的内存通常会导致不可预测的行为，包括程序崩溃、数据损坏或者安全漏洞。</p><p>悬空指针（Dangling Pointer）</p><p>悬空指针是指向了一块已经被释放的内存的指针。当使用例如<code>free</code>或<code>delete</code>操作释放了一块内存之后，原本指向那块内存的指针就成了悬空指针。与野指针不同，悬空指针之前是指向有效内存的，但在内存释放后继续使用它就变得危险了。因为那块内存可能已经被重新分配给其他用途，对悬空指针的引用或操作可能会导致数据损坏或者不稳定的行为。</p><h5 id="智能指针"><a class="header-anchor" href="#智能指针"></a>智能指针</h5><p><strong>分类</strong></p><p>智能指针是一个类，指向动态分配对象，负责自动释放动态分配的对象，防止内存泄漏</p><p><strong><code>auto_ptr</code></strong> C++98 引入的一种智能指针,可以自动管理动态分配（使用 <code>new</code>）的对象的生命周期，以避免内存泄漏,当 <code>std::auto_ptr</code> 的实例离开作用域时，它会自动删除所管理的对象. 由于缺陷建议被3大智能指针替代</p><p><code>std::auto_ptr</code> 的主要问题:</p><ol><li><strong>所有权转移</strong>：<code>std::auto_ptr</code> 在进行拷贝或赋值时，会发生所有权的转移。这意味着原 <code>std::auto_ptr</code> 会失去对对象的所有权（变为 <code>nullptr</code>），而新的 <code>std::auto_ptr</code> 获得所有权。这种行为很容易导致意外的所有权转移，造成资源管理上的困惑。</li><li><strong>容器兼容性</strong>：由于所有权转移的行为，<code>std::auto_ptr</code> 不能安全地用于标准容器（如 <code>std::vector</code>、<code>std::list</code> 等）。尝试存储 <code>std::auto_ptr</code> 的拷贝在容器中会导致未定义行为，因为容器操作经常需要元素的复制和赋值。</li><li><strong>多线程问题</strong>：<code>std::auto_ptr</code> 没有考虑到多线程环境中的安全性问题。其设计不包含对并发访问的保护，这在多线程程序中可能会导致数据竞争和其他同步问题。</li></ol><p><strong><code>std::unique_ptr</code></strong>：是一种<strong>独占所有权</strong>的智能指针，意味着同一时间内只能有一个<code>unique_ptr</code>指向给定资源。当<code>unique_ptr</code>离开作用域时，它指向的对象会被自动销毁。<strong>这种智能指针不允许复制，确保了资源的独占性，但它允许移动，使得资源的所有权可以转移</strong></p><p><strong><code>std::shared_ptr</code></strong>：是一种<strong>共享所有权</strong>的智能指针，允许多个<code>shared_ptr</code>实例指向同一个对象。内部使用引用计数机制来跟踪有多少个<code>shared_ptr</code>共享同一个资源。当最后一个指向对象的<code>shared_ptr</code>被销毁时，对象会被自动删除。<code>shared_ptr</code>适用于需要通过多个指针访问同一资源的情况。shared_ptr内部的引用计数是线程安全的，但是对象的读取需要<strong>加锁</strong></p><p><strong><code>std::weak_ptr</code></strong>：是一种<strong>不拥有对象</strong>的智能指针，它设计用来解决<code>shared_ptr</code>间的<strong>循环引用问题</strong>。<em><code>weak_ptr</code>指向<code>shared_ptr</code>管理的对象，但不增加引用计数</em>。因此，<code>weak_ptr</code>不会阻止其指向的对·象被销毁。通常，<code>weak_ptr</code>用于临时访问<code>shared_ptr</code>管理的对象，而不希望对对象的生命周期产生影响。可以通过lock函数检查对象是否失效，未失效则转换到<code>shared_ptr</code></p><p><strong>拷贝</strong></p><p>当使用一个智能指针来初始化另一个智能指针时,会调用智能指针的拷贝构造函数。不同的智能指针类型,其拷贝构造行为也不尽相同:</p><ul><li><code>std::unique_ptr</code>: 由于<code>unique_ptr</code>是独占所有权的,不允许拷贝构造,只能进行移动构造。</li><li><code>std::shared_ptr</code>: 拷贝构造会使新的<code>shared_ptr</code>与原<code>shared_ptr</code>共享同一个控制块,从而共享对象的所有权。引用计数会加1。</li><li><code>std::weak_ptr</code>: 拷贝构造不会影响引用计数,新旧<code>weak_ptr</code>指向同一个控制块。</li></ul><p><strong>赋值</strong></p><p>对智能指针进行赋值操作时,行为也因类型而异:</p><ul><li><code>std::unique_ptr</code>: 不允许普通的赋值操作,只能通过移动赋值转移所有权。</li><li><code>std::shared_ptr</code>: 赋值后,两个<code>shared_ptr</code>共享同一个控制块,引用计数会加1。</li><li><code>std::weak_ptr</code>: 赋值不会影响引用计数</li></ul><p><strong>循环引用</strong>：指两个或多个对象相互持有对方的强引用（如 <code>shared_ptr</code>），导致这些对象的引用计数永远不会降为零，从而造成内存泄漏</p><p><strong>实现智能指针</strong></p><figure class="highlight c++"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br><span class="line">74</span><br><span class="line">75</span><br><span class="line">76</span><br><span class="line">77</span><br><span class="line">78</span><br><span class="line">79</span><br><span class="line">80</span><br><span class="line">81</span><br><span class="line">82</span><br><span class="line">83</span><br><span class="line">84</span><br><span class="line">85</span><br><span class="line">86</span><br><span class="line">87</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="keyword">template</span> <<span class="keyword">typename</span> T></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">SharedPtr</span> {</span><br><span class="line"><span class="keyword">private</span>:</span><br><span class="line"> T* ptr; <span class="comment">// 原始指针</span></span><br><span class="line"> <span class="type">int</span>* ref_count; <span class="comment">// 引用计数</span></span><br><span class="line"></span><br><span class="line"> <span class="function"><span class="type">void</span> <span class="title">release</span><span class="params">()</span> </span>{</span><br><span class="line"> <span class="keyword">if</span> (ref_count) {</span><br><span class="line"> (*ref_count)--;</span><br><span class="line"> <span class="keyword">if</span> (*ref_count == <span class="number">0</span>) {</span><br><span class="line"> <span class="keyword">delete</span> ptr;</span><br><span class="line"> <span class="keyword">delete</span> ref_count;</span><br><span class="line"> std::cout << <span class="string">"Resource released"</span> << std::endl;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line"> <span class="comment">// 构造函数</span></span><br><span class="line"> <span class="function"><span class="keyword">explicit</span> <span class="title">SharedPtr</span><span class="params">(T* p = <span class="literal">nullptr</span>)</span> : ptr(p), ref_count(new int(<span class="number">1</span>)) {</span>}</span><br><span class="line"></span><br><span class="line"> <span class="comment">// 拷贝构造函数</span></span><br><span class="line"> <span class="built_in">SharedPtr</span>(<span class="type">const</span> SharedPtr<T>& sp) : <span class="built_in">ptr</span>(sp.ptr), <span class="built_in">ref_count</span>(sp.ref_count) {</span><br><span class="line"> (*ref_count)++;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">// 拷贝赋值运算符</span></span><br><span class="line"> SharedPtr<T>& <span class="keyword">operator</span>=(<span class="type">const</span> SharedPtr<T>& sp) {</span><br><span class="line"> <span class="keyword">if</span> (<span class="keyword">this</span> != &sp) {</span><br><span class="line"> <span class="built_in">release</span>(); <span class="comment">// 释放旧的资源</span></span><br><span class="line"> ptr = sp.ptr;</span><br><span class="line"> ref_count = sp.ref_count;</span><br><span class="line"> (*ref_count)++;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> *<span class="keyword">this</span>;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">// 析构函数</span></span><br><span class="line"> ~<span class="built_in">SharedPtr</span>() {</span><br><span class="line"> <span class="built_in">release</span>();</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">// 解引用运算符</span></span><br><span class="line"> T& <span class="keyword">operator</span>*() <span class="type">const</span> {</span><br><span class="line"> <span class="keyword">return</span> *ptr;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">// 箭头运算符</span></span><br><span class="line"> T* <span class="keyword">operator</span>->() <span class="type">const</span> {</span><br><span class="line"> <span class="keyword">return</span> ptr;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">// 获取引用计数</span></span><br><span class="line"> <span class="function"><span class="type">int</span> <span class="title">use_count</span><span class="params">()</span> <span class="type">const</span> </span>{</span><br><span class="line"> <span class="keyword">return</span> *ref_count;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">// 检查指针是否为空</span></span><br><span class="line"> <span class="function"><span class="type">bool</span> <span class="title">unique</span><span class="params">()</span> <span class="type">const</span> </span>{</span><br><span class="line"> <span class="keyword">return</span> *ref_count == <span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"></span><br><span class="line"> <span class="comment">// 获取原始指针</span></span><br><span class="line"> <span class="function">T* <span class="title">get</span><span class="params">()</span> <span class="type">const</span> </span>{</span><br><span class="line"> <span class="keyword">return</span> ptr;</span><br><span class="line"> }</span><br><span class="line">};</span><br><span class="line"></span><br><span class="line"><span class="keyword">class</span> <span class="title class_">Test</span> {</span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line"> <span class="function"><span class="type">void</span> <span class="title">say</span><span class="params">()</span> </span>{</span><br><span class="line"> std::cout << <span class="string">"Hello from Test"</span> << std::endl;</span><br><span class="line"> }</span><br><span class="line">};</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span> </span>{</span><br><span class="line"> <span class="function">SharedPtr<Test> <span class="title">sp1</span><span class="params">(<span class="keyword">new</span> Test())</span></span>; <span class="comment">// 创建一个SharedPtr对象</span></span><br><span class="line"> {</span><br><span class="line"> SharedPtr<Test> sp2 = sp1; <span class="comment">// 引用计数增加</span></span><br><span class="line"> std::cout << <span class="string">"sp1 use_count: "</span> << sp1.<span class="built_in">use_count</span>() << std::endl; <span class="comment">// 输出: 2</span></span><br><span class="line"> sp2-><span class="built_in">say</span>();</span><br><span class="line"> } <span class="comment">// sp2离开作用域，引用计数减少</span></span><br><span class="line"> std::cout << <span class="string">"sp1 use_count: "</span> << sp1.<span class="built_in">use_count</span>() << std::endl; <span class="comment">// 输出: 1</span></span><br><span class="line"> sp1-><span class="built_in">say</span>();</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure><hr><h4 id="模板-📏"><a class="header-anchor" href="#模板-📏"></a>模板 📏</h4><ul><li>概念</li></ul><p><strong>函数模板</strong>：允许以任意类型执行相同的操作。例如，可以写一个排序函数，用于任何可以比较元素的数据类型。</p><p><strong>类模板</strong>：允许生成操作任意类型数据的类的实例。例如，<code>std::vector<T></code>可以存储任何类型<code>T</code>的动态数组</p><p>模板的底层实现机制称为<strong>模板实例化</strong>。<strong>模板本身不是直接编译成机器代码的</strong>，而是在编译器遇到模板使用时（例如，通过指定模板参数来创建对象或调用函数）【两次编译】<strong>在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译</strong></p><p><strong>函数模板实例化</strong>：当你使用特定类型调用一个函数模板时，编译器会生成一个该类型的特定版本的函数。如果你用相同的类型参数再次调用该函数模板，编译器通常会重用之前生成的实例。这意味着对于每一种类型的函数调用，编译器都可能生成一个专门的函数实例。</p><p><strong>类模板实例化</strong>：类模板的实例化过程与函数模板类似。当你声明一个类模板的实例（即对象）时，需要为模板参数提供具体的类型。编译器随后为这些具体类型生成一个特定的类定义。每个不同的参数化类型都会生成一个新的类实例。</p><ul><li>补充</li></ul><ol><li><p>模板中<code>typename</code>和<code>class</code>区别</p><p><code>class</code>用于声明一个类型参数，可以是任何类型包括基本数据类型等；而<code>typename</code>也能这样用，但他主要用于依赖类型的情况，即模板内部依赖于模板参数的类型，其主要是解决编译器解析依赖类型名称时的歧义（例如<code>T::iterator</code>就是一个依赖于模板参数的类型）</p></li></ol><hr><h4 id="其它-🔦"><a class="header-anchor" href="#其它-🔦"></a>其它 🔦</h4><h5 id="C-与-C"><a class="header-anchor" href="#C-与-C"></a>C++ 与 C</h5><ol><li><strong>面向对象支持</strong>：C++是一种面向对象的编程语言，支持类封装、继承、多态等面向对象的特性，同时引入模板概念呢。而C语言则是一种面向过程的编程语言，没有直接支持面向对象的特性。</li><li><strong>标准库</strong>：C标准库主要提供了基本输入输出、字符串处理等功能函数。而C++标准库除了包含了所有C标准库函数外，还添加了对面向对象特性（如容器、算法）的支持，以及更重要的STL库</li><li><strong>安全性</strong>：应对C的不安全性，C++增加了许多机制和特性来应对这些安全性问题，例如cast转换、异常处理机制、智能指针、<code>nullptr</code>类型</li><li><strong>内存分配</strong>：<code>new</code> <code>delete</code>取代<code>malloc</code> <code>free</code></li></ol><h5 id="C-与-C-v2"><a class="header-anchor" href="#C-与-C-v2"></a>C++ 与 C#</h5><p><strong>C#</strong></p><ul><li>C#通常运行在托管环境中，例如.NET Framework或.NET Core。它依赖于CLR（Common Language Runtime）来执行代码，并使用CIL（Common Intermediate Language）作为中间语言</li><li>C#具有自动垃圾回收机制，开发人员不需要手动释放内存。CLR会周期性地检查不再使用的对象，并自动释放它们所占用的内存</li><li>C#通过.NET Core实现了跨平台支持</li></ul><p><strong>C++</strong></p><ul><li>C++可以编译为本地机器代码，不依赖于特定的运行时环境</li><li>C++需要手动管理内存，开发人员需要显式地分配和释放内存，避免内存泄漏和野指针等问题</li><li>C++本身是跨平台的，可以通过适当的编译器和工具链在各种平台上进行开发和运行</li></ul><h5 id="编译过程"><a class="header-anchor" href="#编译过程"></a>编译过程</h5><p>**预处理阶段：**在这个阶段，预处理器处理源文件中的预处理指令，处理器会根据这些指令展开头文件并替换宏定义，生成一个经过预处理的源文件.ii</p><p>**编译阶段：**编译器将预处理后的源文件转换成汇编代码。编译器会对源文件进行词法分析、语法分析和语义分析，<strong>并生成相应的中间代码或汇编代码 .s</strong></p><p><strong>汇编阶段：<strong>汇编器将汇编代码转换成机器码或者目标文件。汇编器会将汇编代码转换成</strong>可重定位的机器码，并生成目标文件 .o</strong></p><p><strong>链接阶段：<strong>链接器将</strong>目标文件和库文件链接</strong>在一起，生成最终的可执行文件 .out</p><p><strong>启动过程</strong></p><p><code>main</code>函数执行前后干了什么</p><p>初始化<code>.data</code>和<code>.bss</code>段的内容-在<code>main</code>前调用全局对象的构造函数-传递<code>argc</code>和<code>argv</code>参数</p><p>全局对象析构函数在<code>main</code>函数之后执行</p><h5 id="动态-静态"><a class="header-anchor" href="#动态-静态"></a>动态\静态</h5><h6 id="链接"><a class="header-anchor" href="#链接"></a>链接</h6><p><strong>静态链接</strong></p><p>在编译链接可执行文件时，链接器从库中复制这些函数和数据并把它们和应用程序的其它模块组合起来创建最终的可执行文件</p><p>优点：可执行程序中已经具备了所有执行程序所需要的任何东西， 在执行的时候运行速度快</p><p>缺点：导致内存中副本代码过多，源库代码修改了，链接过该库的程序要重新进行编译链接</p><p><strong>动态链接</strong></p><p>动态链接的基本思想是把程序按照模块拆分成各个相对独立部分，在程序运行时才将它们链接在一起形 成一个完整的程序</p><p>优点：多个程序在执行时共享同一份副本,更新时只需要替换原来的目标文件，而无需将所有程序再重新链接一遍</p><p>缺点:为把链接推迟到了程序运行时，所以每次执行程序都需要进行链接，所以性能会有一定损失</p><h6 id="断言"><a class="header-anchor" href="#断言"></a>断言</h6><p>静态断言（Static Assertion）：</p><p>静态断言是在编译时进行的，即在代码被编译之前就会执行。</p><p>使用静态断言可以对编译期间已知的条件进行检查。</p><p>静态断言使用静态表达式来定义条件，并且如果条件为假，则会导致编译错误。</p><p>静态断言通常用于验证编译期常量、类型属性或其他与类型相关的约束。</p><p>动态断言（Dynamic Assertion）：</p><p>动态断言是在运行时进行的，即在程序执行过程中才会执行。</p><p>使用动态断言可以对运行时条件进行检查。</p><p>动态断言使用 assert() 宏来定义条件，并且如果条件为假，则会触发一个运行时错误，并终止程序执行。</p><p>动态断言通常用于验证假设、调试程序或捕获意外情况。</p><h6 id="类型"><a class="header-anchor" href="#类型"></a>类型</h6><p>静态类型：编译期间绑定，静态类型的语言要求在编译时确定所有变量的类型</p><p>动态类型：运行期决定，动态类型的语言允许变量在运行时改变其类型</p><h6 id="绑定"><a class="header-anchor" href="#绑定"></a>绑定</h6><p>静态绑定：绑定的是静态类型，将<strong>函数和对应的属性</strong>依赖绑定到相应的对象的静态类型。指的是对象的方法调用在编译时就已经解析，编译器知道具体调用哪个方法</p><p>动态绑定：绑定的是动态类型，将<strong>函数和对应的属性</strong>依赖绑定到相应的对象的动态类型（例如虚函数）。指的是方法调用的目标在运行时才确定</p><h6 id="多态-略"><a class="header-anchor" href="#多态-略"></a>多态(略)</h6><h5 id="RAII"><a class="header-anchor" href="#RAII"></a>RAII</h5><p>Resource Acquisition Is Initialization(RAII) 核心思想是：在对象的生命周期内获取所需的资源，并在对象销毁时释放这些资源。这种方式利用了C++的构造函数和析构函数自动调用的特性，确保资源使用安全且高效，这也是为什么C++比C安全的原因之一。智能指针便是RAII最具代表的实现。</p><h5 id="RTTI"><a class="header-anchor" href="#RTTI"></a>RTTI</h5><p>Run Time Type Identification 通过运行时类型识别，程序能够使用<strong>基类的指针或引用</strong>来<strong>检查着这些指针或引用所指的对象的实际派生类型</strong> typeid dynamic_cast</p><h5 id="OOP"><a class="header-anchor" href="#OOP"></a>OOP</h5><table><thead><tr><th></th><th>OOP</th><th>POP</th></tr></thead><tbody><tr><td>概念</td><td>将问题分解成一系列步骤或称之为过程的操作序列。编程的焦点是在执行具体任务的过程和函数</td><td>将问题分解成一组相互作用的对象，每个对象代表现实世界中的实体或概念。编程的焦点是对象及其交互</td></tr><tr><td>单位</td><td>函数</td><td>类和对象</td></tr><tr><td>适用场景</td><td>较小、单一任务或脚本，尤其是简单的、逻辑线性的任务</td><td>大型的、复杂的系统，特别是需要多次迭代和维护的项目</td></tr><tr><td>实现抽象</td><td>抽象通常限于函数</td><td>支持较高级别的抽象，如类抽象和多态</td></tr></tbody></table><p><strong>封装</strong>:信息隐藏</p><p><strong>继承</strong>:继承是使用已存在的类的定义作为基础建立新类</p><p><strong>多态</strong>:发出的方法调用在编程时并不确定，而是在程序运行期间才确定</p><ol><li>重载多态（Ad-hoc Polymorphism，编译期）：函数重载、运算符重载</li><li>子类型多态（Subtype Polymorphism，运行期）：虚函数</li><li>参数多态性（Parametric Polymorphism，编译期）：类模板、函数模板</li><li>强制多态（Coercion Polymorphism，编译期/运行期）：基本类型转换、自定义类型转换</li></ol><h5 id="锁"><a class="header-anchor" href="#锁"></a>锁</h5><p><strong><code>std::mutex</code></strong>:</p><ul><li>最基本的互斥锁。</li><li>提供了排他性访问，即一次只有一个线程可以持有锁。</li></ul><p><strong><code>std::recursive_mutex</code></strong>:</p><ul><li>递归互斥锁，允许同一个线程多次获取同一互斥锁。</li></ul><p><strong><code>std::timed_mutex</code></strong> 和 <strong><code>std::recursive_timed_mutex</code></strong>:</p><ul><li>这些锁提供了基于时间的锁定功能。</li><li>允许尝试在指定的时间段内获取锁。</li></ul><p><strong><code>std::shared_mutex</code></strong> (自 C++14 开始支持, 在 C++17 中更名为 <code>std::shared_timed_mutex</code>):</p><ul><li>允许多个线程同时读取共享数据，但写入时需要独占访问。</li><li>适用于读多写少的场景，可以提高并发性。</li></ul><p><strong><code>std::lock_guard</code></strong>:</p><ul><li>是一个作用域锁，保护一个代码段，使之在多线程环境下线程安全，使用 RAII（资源获取即初始化）方式管理 <code>std::mutex</code>。</li><li>当 <code>std::lock_guard</code> 对象创建时自动加锁，当作用域结束时自动解锁，避免忘记解锁的问题。</li></ul><p><strong><code>std::unique_lock</code></strong>:</p><ul><li>比 <code>std::lock_guard</code> 更灵活的作用域锁。</li><li>可以在生命周期内多次锁定和解锁。</li><li>支持条件变量 <code>std::condition_variable</code>。</li></ul><h5 id="多线程"><a class="header-anchor" href="#多线程"></a>多线程</h5><ul><li>补充</li></ul><p>使用线程池可能带来哪些风险和有哪些好处？</p><p>好处：减少创建和销毁线程的开销与降低系统资源消耗、更好的线程管理和调度</p><p>风险：资源争用和死锁、复杂性增加</p><p>线程池参数有哪些？</p><p>大小、任务队列容量、线程创建策略、线程拒绝策略、线程活跃时间、核心线程数、最大线程数量、线程优先级</p><p>线程池大小如何确定合理？是否和处理器有关？</p><p>CPU密集型任务：如果任务主要是计算密集型的（例如数学运算），那么线程池的大小通常设为处理器核心数的1到1.5倍。这样可以最大化CPU使用率，同时留有少量空间处理其他可能同时发生的系统任务或其他程序。在完全的CPU密集型场景中，线程数设置为核心数相等通常也是合理的，因为更多的线程不会带来性能提升，反而可能因上下文切换导致效率下降。</p><p>I/O密集型任务：如果任务涉及大量的输入/输出操作，如文件操作、网络通信等，这些操作通常涉及等待，此时CPU核心会空闲。在这种情况下，线程池大小可以设置得比核心数多，通常是核心数的2到3倍，甚至更多，以确保CPU在等待I/O操作完成时可以切换到其他任务。</p><p>常用的线程池工作队列？</p><p>无界队列、有界队列、优先级队列、同步队列、延迟队列</p><h5 id="线程池的设计思路"><a class="header-anchor" href="#线程池的设计思路"></a>线程池的设计思路</h5><p>实现线程池有以下几个步骤： （1）设置一个生产者消费者队列，作为临界资源。</p><p>（2）初始化n个线程，并让其运行起来，加锁去队列里取任务运行</p><p>（3）当任务队列为空时，所有线程阻塞。</p><p>（4）当生产者队列来了一个任务后，先对队列加锁，把任务挂到队列上，然后使用条件变量去通知阻塞中的一个线程来处理。</p><p>如果是CPU密集型应用，则线程池大小设置为：核数目+1<br>如果是IO密集型应用，则线程池大小设置为：2CPU数目+1</p><h5 id="常用Linux命令"><a class="header-anchor" href="#常用Linux命令"></a>常用Linux命令</h5><table><thead><tr><th>命令</th><th>功能</th></tr></thead><tbody><tr><td>man</td><td>帮助命令</td></tr><tr><td>ls命令</td><td>查看当前文件与目录信息</td></tr><tr><td>cd命令</td><td>用于切换当前目录</td></tr><tr><td>pwd命令</td><td>用于显示工作目录。</td></tr><tr><td>mkdir命令</td><td>mkdir 命令用于创建文件夹。</td></tr><tr><td>rm命令</td><td>删除文件或文件夹命令</td></tr><tr><td>rmdir 命令</td><td>从一个目录中删除一个或多个子目录项</td></tr><tr><td>mv命令</td><td>移动文件或文件夹命令</td></tr><tr><td>cp命令</td><td>复制命令</td></tr><tr><td>cat命令</td><td>查看文件内容；连接文件</td></tr><tr><td>more命令</td><td>more 会以一页一页的显示文件内容</td></tr><tr><td>less命令</td><td>less 与 more 类似，但使用 less 可以随意浏览文件</td></tr><tr><td>grep命令</td><td>该命令常用于分析一行的信息，若当中有我们所需要的信息，就将该行显示出来，该命令通常与管道命令一起使用，用于对一些命令的输出进行筛选加工。</td></tr><tr><td>ps命令</td><td>查看进程情况</td></tr><tr><td>top命令</td><td>可以查看操作系统的信息，如进程、CPU占用率、内存信息等</td></tr><tr><td>kill命令</td><td>向进程发送终止信号</td></tr></tbody></table><h5 id="分布式"><a class="header-anchor" href="#分布式"></a>分布式</h5><p>分布式系统中的通信方式有哪些？</p><blockquote><ul><li><strong>消息传递</strong>：节点之间通过发送和接收消息进行通信。</li><li><strong>远程过程调用（RPC）</strong>：允许程序调用远程节点上的函数或方法。</li><li><strong>共享存储</strong>：节点通过共享的存储系统进行数据交换。</li></ul></blockquote><p><strong>什么是一致性问题？</strong></p><blockquote><p>一致性问题指在分布式系统中，多个副本的数据状态需要保持一致。常见的一致性模型包括：</p><ul><li><strong>强一致性</strong>：所有读操作都能看到最新的写操作结果。</li><li><strong>弱一致性</strong>：系统不保证读操作能看到最新的写操作结果。</li><li><strong>最终一致性</strong>：在没有新更新的情况下，所有副本最终会达到一致状态</li></ul></blockquote><p><strong>分布式系统中的负载均衡是什么？</strong></p><blockquote><p>负载均衡是将工作负载均匀分配到多个节点上的技术，以提高系统的性能和可靠性。常见的负载均衡算法包括：</p><ul><li><strong>轮询（Round Robin）</strong>：依次将请求分配给每个节点。</li><li><strong>最小连接数（Least Connections）</strong>：将请求分配给当前连接数最少的节点。</li></ul></blockquote><p><strong>分布式系统中的故障处理有哪些策略？</strong></p><blockquote><ul><li><strong>容错（Fault Tolerance）</strong>：通过冗余设计和备份来应对节点故障。</li><li><strong>重试机制</strong>：在操作失败时自动重试，以应对暂时性故障。</li><li><strong>故障检测和恢复</strong>：检测故障节点并自动恢复服务</li></ul></blockquote><p><strong>分布式系统中的一致性协议有哪些？</strong></p><blockquote><ul><li><strong>Paxos</strong>：一种广泛使用的分布式一致性协议，保证在部分节点故障情况下仍能达成一致。</li><li><strong>Raft</strong>：一种相对易于理解和实现的一致性协议，提供领导选举和日志复制机制。</li></ul></blockquote><p><strong>什么是CAP定理？</strong></p><blockquote><p>CAP定理指出，在分布式系统中，无法同时满足一致性（Consistency）、可用性（Availability）和分区容忍性（Partition Tolerance）。在设计系统时，必须在这三者之间进行权衡。通常选择分区容忍性，然后在一致性和可用性之间做出取舍</p></blockquote><p><strong>分布式系统中的事务处理如何实现？</strong></p><blockquote><p>分布式事务处理需要确保跨多个节点的操作要么全部成功，要么全部失败。常见模型包括：</p><ul><li><strong>两阶段提交（2PC）</strong>：协调者首先请求所有参与者准备提交，然后在所有参与者准备好后发出提交命令。</li><li><strong>三阶段提交（3PC）</strong>：在两阶段提交基础上增加一个预提交阶段，以提高容错性。</li></ul></blockquote><hr><h4 id="问题记录1"><a class="header-anchor" href="#问题记录1"></a>问题记录1</h4><blockquote><p>答题模板：</p><p>各自概念</p><p>对比\优缺点</p></blockquote><h5 id="C-C-语言基础部分"><a class="header-anchor" href="#C-C-语言基础部分"></a>C/C++ 语言基础部分</h5><p>常见问题：智能指针、多态、虚函数、stl原理。</p><ul><li><p>智能指针实现原理</p></li><li><p>智能指针，里面的计数器何时会改变</p></li><li><p>智能指针和管理的对象分别在哪个区（智能指针本身在栈区，托管的资源在堆区，利用了栈对象超出生命周期后自动析构的特征，所以无需手动delete释放资源。</p></li><li><p>面向对象的特性：多态原理</p></li><li><p>介绍一下虚函数，虚函数怎么实现的</p></li><li><p>多态和继承在什么情况下使用</p></li><li><p>除了多态和继承还有什么面向对象方法</p></li><li><p>C++内存分布。什么样的数据在栈区，什么样的在堆区</p></li><li><p>C++内存管理（RAII啥的）</p><p>C++中的内存管理涉及多个方面：首先，内存被分为栈、堆、全局/静态存储区和常量区。栈上的内存分配是自动管理的，而堆上的内存需要我们手动管理，通常使用<code>new</code>和<code>delete</code>或者智能指针来避免内存泄漏和悬挂指针的问题。智能指针如<code>std::unique_ptr</code>和<code>std::shared_ptr</code>提供了自动化的内存管理，尤其是在复杂的应用场景中非常有用。此外，C++还支持RAII原则，通过构造和析构函数自动管理资源，这有助于确保在异常或早期返回时释放资源。常见的内存管理问题包括内存泄漏、悬挂指针、缓冲区溢出和双重释放。我在项目中通常使用智能指针来管理资源，以避免这些问题，并遵循RAII的原则确保异常安全性</p></li><li><p>C++从源程序到可执行程序的过程</p></li><li><p>一个对象=另一个对象会发生什么（赋值构造函数）</p></li><li><p>如果new了之后出了问题直接return。会导致内存泄漏。怎么办（智能指针，raii）</p></li><li><p>c++11的智能指针有哪些。weak_ptr的使用场景。什么情况下会产生循环引用</p></li><li><p>多进程fork后不同进程会共享哪些资源</p></li><li><p>多线程里线程的同步方式有哪些</p></li><li><p>size_of是在编译期还是在运行期确定</p></li><li><p>函数重载的机制。重载是在编译期还是在运行期确定</p></li><li><p>指针常量和常量指针</p></li><li><p>vector的原理，怎么扩容</p></li><li><p>介绍一下const</p></li><li><p>引用和指针的区别</p></li><li><p>Cpp新特性知道哪些</p></li><li><p>类型转换</p></li><li><p>RAII基于什么实现的（生命周期、作用域、构造析构</p></li><li><p>手撕：Unique_ptr，控制权转移(移动语义）</p></li><li><p>手撕：类继承，堆栈上分别代码实现多态</p></li><li><p>unique_ptr和shared_ptr区别</p></li><li><p>右值引用</p></li><li><p>函数参数可不可以传右值</p></li><li><p>参考c/c++堆栈实现自己的堆栈。要求：不能用stl容器。</p></li><li><p>stl容器了解吗？底层如何实现：vector数组，map红黑树，红黑树的实现</p></li><li><p>完美转发介绍一下 去掉std::forward会怎样？</p></li><li><p>介绍一下unique_lock和lock_guard区别？</p></li><li><p>C代码中引用C++代码有时候会报错为什么？</p></li><li><p>静态多态有什么？虚函数原理 虚表是什么时候建立的 为什么要把析构函数设置成虚函数？</p></li><li><p>map为啥用红黑树不用avl树？（几乎所有面试都问了map和unordered_map区别）</p></li><li><p>inline 失效场景</p></li><li><p>C++ 中 struct 和 class 区别</p></li><li><p>如何防止一个头文件 include 多次</p></li><li><p>lambda表达式的理解，它可以捕获哪些类型</p></li><li><p>友元friend介绍</p></li><li><p>move函数</p></li><li><p>模版类的作用</p></li><li><p>模版和泛型的区别</p></li><li><p>内存管理：C++的new和malloc的区别</p></li><li><p>new可以重载吗，可以改写new函数吗</p></li><li><p>C++中的map和unordered_map的区别和使用场景</p></li><li><p>他们是线程安全的吗</p></li><li><p>c++标准库里优先队列是怎么实现的？</p></li><li><p>gcc编译的过程</p></li><li><p>C++ Coroutine</p></li><li><p>extern C有什么作用</p></li><li><p>c++ memoryorder/elf文件格式/中断对于操作系统的作</p></li><li><p>C++的符号表</p></li><li><p>C++的单元测试</p></li></ul><h5 id="数据结构"><a class="header-anchor" href="#数据结构"></a>数据结构</h5><p>常见问题：链表、排序、二叉树。</p><ul><li>数组和链表区别和优缺点</li><li>快速排序</li><li>堆排序是怎么做的</li><li>冒泡排序</li><li>二分查找（复杂度）</li><li>hash表数据很大。rehash的代价很高，怎么办</li><li>二叉树前序遍历非递归</li><li>链表反转</li><li>二叉树输出每一层最右边的节点</li><li>千万级数组如何求最大k个数？（用最小堆反之最大堆） 千万数据范围有限，0到1000，有很多重复的，按频率排序怎么处理？</li><li>计算二叉树层高。</li><li>给一个连续非空子数组，找它乘积最大的（动态规划）</li><li>排序算法. 哪些是稳定的，哪些不稳定的</li><li>树的深度和高度。一开始分别用了一个层序遍历和一个dfs，然后面试官问能否都在一个dfs里面呢，提示了一下在dfs是否可以传一个参数，然后解决了。</li><li>布隆过滤器介绍</li><li>为什么不用布隆过滤器</li><li>.数据结构相关，图的种类，表示方法，图有哪些经典算法+描述算法</li><li>求最大的k个数字，解法：优先队列（堆）或者快速排序</li><li>一个大数问题，解法：转换为字符串解决，这题没写好，leetcode应该有很多类似的问题</li><li>hash解决冲突 （ 开放定址法、链地址法、再哈希法、建立公共溢出区 ），四种方式详细的过程、思路</li><li>链地址法和再哈希法之间的关联和区别，两者分别适用场景，两者底层的数据结构，关联和区别</li><li>链表和数组的底层结构设计、关联、区别、应用场景</li></ul><h5 id="gdb-gcc-g"><a class="header-anchor" href="#gdb-gcc-g"></a>gdb/gcc/g++</h5><ul><li>什么是GDB？它用于做什么？</li><li>GDB的常用命令有哪些？</li><li>如何在GDB中设置断点？</li><li>如何在GDB中查看变量的值？</li><li>如何使用GDB进行程序调试时，定位内存泄漏问题？</li><li>请解释GCC和G++之间的区别。</li><li>GCC和G++都可以编译C++代码吗？如果可以，有什么不同之处？</li><li>GCC的常用编译选项有哪些？</li><li>G++的常用编译选项有哪些？</li><li>如何在GCC/G++中指定特定版本的标准（如C++11或C++14）进行编译？</li><li>怎么debug，怎么看内存泄漏。</li><li>gdb 使用 -> 多线程程序切换到某线程栈帧 -> 如何查看寄存器值</li><li>怎么分析C++的core文件</li><li>GDB有哪些命令</li><li>gcc和g++的区别</li><li>Linux下程序有问题，如何调试？（答GDB打开，打上Breakpoint进行调试）</li></ul>]]></content>
<summary type="html">面试总结</summary>
<category term="Learning" scheme="https://ninokz.github.io/categories/Learning/"/>
<category term="C++" scheme="https://ninokz.github.io/tags/C/"/>
</entry>
</feed>