﻿<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
  <channel>
    <title>C++教程</title>
    <link>https://www.herecours.com//www.herecours.com/list-44-0.html</link>
    <description>Latest 50 infos of C++教程</description>
    <copyright>Copyright(C) Empire CMS</copyright>
    <generator>Empire CMS by Empire Studio.</generator>
    <lastBuildDate>Mon, 03 Aug 2026 02:59:04 +0000</lastBuildDate>
    <ttl>60</ttl>
    <image>
      <url>https://www.herecours.com//www.herecours.com/e/data/images/rss.gif</url>
      <title>帝国网站管理系统</title>
      <link>https://www.herecours.com//www.herecours.com/</link>
    </image>
    <item>
      <title><![CDATA[SQL性能优化之压测404的根因追查与解决方案]]></title>
      <description><![CDATA[ 一、背景二、问题 SQL原始 SQL（MySQL 版本）三、执行计划解读MySQL 版本执行计划达梦版本执行计划四、三大核心问题问题一：全表扫描（type = ALL）问题二：DEPENDENT SUBQUERY（N+1 问题）问题三：Using filesort（额外排序）五、优化方案改写思路：两段式查询优化后 SQL（MySQL 版本）优化后执行计划达梦版本额外改写推荐覆盖索引六、优化前后对比 ]]></description>
      <link>https://www.herecours.com/backend/2026/03-25/151675.html</link>
      <guid>https://www.herecours.com/backend/2026/03-25/151675.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Wed, 25 Mar 2026 01:11:19 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[PostgreSQL中进行数据导入和导出的示例代码]]></title>
      <description><![CDATA[ 一、数据导入1.1 使用COPY命令导入数据1.1.1 示例：从 CSV 文件导入数据1.2 使用COPY命令导入数据1.2.1 示例：使用COPY导入数据1.3 使用pgAdmin导入数据二、数据导出2.1 使用COPY命令导出数据2.1.1 示例：导出数据到 CSV 文件2.2 使用COPY命令导出数据2.2.1 示例：使用COPY导出数据2.3 使用pgAdmin导出数据三、使用pg_dum ]]></description>
      <link>https://www.herecours.com/backend/2026/03-15/150072.html</link>
      <guid>https://www.herecours.com/backend/2026/03-15/150072.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Sun, 15 Mar 2026 07:11:21 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[redis多级缓存的用法及说明]]></title>
      <description><![CDATA[ 一、什么是多级缓存二、搭建环境2.1.安装docker2.2.安装mysql2.3.导入sql2.4.导入springboot项目三、JVM进程缓存3.1.初识Caffeine3.2.实现JVM进程缓存四、Lua语法入门4.1.初识Lua4.2.变量和循环4.2.1.Lua的数据类型4.2.2.声明变量4.2.3.循环4.3.条件控制、函数4.3.1.函数4.3.2.条件控制4.3.3.案例五、实 ]]></description>
      <link>https://www.herecours.com/backend/2026/03-12/145996.html</link>
      <guid>https://www.herecours.com/backend/2026/03-12/145996.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Thu, 12 Mar 2026 08:15:34 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[MySQL数据误删恢复的完整指南]]></title>
      <description><![CDATA[ 引言一、drop 表恢复：全量备份 + Binlog 增量补充1.1 恢复核心逻辑1.2 必备前提（关键！）1.3 实战操作步骤（附完整命令）步骤 1：日常环境准备（提前完成）步骤 2：模拟误操作场景步骤 3：全量备份导入恢复实例步骤 4：Binlog 增量数据恢复步骤 5：数据回迁源实例二、delete 误删恢复：my2sql 快速回滚2.1 恢复核心逻辑2.2 前提条件与工具准备必备条件 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-27/70411.html</link>
      <guid>https://www.herecours.com/backend/2026/02-27/70411.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Fri, 27 Feb 2026 01:13:02 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 同步操作和强制排序]]></title>
      <description><![CDATA[ C++ 同步操作和强制排序，假设你有两个线程，一个向数据结构中填充数据，另一个读取数据结构中的数据。为了避免恶性条件竞争，第一个线程设置一个标志，用来表明数据已经准备就绪，并且第二个线程在这个标志设置前不能读取数据。下面的程序清单就是这样的情况。清单2 不同线程对数据的读写#include #include #include std::vecto ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15358.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15358.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:39:37 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 内存模型基础]]></title>
      <description><![CDATA[ C++ 内存模型基础，这里从两方面来讲内存模型：一方面是基本结构，这与事务在内存中是怎样布局的有关；另一方面就是并发。对于并发基本结构很重要，特别是在低层原子操作。所以我将会从基本结构讲起。C++中它与所有的对象和内存位置有关。C++ 对象和内存位置在一个C++程序中的所有数据都是由对象(objects)构成。这不是说你可以创建一 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15352.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15352.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:39:25 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 原子操作和原子类型]]></title>
      <description><![CDATA[ C++中的原子操作和原子类型，原子操作 是个不可分割的操作。在系统的所有线程中，你是不可能观察到原子操作完成了一半这种情况的；它要么就是做了，要么就是没做，只有这两种可能。如果从对象读取值的加载操作是 原子 的，而且对这个对象的所有修改操作也是 原子 的，那么加载操作得到的值要么是对象的初始值，要么是某次修改操作存入的值。 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15351.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15351.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:39:24 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 内存模型和原子类型操作]]></title>
      <description><![CDATA[ C++内存模型和原子类型操作，主要内容C++11内存模型详解标准库提供的原子类型使用各种原子类型原子操作实现线程同步功能C++11标准中，有一个十分重要特性，常被程序员们所忽略。它不是一个新语法特性，也不是新工具，它就是多线程(感知)内存模型。内存模型没有明确的定义基本部件应该如何工作的话，之前介绍的那些工具就无法正常工作。 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15347.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15347.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:39:08 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 使用同步操作简化代码]]></title>
      <description><![CDATA[ C++ 使用同步操作简化代码，同步工具的使用在本章称为构建块，你可以之关注那些需要同步的操作，而非具体使用的机制。当需要为程序的并发时，这是一种可以帮助你简化你的代码的方式，提供更多的函数化的方法。比起在多个线程间直接共享数据，每个任务拥有自己的数据会应该会更好，并且结果可以对其他线程进行广播，这就需要使用“期望”来完 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15314.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15314.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:35:04 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 使用期望等待一次性事件]]></title>
      <description><![CDATA[ C++ 使用期望等待一次性事件，假设你乘飞机去国外度假。当你到达机场，并且办理完各种登机手续后，你还需要等待机场广播通知你登机，可能要等很多个小时。你可能会在候机室里面找一些事情来打发时间，比如：读书，上网，或者来一杯价格不菲的机场咖啡，不过从根本上来说你就在等待一件事情：机场广播能够登机的时间。给定的飞机班次再之后没有可 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15312.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15312.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:35:01 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 限定等待时间]]></title>
      <description><![CDATA[ C++ 限定等待时间，之前介绍过的所有阻塞调用，将会阻塞一段不确定的时间，将线程挂起直到等待的事件发生。在很多情况下，这样的方式很不错，但是在其他一些情况下，你就需要限制一下线程等待的时间了。这允许你发送一些类似“我还存活”的信息，无论是对交互式用户，或是其他进程，亦或当用户放弃等待，你可以按下“取消”键直接终止等待。介绍 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15308.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15308.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:34:46 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 同步并发操作]]></title>
      <description><![CDATA[ C++ 同步并发操作，本章主要内容等待事件带有期望的等待一次性事件在限定时间内等待使用同步操作简化代码在C++ 线程间共享数据中，我们看到各种在线程间保护共享数据的方法。当你不仅想要保护数据，还想对单独的线程进行同步。例如，在第一个线程完成前，可能需要等待另一个线程执行完成。通常情况下，线程会等待一个特定事件的发生，或者 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15306.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15306.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:34:45 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 等待一个事件或其他条件]]></title>
      <description><![CDATA[ C++ 等待一个事件或其他条件，假设你在旅游，而且正在一辆在夜间运行的火车上。在夜间，如何在正确的站点下车呢？一种方法是整晚都要醒着，然后注意到了哪一站。这样，你就不会错过你要到达的站点，但是这样会让你感到很疲倦。另外，你可以看一下时间表，估计一下火车到达目的地的时间，然后在一个稍早的时间点上设置闹铃，然后你就可以安心的睡会 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15307.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15307.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:34:45 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 共享数据带来的问题]]></title>
      <description><![CDATA[ C++ 共享数据带来的问题，当涉及到共享数据时，问题很可能是因为共享数据修改所导致。如果共享数据是只读的，那么只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数据。但是，当一个或多个线程要修改共享数据时，就会产生很多麻烦。这种情况下，就必须小心谨慎，才能确保一切所有线程都工作正常。不变量(invaria ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15301.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15301.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:34:04 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 线程间共享数据]]></title>
      <description><![CDATA[ C++ 线程间共享数据，本章主要内容共享数据带来的问题使用互斥量保护数据数据保护的替代方案C++ 线程管理中，我们已经对线程管理有所了解了，现在让我们来看一下“共享数据的那些事”。想象一下，你和你的朋友合租一个公寓，公寓中只有一个厨房和一个卫生间。当你的朋友在卫生间时，你就会不能使用了(除非你们特别好，好到可以在同时使用 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15293.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15293.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:33:46 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 保护共享数据的替代设施]]></title>
      <description><![CDATA[ C++ 保护共享数据的替代设施，互斥量是最通用的机制，但其并非保护共享数据的唯一方式。这里有很多替代方式可以在特定情况下，提供更加合适的保护。一个特别极端(但十分常见)的情况就是，共享数据在并发访问和初始化时(都需要保护)，但是之后需要进行隐式同步。这可能是因为数据作为只读方式创建，所以没有同步问题；或者因为必要的保护作 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15294.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15294.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:33:46 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 使用互斥量保护共享数据]]></title>
      <description><![CDATA[ C++ 使用互斥量保护共享数据，当程序中有共享数据，肯定不想让其陷入条件竞争，或是不变量被破坏。那么，将所有访问共享数据结构的代码都标记为互斥岂不是更好？这样任何一个线程在执行这些代码时，其他任何线程试图访问共享数据结构，就必须等到那一段代码执行结束。于是，一个线程就不可能会看到被破坏的不变量，除非它本身就是修改共享数据 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15295.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15295.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:33:46 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 转移线程所有权]]></title>
      <description><![CDATA[ C++ 转移线程所有权，假设要写一个在后台启动线程的函数，想通过新线程返回的所有权去调用这个函数，而不是等待线程结束再去调用；或完全与之相反的想法：创建一个线程，并在函数中转移所有权，都必须要等待线程结束。总之，新线程的所有权都需要转移。这就是移动引入std::thread的原因，C++标准库中有很多_资源占有_resource-owning类型，比如s ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15272.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15272.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:48 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 线程管理]]></title>
      <description><![CDATA[ C++ 线程管理，主要内容启动新线程等待线程与分离线程线程唯一标识符好的！看来你已经决定使用多线程了。先做点什么呢?启动线程、结束线程，还是如何监管线程？C++标准库中只需要管理std::thread关联的线程，无需把注意力放在其他方面。不过，标准库太灵活，所以管理起来不会太容易。本章将从基本开始：启动一个线程，等待这个线程结束，或放在 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15267.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15267.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:47 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 向线程函数传递参数]]></title>
      <description><![CDATA[ C++ 向线程函数传递参数，清单2.4中，向std::thread构造函数中的可调用对象，或函数传递一个参数很简单。需要注意的是，默认参数要拷贝到线程独立内存中，即使参数是引用的形式，也可以在新线程中进行访问。再来看一个例子：void f(int i, std::string const&amp;amp; s);std::thread t(f, 3, &amp;quot;hello&amp;quot;);代码创建了一个调用f(3, hello)的线 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15268.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15268.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:47 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 线程管理的基础]]></title>
      <description><![CDATA[ C++ 线程管理的基础，每个程序至少有一个线程：执行main函数的线程，其余线程有其各自的入口函数。线程与原始线程以main为入口函数的线程同时运行。如同main函数执行完会退出一样，当线程执行完入口函数后，线程也会退出。在为一个线程创建了一个std::thread对象后，需要等待这个线程结束；不过，线程需要先进行启动。下面就来启动线程。C++ ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15269.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15269.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:47 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 运行时决定线程数量]]></title>
      <description><![CDATA[ C++ 运行时决定线程数量，std::thread::hardware_concurrency()在新版C++标准库中是一个很有用的函数。这个函数将返回能同时并发在一个程序中的线程数量。例如，多核系统中，返回值可以是CPU核芯的数量。返回值也仅仅是一个提示，当系统信息无法获取时，函数也会返回0。但是，这也无法掩盖这个函数对启动线程数量的帮助。清单2.8实现了 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15270.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15270.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:47 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 标识线程]]></title>
      <description><![CDATA[ C++ 标识线程，线程标识类型是std::thread::id，可以通过两种方式进行检索。第一种，可以通过调用std::thread对象的成员函数get_id()来直接获取。如果std::thread对象没有与任何执行线程相关联，get_id()将返回std::thread::type默认构造值，这个值表示“无线程”。第二种，当前线程中调用std::this_thread::get_id()(这个 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15271.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15271.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:47 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 同步操作和强制排序]]></title>
      <description><![CDATA[ C++ 同步操作和强制排序，假设你有两个线程，一个向数据结构中填充数据，另一个读取数据结构中的数据。为了避免恶性条件竞争，第一个线程设置一个标志，用来表明数据已经准备就绪，并且第二个线程在这个标志设置前不能读取数据。下面的程序清单就是这样的情况。清单2 不同线程对数据的读写#include #include #include std::vecto ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15256.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15256.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:20 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 并发和多线程是什么]]></title>
      <description><![CDATA[ C++ 何谓并发最简单和最基本的并发,是指两个或更多独立的活动同时发生。并发在生活中随处可见，我们可以一边走路一边说话，也可以两只手同时作不同的动作，还有我们每个人都过着相互独立的生活——当我在游泳的时候，你可以看球赛，等等。计算机系统中的并发计算机领域的并发指的是在单个系统里同时执行多个独立的任务，而非顺序的进行 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15257.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15257.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:20 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 共享数据带来的问题]]></title>
      <description><![CDATA[ C++ 共享数据带来的问题，当涉及到共享数据时，问题很可能是因为共享数据修改所导致。如果共享数据是只读的，那么只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数据。但是，当一个或多个线程要修改共享数据时，就会产生很多麻烦。这种情况下，就必须小心谨慎，才能确保一切所有线程都工作正常。不变量(invaria ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15252.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15252.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:13 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 并发和多线程是什么]]></title>
      <description><![CDATA[ C++ 何谓并发最简单和最基本的并发,是指两个或更多独立的活动同时发生。并发在生活中随处可见，我们可以一边走路一边说话，也可以两只手同时作不同的动作，还有我们每个人都过着相互独立的生活——当我在游泳的时候，你可以看球赛，等等。计算机系统中的并发计算机领域的并发指的是在单个系统里同时执行多个独立的任务，而非顺序的进行 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15251.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15251.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:12 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 向线程函数传递参数]]></title>
      <description><![CDATA[ C++ 向线程函数传递参数，清单2.4中，向std::thread构造函数中的可调用对象，或函数传递一个参数很简单。需要注意的是，默认参数要拷贝到线程独立内存中，即使参数是引用的形式，也可以在新线程中进行访问。再来看一个例子：void f(int i, std::string const&amp;amp; s);std::thread t(f, 3, &amp;quot;hello&amp;quot;);代码创建了一个调用f(3, hello)的线 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15249.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15249.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:10 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 运行时决定线程数量]]></title>
      <description><![CDATA[ C++ 运行时决定线程数量，std::thread::hardware_concurrency()在新版C++标准库中是一个很有用的函数。这个函数将返回能同时并发在一个程序中的线程数量。例如，多核系统中，返回值可以是CPU核芯的数量。返回值也仅仅是一个提示，当系统信息无法获取时，函数也会返回0。但是，这也无法掩盖这个函数对启动线程数量的帮助。清单2.8实现了 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15246.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15246.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:09 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 并发]]></title>
      <description><![CDATA[ C++并发主要内容何谓并发和多线程应用程序为什么要使用并发和多线程C++的并发史一个简单的C++多线程程序令C++用户振奋的时刻到了。距初始的C++标准（1998年）发布13年后，C++标准委员会给语言本身，以及标准库，带来了一次重大的变革。新C++标准（也被称为C++11或C++0x）在2011年发布，带来一系列的变革让C++编程更加简单和高效。其中一个最 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15247.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15247.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:09 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 并发入门]]></title>
      <description><![CDATA[ C++ 并发入门，ok！现在你有一个能与C++11标准兼容的编译器。接下来呢?一个C++多线程程序是什么样子呢?其实，它看上去和其他C++程序差不多，通常是变量、类以及函数的组合。唯一的区别在于某些函数可以并发运行，所以需要确保共享数据在并发访问时是安全的，详见第3章。当然，为了并发地运行函数，必须使用特定的函数以及对象来管理各个线程 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15243.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15243.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:08 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 中的并发和多线程]]></title>
      <description><![CDATA[ C++中的并发和多线程，通过多线程为C++并发提供标准化支持是件新鲜事。只有在C++11标准下，才能编写不依赖平台扩展的多线程代码。了解C++线程库中的众多规则前，先来了解一下其发展的历史。C++多线程历史C++98(1998)标准不承认线程的存在，并且各种语言要素的操作效果都以顺序抽象机的形式编写。不仅如此，内存模型也没有正式定义，所以 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15244.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15244.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:08 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 为什么使用并发]]></title>
      <description><![CDATA[ C++ 为什么使用并发，主要原因有两个：关注点分离(SOC)和性能。事实上，它们应该是使用并发的唯一原因；如果你观察得足够仔细，所有因素都可以归结到其中的一个原因(或者可能是两个都有。当然，除了像“就因为我愿意”这样的原因之外)。为了分离关注点编写软件时，分离关注点是个好主意；通过将相关的代码与无关的代码分离，可以使程序更容易 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15245.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15245.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:08 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 线程管理的基础]]></title>
      <description><![CDATA[ C++ 线程管理的基础，每个程序至少有一个线程：执行main函数的线程，其余线程有其各自的入口函数。线程与原始线程以main为入口函数的线程同时运行。如同main函数执行完会退出一样，当线程执行完入口函数后，线程也会退出。在为一个线程创建了一个std::thread对象后，需要等待这个线程结束；不过，线程需要先进行启动。下面就来启动线程。C++ ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15241.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15241.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:07 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 线程管理]]></title>
      <description><![CDATA[ C++ 线程管理，主要内容启动新线程等待线程与分离线程线程唯一标识符好的！看来你已经决定使用多线程了。先做点什么呢?启动线程、结束线程，还是如何监管线程？C++标准库中只需要管理std::thread关联的线程，无需把注意力放在其他方面。不过，标准库太灵活，所以管理起来不会太容易。本章将从基本开始：启动一个线程，等待这个线程结束，或放在 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15242.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15242.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:07 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 转移线程所有权]]></title>
      <description><![CDATA[ C++ 转移线程所有权，假设要写一个在后台启动线程的函数，想通过新线程返回的所有权去调用这个函数，而不是等待线程结束再去调用；或完全与之相反的想法：创建一个线程，并在函数中转移所有权，都必须要等待线程结束。总之，新线程的所有权都需要转移。这就是移动引入std::thread的原因，C++标准库中有很多_资源占有_resource-owning类型，比如s ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15239.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15239.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:06 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 使用同步操作简化代码]]></title>
      <description><![CDATA[ C++ 使用同步操作简化代码，同步工具的使用在本章称为构建块，你可以之关注那些需要同步的操作，而非具体使用的机制。当需要为程序的并发时，这是一种可以帮助你简化你的代码的方式，提供更多的函数化的方法。比起在多个线程间直接共享数据，每个任务拥有自己的数据会应该会更好，并且结果可以对其他线程进行广播，这就需要使用“期望”来完 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15240.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15240.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:06 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 同步并发操作]]></title>
      <description><![CDATA[ C++ 同步并发操作，本章主要内容等待事件带有期望的等待一次性事件在限定时间内等待使用同步操作简化代码在C++ 线程间共享数据中，我们看到各种在线程间保护共享数据的方法。当你不仅想要保护数据，还想对单独的线程进行同步。例如，在第一个线程完成前，可能需要等待另一个线程执行完成。通常情况下，线程会等待一个特定事件的发生，或者 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15236.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15236.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:05 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 线程间共享数据]]></title>
      <description><![CDATA[ C++ 线程间共享数据，本章主要内容共享数据带来的问题使用互斥量保护数据数据保护的替代方案C++ 线程管理中，我们已经对线程管理有所了解了，现在让我们来看一下“共享数据的那些事”。想象一下，你和你的朋友合租一个公寓，公寓中只有一个厨房和一个卫生间。当你的朋友在卫生间时，你就会不能使用了(除非你们特别好，好到可以在同时使用 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15237.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15237.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:05 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 标识线程]]></title>
      <description><![CDATA[ C++ 标识线程，线程标识类型是std::thread::id，可以通过两种方式进行检索。第一种，可以通过调用std::thread对象的成员函数get_id()来直接获取。如果std::thread对象没有与任何执行线程相关联，get_id()将返回std::thread::type默认构造值，这个值表示“无线程”。第二种，当前线程中调用std::this_thread::get_id()(这个 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15238.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15238.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:05 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 等待一个事件或其他条件]]></title>
      <description><![CDATA[ C++ 等待一个事件或其他条件，假设你在旅游，而且正在一辆在夜间运行的火车上。在夜间，如何在正确的站点下车呢？一种方法是整晚都要醒着，然后注意到了哪一站。这样，你就不会错过你要到达的站点，但是这样会让你感到很疲倦。另外，你可以看一下时间表，估计一下火车到达目的地的时间，然后在一个稍早的时间点上设置闹铃，然后你就可以安心的睡会 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15235.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15235.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:04 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 保护共享数据的替代设施]]></title>
      <description><![CDATA[ C++ 保护共享数据的替代设施，互斥量是最通用的机制，但其并非保护共享数据的唯一方式。这里有很多替代方式可以在特定情况下，提供更加合适的保护。一个特别极端(但十分常见)的情况就是，共享数据在并发访问和初始化时(都需要保护)，但是之后需要进行隐式同步。这可能是因为数据作为只读方式创建，所以没有同步问题；或者因为必要的保护作 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15233.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15233.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:03 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 使用互斥量保护共享数据]]></title>
      <description><![CDATA[ C++ 使用互斥量保护共享数据，当程序中有共享数据，肯定不想让其陷入条件竞争，或是不变量被破坏。那么，将所有访问共享数据结构的代码都标记为互斥岂不是更好？这样任何一个线程在执行这些代码时，其他任何线程试图访问共享数据结构，就必须等到那一段代码执行结束。于是，一个线程就不可能会看到被破坏的不变量，除非它本身就是修改共享数据 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15234.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15234.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:03 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 使用期望等待一次性事件]]></title>
      <description><![CDATA[ C++ 使用期望等待一次性事件，假设你乘飞机去国外度假。当你到达机场，并且办理完各种登机手续后，你还需要等待机场广播通知你登机，可能要等很多个小时。你可能会在候机室里面找一些事情来打发时间，比如：读书，上网，或者来一杯价格不菲的机场咖啡，不过从根本上来说你就在等待一件事情：机场广播能够登机的时间。给定的飞机班次再之后没有可 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15232.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15232.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:32:02 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 中的并发和多线程]]></title>
      <description><![CDATA[ C++中的并发和多线程，通过多线程为C++并发提供标准化支持是件新鲜事。只有在C++11标准下，才能编写不依赖平台扩展的多线程代码。了解C++线程库中的众多规则前，先来了解一下其发展的历史。C++多线程历史C++98(1998)标准不承认线程的存在，并且各种语言要素的操作效果都以顺序抽象机的形式编写。不仅如此，内存模型也没有正式定义，所以 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15228.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15228.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:31:58 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 并发]]></title>
      <description><![CDATA[ C++并发主要内容何谓并发和多线程应用程序为什么要使用并发和多线程C++的并发史一个简单的C++多线程程序令C++用户振奋的时刻到了。距初始的C++标准（1998年）发布13年后，C++标准委员会给语言本身，以及标准库，带来了一次重大的变革。新C++标准（也被称为C++11或C++0x）在2011年发布，带来一系列的变革让C++编程更加简单和高效。其中一个最 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15225.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15225.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:31:57 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 为什么使用并发]]></title>
      <description><![CDATA[ C++ 为什么使用并发，主要原因有两个：关注点分离(SOC)和性能。事实上，它们应该是使用并发的唯一原因；如果你观察得足够仔细，所有因素都可以归结到其中的一个原因(或者可能是两个都有。当然，除了像“就因为我愿意”这样的原因之外)。为了分离关注点编写软件时，分离关注点是个好主意；通过将相关的代码与无关的代码分离，可以使程序更容易 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15226.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15226.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:31:57 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 并发入门]]></title>
      <description><![CDATA[ C++ 并发入门，ok！现在你有一个能与C++11标准兼容的编译器。接下来呢?一个C++多线程程序是什么样子呢?其实，它看上去和其他C++程序差不多，通常是变量、类以及函数的组合。唯一的区别在于某些函数可以并发运行，所以需要确保共享数据在并发访问时是安全的，详见第3章。当然，为了并发地运行函数，必须使用特定的函数以及对象来管理各个线程 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15227.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15227.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:31:57 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 内存模型基础]]></title>
      <description><![CDATA[ C++ 内存模型基础，这里从两方面来讲内存模型：一方面是基本结构，这与事务在内存中是怎样布局的有关；另一方面就是并发。对于并发基本结构很重要，特别是在低层原子操作。所以我将会从基本结构讲起。C++中它与所有的对象和内存位置有关。C++ 对象和内存位置在一个C++程序中的所有数据都是由对象(objects)构成。这不是说你可以创建一 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15224.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15224.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:31:56 +0000</pubDate>
    </item>
    <item>
      <title><![CDATA[C++ 限定等待时间]]></title>
      <description><![CDATA[ C++ 限定等待时间，之前介绍过的所有阻塞调用，将会阻塞一段不确定的时间，将线程挂起直到等待的事件发生。在很多情况下，这样的方式很不错，但是在其他一些情况下，你就需要限制一下线程等待的时间了。这允许你发送一些类似“我还存活”的信息，无论是对交互式用户，或是其他进程，亦或当用户放弃等待，你可以按下“取消”键直接终止等待。介绍 ]]></description>
      <link>https://www.herecours.com/backend/2026/02-17/15222.html</link>
      <guid>https://www.herecours.com/backend/2026/02-17/15222.html</guid>
      <category>C++教程</category>
      <author><![CDATA[]]></author>
      <pubDate>Tue, 17 Feb 2026 00:31:55 +0000</pubDate>
    </item>
  </channel>
</rss>