视频内容

刚开始我以为up就是想把所有的系统级头文件合并在一个.h里然后引用，还在想这有什么意义，好看一点？

看到改CMake直接使用了一个pchheader才知道，这里有东西的！！

预编译的头文件

PCH文件是一个预编译头文件（pre-compiled header），它的后缀是PCH，所以也叫PCH文件。编译器会将头文件的内容事先编译成二进制的中间文件，在整个编译过程中，只编译一次，并且有缓存，除非有变化，否则不会重新编译（每个引入的.h和.cpp）文件，从而大大提高编译速度。

每个源文件只能使用一个预编译的标头（.pch）文件，但是可以在一个项目中使用多个.pch文件。

几乎所有C/C++编译器都支持预编译头文件的，例如gcc, clang, msvc等…但是不同的编译器对它的支持力度和处理方式有很大差异，并不是非常通用。

msvc的处理

/Yc是创建pch文件，必须要通过编译stdafx.cpp才能生成stdafx.pch，使用的时候需要用/Yu来使用，最后链接的时候还需要把stdafx.obj和test.obj都链接上才行，这也是和gcc, clang最大的不同。

其他

clang的支持很简单，可以直接通过-c创建，使用的时候通过-include-pch直接使用。

gcc不支持-include-pch，所以需要从-I的头文件路径中搜索。

标头单元、模块和预编译头文件

如微软的文档里所描述的，include是最慢的，其次是预编译头，再快一点的是标头单元，而最快的是模块。

import std或者import std.compat的速度比#include <vector>要快，不过目前好像只有msvc支持完整，clang到17还是部分支持。

那说回来，什么是标头单元？
标头单元是头文件的二进制表示形式。 标头单元以 .ifc 扩展名结尾。相同的格式也用于命名模块。
使用标头单元比include编译要快的主要原因就是标头单元类似于预编译头文件一样，是提前被编译过的，而且标头单元是不受外部宏定义影响的，因为已经被编译过了。

不过标准库的标头文件，现在看支持好像还是一般，以mvsc为主。

参考

https://tboox.org/cn/2017/07/31/precompiled-header/
https://learn.microsoft.com/zh-cn/cpp/build/compare-inclusion-methods?view=msvc-170

End。

介绍

是一本介绍C++11到C++20特性的书籍。
越来越多的项目迁移到了更新的标准上，毕竟带来了新的好用的特性，而且性能依然非常的高，需要学习一下。

不会大而全的记录，主要会是让我有所醒悟的内容。

基础类型

整型

新增了long long表示至少64位的整数，对应的还有LL和ULL的后缀。

long long x = 65536LL;
unsigned long long x = 65536ULL;

整型上限：

std::numeric_limits<long long>::min()
std::numeric_limits<long long>::max()
std::numeric_limits<unsigned long long>::max()

字符和字符串

字符集和编码方法

字符集和编码方法是有区别的，字符集就是所有字符的集合，应该是包含所有的文字对应的图像，而编码方式就是用数字和字符集建立对应关系的方法。
Unicode有三种编码方式，UTF-8, UTF-16, UTF-32，都是Unicode字符集。而UTF-X是具体的编码方式，UTF-32是最简单的，用4个字节直接存储一个字符，但是很浪费。UTF-16稍微好一点，UTF-8特别差，不好计算长度不好查找字符。

标准新增类型

新增了char16_t和char32_t，分别用来对应Unicode字符集的UTF-16和UTF-32两种编码方法。

• utf8的前缀u8
• utf16的前缀u
• utf32的前缀U
• wchat_t的前缀是L（早期定义的类型）

char utf8c = u8'a';       // C++17标准
char16_t utf16c = u'好';
char32_t utf32c = U'好';

在C++11标准中u8只能作为字符串字面量的前缀，而无法作为字符的前缀。这个问题直到C++17标准才得以解决，所以上述代码需要C++17的环境来执行编译。

whcar_t是早期定义的类型，没有严格规定大小，导致Windows是16位，Linux是32位，这种标准不好修改，所以引入新的标准解决这个问题。

新增的函数，记忆主要是分三个类型：

• mbr: utf-8，即char
• c16: utf-16
• c32: utf-32

  size_t mbrtoc16（char16_t * pc16，const char * s，size_t n，mbstate_t * ps）;
  std::mbrtoc32
  std::c16rtomb
  std::c32rtomb

  auto

  主要的用法有两个：

• 声明变量时2，自动推断类型
• 声明函数时返回值的占位符(模板推导使用)

还有几个要点：

• 从左到右推导
• 不会收窄类型
• 总是使用更强的类型
• 无法声明非静态成员变量
• 按值推导会忽略cv限定符、引用属性
• 使用auto和万能引用声明变量，左值会被推导为引用
• 如果目标对象是数组或者函数，auto会推导为对应的指针类型

