https://blog.zhuwenq.cc/icon.png 2025-03-21T16:09:05.020Z https://blog.zhuwenq.cc/ zhuwenq Hexo https://blog.zhuwenq.cc/std-string-%E6%8B%BC%E6%8E%A5%E6%93%8D%E4%BD%9C%E7%9A%84%E6%80%A7%E8%83%BD%E5%88%86%E6%9E%90/ 2024-06-23T07:34:26.000Z 2025-03-21T16:09:05.020Z

<p>偶然的机会在工作中对 <code>std::string</code> 的拼接操作进行了对比, 本文记录对 4 种拼接方式的简单 benchmark:</p> <ol> <li><code>+</code> 操作符</li> <li><code>+=</code> 操作符</li> <li><code>append</code> 成员</li> <li><code>stringstream</code> 的 <code>&lt;&lt;</code> 操作符</li> </ol>

https://blog.zhuwenq.cc/%E4%B8%80%E4%B8%AA%E7%AE%80%E5%8D%95%E7%9A%84-std-function-%E5%AE%9E%E7%8E%B0/ 2023-08-10T05:25:09.000Z 2025-03-21T16:09:05.021Z

<p>一个简单的 <code>std::function</code> 实现, 能够完成基本功能, 即可以代理:</p> <ol> <li>普通函数</li> <li><code>bind</code> 表达式</li> <li><code>lambda</code> 表达式以及普通 <code>functor</code></li> <li>成员函数</li> <li>成员变量</li> </ol> <p><code>functor</code> 存储部分使用继承体系擦除 <code>functor</code> 类型, 保留返回值以及参数列表类型. 核心的调用部分则是直接使用 <code>std::invoke</code> 实现, 同时也没有做 <code>functor</code> 大小的区分, 统一存在堆上.</p>

https://blog.zhuwenq.cc/%E5%A6%82%E4%BD%95%E5%88%A4%E6%96%AD%E4%B8%80%E4%B8%AA%E7%82%B9%E5%9C%A8%E4%B8%80%E4%B8%AA%E4%B8%89%E8%A7%92%E5%BD%A2%E5%86%85%E9%83%A8/ 2023-07-16T14:31:52.000Z 2025-03-21T16:09:05.024Z

<p>最近遇到这么一个问题: 给定一个点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>P</mi></mrow><annotation encoding="application/x-tex">P</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.13889em;">P</span></span></span></span> 和三角形的三个点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>A</mi><mo separator="true">,</mo><mi>B</mi><mo separator="true">,</mo><mi>C</mi></mrow><annotation encoding="application/x-tex">A, B, C</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8777699999999999em;vertical-align:-0.19444em;"></span><span class="mord mathnormal">A</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.05017em;">B</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord mathnormal" style="margin-right:0.07153em;">C</span></span></span></span>, 如何判断点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>P</mi></mrow><annotation encoding="application/x-tex">P</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathnormal" style="margin-right:0.13889em;">P</span></span></span></span> 是否在 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi mathvariant="normal">△</mi><mrow><mi>A</mi><mi>B</mi><mi>C</mi></mrow></msub></mrow><annotation encoding="application/x-tex">\triangle_{ABC}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8888799999999999em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord">△</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.32833099999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;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 mathnormal mtight">A</span><span class="mord mathnormal mtight" style="margin-right:0.05017em;">B</span><span class="mord mathnormal mtight" style="margin-right:0.07153em;">C</span></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></span></span> 内部?</p>

https://blog.zhuwenq.cc/Modern-C-Concurrency-Utilities-06-Promise-Future-and-Asynchronous/ 2023-06-24T13:44:54.000Z 2025-03-21T16:09:04.945Z

<p>「期值」是标准库为异步任务中返回值以及异常的传递提供的基础设施. 具体的做法是将这些值关联到共享的「future」对象上. 异步任务可以向这些期值对象中写入返回值或异常值, 异步任务的发起线程则可以通过这些期值对象等待, 读取, 检查其所需要的异步结果. 标准库中为上述功能提供的设施即 <code>std::promise</code> 和 <code>std::future</code>.</p>

https://blog.zhuwenq.cc/Modern-C-Concurrency-Utilities-05-Condition-variable-Semaphore-and-Synchronization/ 2023-06-23T15:55:24.000Z 2025-03-21T16:09:04.945Z

<p>Condition variable 和 Semaphore 是并发编程中用于同步控制和交互的原语. 多个并发线程可以使用 Condition variable 彼此交互, 一些线程可以通过 Condition variable 等待 (wait) 其他线程的通知 (notification). <em>Condition variable 总是和 mutex 关联使用</em>. Semaphore 相比 Condition variable 更加轻量, 它用来限制多个线程对共享资源的并发访问.</p>

https://blog.zhuwenq.cc/Modern-C-Concurrency-Utilities-04-Mutex-Lock-and-Concurrent-Access-Control/ 2023-06-21T13:59:51.000Z 2025-03-21T16:09:04.945Z