T &&是万能引用声明，会触发引用折叠。

decltype

这个初步了解的话，比较清楚地是:

int i = 1;
decltype(i) j = 2;      // 推到为int

但是它的复杂之处就在于它的推导，auto是将cv去掉了，而且不主动用万能引用引发引用折叠是不会有太多引用的问题要考虑的。

但是decltype的推倒过程是要考虑引用的，它整体的推导规则：
decltype(e) 其中e的类型是T，推导规则有五条：

1. 如果e是未加括号的符号表达式或者未加括号的类成员访问，则推出的类型是T；
2. 如果e是一个函数调用或者仿函数调用，那么推导出返回值的类型；
3. 如果e是一个类型为T的左值，则decltype(e)是T&
4. 如果e是一个类型为T的将亡值，则decltype(e)是T&&
5. 除了以上情况，推导结果为T

但是实际实验，发现在创造的时候由不符合这个情况，可能是因为编译不过就自动退化了。

其他资料

字符编码那些事

End.

记录

一方面是持续提升自己，让自己未来在能够接到更重的工作的时候能够胜任；另外一方面也就是持续的学习，保持自己的竞争力，别哪天真的没工作干了。
作为技术人员，一方面要拥有很核心的技术，深度要深，广度要广，而且要持续跟进最新的知识，有持续的产出，所以，一方面努力学习，一方面努力写代码。

链接：
https://cpxwidm62n.feishu.cn/base/HRiqb4hAga8J77smUATcc8qenme?from=from_copylink

最近公司出了一个bug，我有点不太懂python循环import会发生什么，也不知道python是怎么处理的，周末顺着文档缕了一遍python的导入系统。

官方导入系统的文档：https://docs.python.org/zh-cn/3.12/reference/import.html
本文主要是记录一些细节、自己的理解以及一些注解。

基本介绍

import

import: import语句包含了两个操作：

1. 它先搜索指定的模块，如果不存在会创建改模块；
2. 然后将搜索结果绑定到当前作用域中；

展开来说，就是import首先会调用__import__将模块拿到引用，然后import会处理名字绑定相关的操作，类似于

import math         # 将math模块绑定到locals()的math
import abc as a     # 将abc模块绑定到locals()的a
from abc import d       # 将abc.a绑定到locals()的d上

__import__

看完前面的，__import__就很清晰了，它在设计上是仅用来做搜索以及在没搜到时创建模块的功能的，但是虽然不会影响globals()和locals()，但是会修改sys.modules。

模块和包

模块：Python只有一种模块对象类型，所有模块都属于该类型，无论是从python还是C++实现的类模块。
包：可以将模块理解成文件，包是目录，包可以拥有子包，也可以拥有模块。

包又分为常规包和命名空间包，常规包就是目录有__init__.py的包，命名空间包就可以让一个包内的模块不在同一个目录，甚至

注：

• 包是为了帮助组织模块并提供名称层次结构，Python 还引入的概念。
• 所有的包也都是模块
• 拥有__path__的模块会被当做是包

加载模块

[原文]
当一个模块说明被找到时，导入机制将在加载该模块时使用它（及其所包含的加载器）。 下面是导入的加载部分所发生过程的简要说明:

module = None
if spec.loader is not None and hasattr(spec.loader, 'create_module'):
    # It is assumed 'exec_module' will also be defined on the loader.
    module = spec.loader.create_module(spec)
if module is None:
    module = ModuleType(spec.name)
# The import-related module attributes get set here:
_init_module_attrs(spec, module)

if spec.loader is None:
    # unsupported
    raise ImportError
if spec.origin is None and spec.submodule_search_locations is not None:
    # namespace package
    sys.modules[spec.name] = module
elif not hasattr(spec.loader, 'exec_module'):
    module = spec.loader.load_module(spec.name)
else:
    sys.modules[spec.name] = module
    try:
        spec.loader.exec_module(module)
    except BaseException:
        try:
            del sys.modules[spec.name]
        except KeyError:
            pass
        raise
return sys.modules[spec.name]

循环import的问题

主要文章： https://www.jb51.net/article/51815.htm

# 文件A.py:
from B import D
class C: pass

# 文件B.py
from A import C
class D: pass

这个过程会直接报错，但是如果将from A import C改成import A就不会报错，这是为什么呢？
可以看到前面的文档里的内容，包括这段开头的文章。
在import时首先查看是否存在这个模块，如果存在，则直接获取，如果不存在，则先创建一个空的占用，然后再执行loader.execute()

两个连续的from xx import xx发生的事情就是，在第二次执行from A import C时，会发现sys.modules里面已经有A，那么import做的事情是获取A.C，然后把引用放进globals。

但是这个A是个空的模块，所以就Trace了。

End