<p><code>mutex</code> 即 mutual exclusion, 表示一种互斥语义. 所谓互斥, 实际上是指所有权的唯一性, 即同一时刻一个互斥量只能由一个所有者持有. 在并发语境中, 互斥量这一原语的所有者一般是「线程」, 它的作用是用于阻止多个线程同时访问共享的资源, 从而避免 data race 并为多个线程的执行提供实现「同步」的机制.</p>

https://blog.zhuwenq.cc/Modern-C-Concurrency-Utilities-03-Atomic-and-Memory-Ordering/ 2023-06-21T06:29:49.000Z 2025-03-21T16:09:04.945Z

<p>Atomic 提供了开发高性能无锁 (lock free) 结构的工具和接口, 对于内置类型或自定义类型, 也可以通过 <code>atomic&lt;&gt;</code> 模板包装成支持原子操作的类型, 以实现并发安全.</p>

https://blog.zhuwenq.cc/Modern-C-Concurrency-Utilities-02-CPU-Cache-and-false-sharing/ 2023-06-20T08:15:09.000Z 2025-03-21T16:09:04.944Z

<p>C++ 17 提供了两个编译时常量, 用于表示 CPU Cache 的一些参数. 合理使用这两个编译时常量可以避免在多级 Cache 结构的计算机上并发程序频繁访问同一个对象不同成员时可能发生的 <strong>伪共享 (false sharing)</strong> 问题.</p>

https://blog.zhuwenq.cc/Modern-C-Concurrency-Utilities-01-Thread-and-Concurrent-Execution/ 2023-06-19T14:35:31.000Z 2025-03-21T16:09:04.944Z

<p>C++ 11 及之后的版本中提供了一系列并发编程的工具和对并发控制原语的抽象封装, 如 <code>thread</code>, <code>atomic</code>, <code>mutex</code>, <code>condition_varible</code> 等. 本文介绍 <code>thread</code> 以及 <code>jthread</code> 的基本语义和功能, 它们在实际场景中的 best practice 和与之密切相关的编程模式不在本文讨论范围之内.</p>

https://blog.zhuwenq.cc/C-storage-duration-and-specifiers/ 2023-06-19T08:17:18.000Z 2025-03-21T16:09:04.910Z

<p>偶然在 vscode 的代码提示中看到了 <code>thread_local</code> 这个关键字, 心想 C++ 中什么时候提供了这种东西. 翻了下 cppreference 才知道早在 C++ 11 中就引入了这个修饰符, 用于声明线程生命周期. 趁此机会系统地看了下 C++ 变量的 4 种生命周期, 特此记录.</p>

https://blog.zhuwenq.cc/C-black-magic-%E5%88%A9%E7%94%A8%E5%8F%8B%E5%85%83%E5%87%BD%E6%95%B0%E5%92%8C%E6%98%BE%E5%BC%8F%E5%AE%9E%E4%BE%8B%E5%8C%96%E7%AA%81%E7%A0%B4%E8%AE%BF%E9%97%AE%E6%9D%83%E9%99%90/ 2023-06-03T14:34:16.000Z 2025-03-21T16:09:04.910Z

<p>C++ 中的非继承类有两种访问权限, <code>private</code> 和 <code>public</code>. 一般来说, <code>private</code> 只允许类型内部使用, 不允许外部访问. 然而, 由于 C++ 语言巨大的复杂性, 这一约束存在若干漏洞. 一种简单的做法就是假设 C++ 编译器不会对类对象的内存布局做奇怪的扰动, 这一假设通常是正确的, 因此可以通过猜测私有成员相对对象整体的地址偏移量访问私有成员. 或者更加方便地通过定义一个成员完全相同但访问权限相反的类, 并将原类对象的指针转换成新类的指针的方式访问原类对象的私有指针.</p> <p>这两种方法本质上都基于「假设」, 即假设 C++ 编译器不会对类型的成员做特殊的处理. 本文介绍一种更加优雅的方法, 可以稳定地实现对私有成员的访问.</p>

https://blog.zhuwenq.cc/C-%E5%AF%B9%E8%B1%A1%E3%80%81%E8%99%9A%E5%87%BD%E6%95%B0%E4%B8%8E%E7%BB%A7%E6%89%BF/ 2023-04-14T08:00:26.000Z 2025-03-21T16:09:04.911Z

<p>C++ 中以继承的方式实现动态多态是存在额外开销的, 具体地说，C++ 对象使用了额外的内存保存关于基类信息才实现了运行时多态. 但这种额外信息究竟以何种方式在对象的内存中报错对我来说仍是未知. 受到前人文章的启发, 本文借助 GDB 调试器一步步地观察记录 C++ 对象的内存布局, 力求理解实际 C++ 编译器 (gcc 9.4.0) 对 C++ 对象的内存布局以及派生类的实现.</p>

https://blog.zhuwenq.cc/%E5%86%85%E5%AD%98%E5%B1%8F%E9%9A%9C%E5%92%8C-C-%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B/ 2023-04-08T14:47:44.000Z 2025-03-21T16:09:05.022Z

<p>Memory Barrier 是 CPU 提供的一种机制, 它的作用是在程序中设置一个内存屏障, CPU 会保证所有在 Memory Barrier 之前的代码对内存的访问 (改动) 在 Memory Barrier 之后都是可见的. 这一保证据有两方面的效应:</p> <ol> <li>所有 Memory Barrier 之后的代码都不能被重排 (Reordering) 到 Memory Barrier 之前执行</li> <li>当执行到 Memory Barrier 时, CPU 必须在所有 Core 之间同步 Cache, 保证此刻所有 Core 看到的内存是一致的.</li> </ol> <p>Memory Order 是 C++ 11 提供的一种并发编程机制, 它允许显式地限制编译器/CPU 对指令的重排 (Reordering), 以及显式地控制多核 CPU Cache 之间的同步. 其效果是使得不同线程/不同 CPU Core 所观察到的原子操作附近的内存操作具有可预测的顺序.</p>

https://blog.zhuwenq.cc/%E5%85%B1%E4%BA%AB%E7%9B%AE%E6%A0%87%E6%96%87%E4%BB%B6-%E5%85%B1%E4%BA%AB%E5%BA%93/ 2023-04-02T12:08:44.000Z 2025-03-21T16:09:05.021Z

<p>对于被广泛使用的标准库或其他库, 如果一个系统中多个程序都在引用相同的符号, 此时使用静态库将需要为每个程序都加载一份符号定义的代码和数据, 这对内存是极大的浪费.</p> <p>共享库 (shared library) 是解决静态库这一问题的产物. 共享库是一个目标模块, 在运行或加载时可以被加载到任意内存地址, 并和一个在内存中的程序链接起来. 这一过程称为动态链接, 是由一个叫做 <em>动态链接器 (dynamic linker)</em> 的程序执行的.</p>

https://blog.zhuwenq.cc/%E5%8F%AF%E6%89%A7%E8%A1%8C%E7%9B%AE%E6%A0%87%E6%96%87%E4%BB%B6/ 2023-04-02T12:03:27.000Z 2025-03-21T16:09:05.023Z

<p>链接器 <a href="../Linkage">链接</a> 的结果是生成一个可执行目标文件, 这个目标文件中包含将程序加载到内存并运行的所有信息. 下图是一个 ELF 可执行目标文件所包含的信息:</p> <img data-src="/%E5%8F%AF%E6%89%A7%E8%A1%8C%E7%9B%AE%E6%A0%87%E6%96%87%E4%BB%B6/1.png" class="">

https://blog.zhuwenq.cc/%E5%8F%AF%E9%87%8D%E5%AE%9A%E4%BD%8D%E7%9B%AE%E6%A0%87%E6%96%87%E4%BB%B6/ 2023-04-02T11:19:23.000Z 2025-03-21T16:09:05.024Z

<p>现代 x86-64 系统使用可执行可链接格式文件 (Executable and Linkable Format, ELF)</p> <p>ELF 文件的结构:</p> <img data-src="/%E5%8F%AF%E9%87%8D%E5%AE%9A%E4%BD%8D%E7%9B%AE%E6%A0%87%E6%96%87%E4%BB%B6/1.png" class="">

https://blog.zhuwenq.cc/Linkage/ 2023-04-02T11:13:52.000Z 2025-03-21T16:09:04.944Z

<p>程序从源代码到可执行文件需要经过 4 个步骤, 链接就是其中重要的一步.</p> <p>链接器的主要工作是将具备引用关系的不同编译单元的编译结果 (i.e. 可重定位目标文件) 相互连接, 组成一个可执行文件.</p> <p>静态链接器以一组可重定位目标文件和命令行参数作为输入, 生成一个完全链接的, 可以加载运行的可执行目标文件.</p>

https://blog.zhuwenq.cc/Cache/ 2023-03-15T14:45:25.000Z 2025-03-21T16:09:04.912Z

<p>计算机存储器具有金字塔式结构, 即: 较高层的存储器容量小速度快, 低层的存储器容量大速度慢, 计算机通过缓存的方式提高储存系统的整体性能.</p>

https://blog.zhuwenq.cc/Xv6-Operating-system-03-page-table/ 2023-03-09T11:13:11.000Z 2025-03-21T16:09:05.019Z

<p>页表是操作系统之所以能够为进程提供独立的地址空间和内存所依赖的机制。</p>

https://blog.zhuwenq.cc/C-%E6%A8%A1%E6%9D%BF03-%E5%9F%BA%E6%9C%AC%E6%8A%80%E5%B7%A7/ 2023-03-06T12:04:48.000Z 2025-03-21T16:09:04.912Z

<p>C++ template 中关于实践的一些技巧和基础机制</p>