学习笔记 on T.本秋的自留地

现代 C++ 笔记：I/O 流与字符串流

Thu, 13 Nov 2025 13:58:39 +0800

流
#

`std::cin >>`
#

跳过输入流中前导空白符，当遇到下一个空白的时候停止，并把空白保留在输入缓冲区中。

简单来说，就是获取一个单词。

C-style 的函数
#

有一些函数是 C 遗留下来的，所以他们不支持 std::string，只能使用传统的 C 风格字符串。

std::getline()

给定一个字符串缓冲的容器：

获取缓冲区的内容，直到遇到 \n，把 \n 以及前面的内容提取，然后不将 \n 放在目标中。

重载函数 (strBuf, n) 可以提取指定的长度的字符，获取 n -1 个字符，因为要有 \0 结尾。

gcount() 用于统计提取的部分，包括 \n，但是不包括限定长度在后面添加的 \0。

现代 C++ 笔记：继承、虚函数与异常处理

Thu, 06 Nov 2025 10:23:35 +0800

继承，派生
#

继承初始化
#

在构造函数后面的 : 加入基类的列表初始化：

class Base {
  private:
    int m_baseVar{};

  public:
    Base(int baseVar) : m_baseVar{baseVar} {}
};
class Derive : public Base {
  private:
    int m_deriveVar{};

  public:
    Derive(int baseVar, int deriveVar) : Base{baseVar}, m_deriveVar{deriveVar} {}
};

修改派生类的访问权限
#

访问修饰符
#

定义派生类的时候，: 后的访问限定符：

public: 基类所有访问类型，即为派生类的访问类型。
protected: 基类的 public 在派生类中是 protected。
private: 基类的 public 和 protected 在派生类中是 private。

基类的 private 在派生类中默认永远无法访问。

`using`来强制改变单个成员
#

可以单独在派生类中修改基类中可访问的成员在派生类的访问权限。

class Derive : public Base {
  private:
    using Base::func; // 假设这两个在 Base 都是公开的
    using Base::m_var;
}

这样就把两个成员在派生类中限制在了 private 权限，重载函数会全部限制。

隐藏功能
#

如果基类和派生类存在同名的成员函数，那么派生类会隐藏基类的函数。

如果向派生类对象传入一个 int，基类里面的匹配 int，派生类匹配 double，还是会优先使用派生类的函数，然后通过数值转化把实参变成 double。

解决方案是在派生类强制使用 using Base::func 来使用基类的函数。

删除功能
#

像复制构造函数一样，可以显示删除某些不需要的基类功能，用 = delete。

但是仍然可以绕过派生类访问基类的功能：

std::cout << derived.Base::m_value;
std::cout << static_cast<Base&>(derived).m_value;

虚函数
#

虚函数是 RTTI（运行时类型信息）的典型代表。

在多个派生的类中，如果有签名一致的函数，前面加上 virtual 关键字，如果有类型为低派生的引用或者指针指向高派生的类，那么使用该指针将会自动调用尽可能高派生的类的函数。

如果一个派类在其继承链的中只要有一个类的函数是 virtual，那么其所有相同签名的函数均视为虚函数。

覆盖
#

使用 override 关键字在派生类中显式的覆盖相同签名的函数，如果无法覆盖会报错，这样避免了签名不一致导致未覆盖还过编译的情况。

override 放在成员函数的 const 后。

override 是隐式 virtual 的，所以只有最底层的基类型需要 virtual 关键字，其他都可以写 override。

final 放在 override 后，提示这是最后一个覆盖的派生类函数，后续派生的类若再覆盖，则报错。

协变返回类型
#

当派生类中返回一个 this 指针的时候，这个指针指向的类型只跟调用它的引用/指针类型有关。

虚析构函数
#

如果使用低层的引用/指针指向一个高层的派生类，释放的时候不会正确调用高层的析构函数。此时需要给析构函数添加 virtual 修饰符。

不推荐给所有的派生类添加 virtual，因为虚函数表会造成开销。如果不希望此类被继承，应该在定义类的时候在类名后添加 final 禁用对此类的继承。

绑定和调度
#

早期绑定/早期调度：在编译的时候就已经确定了调用函数的地址。
晚期绑定：使用函数指针调用函数
晚期调度：调用虚函数，通过虚表查询，只有在运行时才知道真正调用的函数。

纯虚函数，纯虚类，虚基类
#

纯虚函数指的是基类声明了有这个函数，但是实际上无法实例化，只能交由派生类实例化的函数。

在一个 virtual 后面加入 = 0 即可实现，也不需要函数体。

纯虚类（抽象类）其实相当于一个接口函数，这个类没有成员变量，只有纯虚函数，需要注意必须要有虚析构函数。此类不能被构造，一般在调用的时候，形参为其的引用/指针，并接受其派生类为实参。

虚基类在继承的 : 后面加入 virtual，目的是只有最后一个非虚的派生类创建对象，从而避免菱形继承造成的功能重复。

切片
#

当复制/移动的的目标类型是基类型时，会造成切片，只保留基类实例的部分。

RTTI
#

`dynamic_cast`
#

用于向下转换（把一个基类型的指针转换成一个派生类型的指针），造成很大的开销，转换后需要判断是否转换成功。

当然用 static_cast 也可以转换，但是不会判断是否是否可以成功转换，访问的时候会造成内存问题。所以不推荐。

`typeid`
#

获取表达式和类型的类型信息，用于实现 C++ 中的自省。

重载的运算符 ==，用于比较两个对象是否完全一致。

成员函数 .name()，可被打印的、修饰过的编译器名字。

委派重载函数
#

<< 不能够被设置成虚函数，因为不是成员函数。但是可以委派给虚函数来打印，只需要把流对象的引用传递过去即可。

异常处理
#

经典的 try-catch 块和 throw 关键字。

在主函数里面使用 try 包裹功能调用函数的时候，函数也可以抛出异常，如果函数本身没有处理，会清理本块的资源，然后依次交由上一级调用栈处理，这个过程叫作栈展开。如果一直到主函数都没有处理，那么就会调用 std::terminate() 终止程序，此时可能未完成清理。

因此，建议使用 catch(...) 在最后捕获所有异常，此时可以保证所有资源都被清理。

析构函数是隐式 noexcept 的，因为如果析构函数又抛出异常（二次异常），那么程序将会直接终止。

异常类和重载不同，对于能同时接受派生类和基类的形参，会优先选择第一个 catch，所以需要把最匹配的放在前面。

异常对象的存储机制
#

异常对象会在抛出的时候进行复制，所以这个对象的类必须有复制构造函数，才能正常进行异常流程。

在 `catch` 中抛出异常
#

可以在 catch 中抛出异常，如果希望再次抛出相同的异常向上处理，应该直接使用 throw; 而不是显式指定传入的名字，因为按值复制的过程会造成类型切片。

函数级异常
#

严格在函数的 () 后写 try-catch 块，此过程有隐式重抛异常，最好自己手动指定。

一般用于构造函数中。


class B : public A {
  public:
    B(int x)
    try
        : A{x} // note addition of try keyword here
    {
    } catch (...) // note this is at same level of indentation as the function itself
    {
        // Exceptions from member initializer list or
        // from constructor body are caught here

        std::cerr << "Exception caught\n";

        // throw; // rethrow the existing exception
    }
}

`noexcept`
#

没有带 noexcept 的函数都是潜在的抛出异常的函数。

要求带有此标记的函数，必须在这个块前完成异常处理，如果超出了这个块，那么整个程序就被强行终止（使用 std::terminate）

使用 noexcept 允许编译器进行深度的优化，因为不需要考虑异常的栈展开机制。

`std::move_if_noexcept`
#

在编译的时候确定移动构造函数是否有 noexcept 关键字，如果没有，就 fallback 到复制。

其实此函数传入的形参是可变的，如果移动构造保证无异常抛出，那么就传入将亡值，使用移动构造函数；如果没有，那么就传入左值，使用复制构造函数。

现代 C++ 笔记：移动语义、智能指针与值类别

Thu, 30 Oct 2025 14:34:07 +0800

左右值、`&&`、移动语义、智能指针
#

有两个重要概念需要区分：

类型 (Type)
#

表示一段内存究竟是怎么样的性质。对于一段内存，它内部的结构应该是怎么样被解析的，使用什么样的运算符。

其实就是一开始的类型系统，包括基本类型的 int、double，也可以是标准库中的 std::string，用户在 class 定义类型。

值类别 (Value Category)
#

在移动语义后完善的概念，重点关注此表达式本身的性质，具有什么身份，是否可以被移动。

在 C++98，只有左值和右值。

但是在 C++11，我们引入了移动语义，出现了一个将亡值。

将亡值有身份可以取地址，但是马上被移动也就消失了，所以我们扩大了左值的定义，认为他是广义左值；

同时，因为他即将消失，所以认为是右值，那么就把以前的右值定义为纯右值，这样五种值类别就出来了。

`&&`/`&` 作为函数形参
#

考虑下面这个函数：

int main(){
    int&& ref{ 5 };
    fun(ref);
}

给出两个 fun 的函数声明：

void fun(int&&);
void fun(const int&);

事实上，只有第二个能够匹配传入的参数，而不是第一个。

在没有引用的时候，我们的函数形参其实是匹配对象的类型的，因为只有确定了类型，函数内部才知道这个对象使用哪一种操作符，如何解释这一段内存。

引入引用之后，带 & 的参数会解释这个对象如何绑定到实参：

左值引用：只能绑定到左值。
常量左值引用：能绑定到左值和右值，如果直接绑定到右值，会延长该对象的生命周期。
右值引用：绑定到右值时，在函数内部转换成一个左值；绑定到左值时，是一个左值引用。

但是需要注意一点，虽然 ref 是一个 int&& 类型的对象，但是他的值类别其实是一个左值，所以形参可以是一个 (常量) 左值引用。

`&&` 在模板参数的使用
#

仅在模板以及泛型中，&& 才有引用折叠作用，常用于完美转发。

最常见的在于这样一个泛型函数：

template <typename T> wrapper(T&& arg){
    target(std::forward<T>(arg))
}

传入左值的时候，会被折叠成 T&，而传入右值的时候，保留 T&& 的类型，&&非常智能，自动判断左右值。

实现移动
#

std::move() 返回的值是一个将亡值 (xvalue)，至于如何把这个值移动，是类的移动构造函数/移动赋值运算符实现的。

所以如果手动编写的移动构造函数/移动赋值运算符，需要注意：

加上 noexcept 关键字，避免抛出异常（要么成功，要么终止，避免移动一半），避免回退到复制。
手动把地址给到目标，然后把原来的指针指向空指针。
对于运算符，可以加上判断一下不是自己给自己，如果是就返回 *this。

至于源对象如何释放，是取决它本身的生命周期的。此时我们已经完成了所有权的转移。

智能指针
#

`unique_ptr`
#

这个指针指向的堆内存必须是它独占的，如果使用移动语义来赋值的话，会自动把上一个指针置空。

不要用一个裸指针来初始化一个智能指针，虽然语法上成立，但是语义上会破坏 unique 的独占性，仍然会发生双重释放的问题。

使用 make_unique 将一个纯右值的对象变成独占的指针，不用手动 new 故比较推荐。

make_unique 其实是一个函数，为一个纯右值返回一个独占指针，所以返回值一定会有一个指针接收，一般用 auto 配合效果很好：

auto ptr {std::make_unique<Fraction>(Fraction{3, 5})};

如果要求传入一个类型的裸指针，但是手上只有智能指针，可以使用 .get() 来得到一个底层中使用的裸指针的副本。

`shared_ptr` 和 `weak_ptr`
#

共享指针允许多个指针同时指向一块内存，同时其内部会保存指向这段内存的计数。当最后一个共享指针销毁的时候，内存将会被自动释放。

不过 shared_ptr 会导致两个共享指针相互依赖的问题，这样在释放的时候认为是互相依赖使得最终内存无法释放导致内存泄漏。

最典型的例子就是，在一个类中有 shared_ptr 的成员变量，然后两个实例化的对象的共享指针指向对方，同时具有相同的生命周期，这样释放的时候互相认为对方存在，从而都不释放内存。

因此，weak_ptr 出现了。弱指针不增加引用计数，因此可以很好的解决上面的问题。

弱指针其实有点像 string_view，他们都只是一个视图（观察者）而已。

使用弱指针：

.expired() 可以检测弱指针是否指向无效的内存。
.lock() 锁定指向的内容，把引用计数 +1，同时返回一个 shared_ptr；如果已过期，那么会返回 nullptr（这样甚至不需要 std::optional）。

关系
#

unique_ptr 可以转化为 shared_ptr，反之不能转化。

unique_ptr 只能移动不能拷贝，shared_ptr 和 weak_ptr 可以拷贝。

shared_ptr 可以被 weak_ptr 创建一个视图。

weak_ptr 的成员函数 .lock() 有效时会返回一个 shared_ptr，否则会返回一个 nullptr。

组合、聚合和关联
#

属性 (Property)	组合 (Composition)	聚合 (Aggregation)	关联 (Association)
关系类型	整体/部分	整体/部分	其他不相关
部分可属于多个整体	否	是	是
部分的存在由整体管理	是	否	否
方向性	单向	单向	单向或双向
关系动词	是…的一部分 (Part-of)	拥有 (Has-a)	使用 (Uses-a)
**方式	类成员	引用 (数组)	引用 (数组)

初始化列表 `initializer_list`
#

如果想要让自己的类使用一个初始化列表来初始化，需要手动添加一个重载的构造函数：

template<typename T>
class MyClass{
  private:
    T m_size{};
    T* m_data{};
  public:
    MyClass(int size) : m_size{size}, m_data{new T[static_cast<size_t>(size)]}{};
    MyClass(std::initializer_list<T> list) : MyClass(static_cast<T>(list.size())){
        // 用委托构造函数来创建一个
        std::copy(list.begin(), list.end(), m_data);
    }
    // 3/5/0 法则的其他函数
}

现代 C++ 笔记：Lambda、运算符重载与闭包

Wed, 22 Oct 2025 16:29:09 +0800

命令行参数
#

早就知道在 c 中是可以在 main 中获取从命令行传入的参数的。但是对于解析是一窍不通，这里简单说一下如何获取整形。

不过，这些方法都仅仅适用于简单的字符串处理，而一个简单的带参 cli 程序，基本都要求参数能够无视顺序，可选参数，这些统统都不能实现…

`std::stringstream`
#

这个函数用于把字符串转换成流，然后再把流输出到整形。

std::stringstream convert{arcv[1]};
int num{};
if(convert>>num){
    std::cout<<num;
}

std::stoi
#

这个就是现代 C++ 的方法了。

直接转换就行：

    int num{std::stoi(argv[1])};
    std::cout << num;

lambda 表达式
#

lambda 表达式看起来像这样子：

[<capture>](<parameter list>) -> <return type> {<body>};

参数列表可以省略，返回值也可以省略，会自动推断。

所以说，最简的 lambda 表达式：[]{}。

捕获
#

对于以下变量来说，不需要捕获也可使用：

全局变量，静态局部变量，线程局部变量
常量表达式（包括被编译器视为常量表达式的变量）

捕获语法是 lambda 表达式中一个不可缺少的部分，词法分析就是通过 [] 来发现这是一个表达式的。

lambda 表达式不和 {} 一样，不能访问上级大括号中的局部变量。它只能访问静态和全局的变量，以及 constexpr。

而捕获其实就是把原来应该能让 lambda 能够使用的局部变量让它使用。

捕获的时候可以声明新变量的，在 [] 内，可以使用当前块内能访问的变量来参与运算。

捕获有两种类型：默认捕获和单个捕获。

按对象捕获
#

假设有变量 a b:

传值：[a,b]。默认传入变量的常量值，如果需要修改，需要在大括号前加上 mutable。
传引用：[&a,&b]

默认捕获
#

默认捕获会捕获 lambda 中提到的所有变量。

[=]：传入值
[&]：传入引用

不允许同时使用默认捕获和按对象的捕获。

创建闭包
#

提到闭包这个词，就不得不提函数式编程了。简单来说，函数是“一等公民”，就像我们传统的命令式编程的变量（对象）一样，可以作为参数传递，可以被返回，可以运行时创建等等。

那么闭包就是保存了当前上下文中某些状态的函数。

在 C++ 中，想实现一个闭包，还是得定义一个普通函数（虽然说跟一般的匿名函数印象不太一样）：

std::function<int(int)> multiply(int factor) {
    return [factor](int base) { return base * factor; };
}
int main() {
    auto multiply_3 = multiply(3);
    auto multiply_4 = multiply(4);
    std::cout << multiply_3(3) << '\n';
    std::cout << multiply_4(4);
}

multiply_3 和 multiply_4 就是一个闭包。

实现一个简单的函数
#

`lambda` 表达式可以作为 `lambda` 类型的变量存储。
#

    auto square{[](int base) { return base * base; }};
    std::cout << square(3);

也可以声明的时候就调用：
#

[]() { std::cout << "Hello world!\n"; }();
// 前一个括号是形参列表，后一个括号表示调用函数

值得提的一点是，这其实不是真正的函数，实际上只是重载了 () 实现像函数一样的调用。

在算法库的应用
#

前面在 <algorithm> 中，最后一个参数是比较函数的地址，其实我们可以直接在这里写 lambda 函数。

lambda 推断
#

对于实参推断（给出 (auto a, auto b) 的情况，只要函数体里面的能匹配，那么没有问题，因为编译器会自动生成重载的 lambda 表达式。

对于返回值，要求所有返回的地方一致才能推断，否则，请使用 -> 手动指定返回值类型。

带捕获的 `lambda` 拷贝
#

如果对带捕获的 lambda 表达式操作的时候，目标的类型是 std::function，那么会发生隐式类型转换，将 lambda 闭包进行深拷贝，使得多次使用 std::function 构造的多个对象出现独立的拥有原始闭包状态的副本。

在 lambda 构造的时候使用了 mutable 的值捕获，那么每次捕获的变量都是原始的捕获值。

解决方法是使用 std::ref 来包装 lambda 表达式。对于传入参数不一致的情况，它会返回一个 std::reference_wrapper 对象，保证内部存储的是对原始 lambda 对象的引用，从而保证每次调用的是同一个 lambda 表达式对象。

运算符重载
#

有三种办法重载：

友元函数：如果想要重载操作数是类对象的运算符，为了获取类内成员的访问权限，可以把此重载函数以友元的形式声明在类内。

普通函数：同时可以使用 getter 和 setter 来避免直接访问内部的成员变量。

类成员函数：仅适用于左侧操作数是类成员的情况，此时右操作数就作为参数。

一些选择建议：

重载赋值、下标 ([])、函数调用、成员选择 (->) -> 类成员函数
重载一元运算符 -> 类成员函数
不修改左操作数 -> 普通/友元函数
左操作数是内置类型无法修改 -> 普通/友元函数
左操作数可以修改 -> 类成员函数

重载函数一般返回左侧的对象的引用（以便可以连续用 . 调用）或者返回一个同类型的对象（用于连续使用重载运算符比如 +=）。

重载一元+/-
#

由于一元的 +/- 是类成员函数，而且没有参数，所以不会和二元的混淆。

重载自增/减
#

前自增/减参数列表没有参数，而后自增/减有一个 int 用于占位，从而将两者区分。

由于后自增/减要返回原来的值，所以需要一个临时变量用于返回，相比前自增/减多了开销，更倾向使用前自增/减。

下标访问重载
#

下标访问的重载返回值一般使用 auto&，从而作为左值被修改。

在 C++23 之前，如果定义类的时候使用 const，那么就需要添加一个成员重载函数：

const auto& operator[](T t) const;

这个函数被常量对象优先使用，被非常量对象次优先使用。

在 C++23，用右值引用解决此问题。

飞船运算符
#

外来语言的符号，用于比较两个数大小关系。

返回下面类型：

strong_ordering: 有equivalent、equal、greater 和 less。

weak_ordering: 比 strong 少了相等，因为是弱，只有等效。

partial_ordering: 相比 weak 多了 unordered，用于表示无法比较的情况。

从上往下可以隐式转换。

类型转换重载
#

类型转换重载也是 operator 操作符，不过重载的目标其实有点像 C 的强制转换：

class MyClass{
    //...
  public:
    operator int() { 
        // conversion
        return <intType_obj>;
    }
};

无须返回值，也无须参数，因为显而易见的返回目标类型，传入的是这个类对象，这也必须是一个类成员函数。

建议加上 explicit 关键字，因为我们不希望隐式转换带来的不确定性。

如何平衡类型转换重载和转换构造函数？

假设要把 A 转换成 B：

A 可改，B 不可改。那么就定义一个类型转换的重载。

A 不可改，B 可改。那么就定义一个参数只含 A 的转换构造函数，让 B 去接收 A。

A、B 都不可改。那么定义一个普通函数实现转换吧。

复制运算符重载
#

在动态分配内存中，有时为了避免自己赋值给自己，用一个 if 来设置保护防止出现空指针问题。

在三/五/零原则中，如果不带指针，那么应该不应该定义这个复制运算符重载。（其他：析构、复制构造，移动运算符，移动构造函数）

现代 C++ 笔记：容器、迭代器与算法库

Mon, 13 Oct 2025 08:25:04 +0800

std::vector
#

此向量非彼向量。

对于字符串
#

推荐使用string_view配合 C 风格的字符串，这样效率最高，只发生一次堆内存分配。

std::vector<std::string_view> names{ "Alex", "Betty", "Caroline", "Dave","Emily","Fred","Greg","Holly" };

列表初始化器
#

std::vector vec(3)会初始化一个全 0，长度为 3 的向量；
std::vecotr vec(2,3)会初始化一个长度 2，值都为 3 的向量。
但是std::vector vec({3})会初始化一个长度 1 值为 3 的向量。

因为给出单参数的时候，会优先调用列表初始化器，这个初始化器的行为是初始化长度为参数的向量。

下标
#

当时设计让size_t是一个无符号的整数，从现在看来是一个错误，因为下标访问最容易导致环绕，最好的办法是不使用下标访问而是迭代器，次选是使用 C 风格的访问.data()。然后全部使用有符号整数。

for-each
#

推荐使用这些：

修改元素副本：auto
修改原始元素：auto
只需要查看：const auto&（大多数情况）

反向查看：使用std::view::reverse()

容量和长度
#

容量是分配给向量的内存，长度是实际使用的部分。

pop的时候长度减少容量不变；push时如果遇到容量瓶颈，会自动复制扩容（2/1.5）倍。

resize成员函数会同时改变容量和长度，reserve只改变容量。

emplace_back会显示调用构造函数，直接在堆上预留的内存构建对象，如果是是临时对象，那么要注意如果有explicit那么不能执行隐式转换。而push_back会发生一次拷贝。

在 make_unique 下，始终会产生一次拷贝，此时两者表现一致。

std::array
#

array 大部分功能都与 constexpr 兼容。

在 constexpr 表达式执行的从 unsign 到 sign 的转换是允许的，因为编译器对此信任程度很高。

.at()、[]和 std::get()
#

.at(): 运行时边界检查。(C++17 后编译时检查)
std::get<index>(arr): 编译时边界检查。
[]: 不进行边界检查，C++11 后可为 constexpr 。

对于现代 C++ 来说， .at 是更安全的选择。

因为会在越界访问的时候抛出异常。而 [] 不会进行越界检查。

用模板创建数组
#


template<typename T, size_t N>
void passByRef(const std::array<T,N>& arr){
    static_assert(N!=0);
    std::cout<<arr[N];
}

由于模板参数是编译时常量，所以可以用 static_assert ，同时，更加推荐把这两句用 std::get<N>(arr) 替代。

在 C++20，可以把 size_t 替换成 auto 。

在函数内返回 array
#

由于 array 是在栈上分配的，那么一般来说会执行返回值优化，但是移动语义就没有意义（因为不是在堆上分配的就不能仅转移指针）。如果在 C++17 之前为了避免不确定性，那用 vector ？但是怎么感觉开销在堆上更大了说…

初始化聚合数组
#

列表初始化，但是兼容 C 带来的技术债。

constexpr std::array<House, 3> houses { // 1. 初始化 std::array
    { // 2. 初始化底层 C 风格数组 (元素列表)
        { 13, 1, 7 }, // 3. 初始化第一个 House 结构体
        { 14, 2, 5 }, // 3. 初始化第二个 House 结构体
        { 15, 2, 4 }  // 3. 初始化第三个 House 结构体
    }
};

此时不使用 CTAD，但是必须手动指定模板参数，或者，指定每一个元素的类型，此时可以 CTAD：

constexpr std::array houses { // 1. 初始化 std::array
    {
        Horse{ 13, 1, 7 }, // 3. 初始化第一个 House 结构体
        Horse{ 14, 2, 5 }, // 3. 初始化第二个 House 结构体
        Horse{ 15, 2, 4 }  // 3. 初始化第三个 House 结构体
    }
};

reference_wrapper
#

容器中不能给模板传入 int& 但是可以传入一个 std::reference_wrapper<int> 起到同样的作用，或者直接用 std::ref() std::cref() 直接把变量转换成引用。

迭代器
#

迭代器一般使用 !=end 来判断是否到达末尾，因为不是所有迭代器都可以比较。

其本身是一个指针，指向当前的容器元素。

写的 range based for 实际上就是迭代器的语法糖。

algorithems 库
#

这是一个算法库，用于偷懒（不是

补充知识
#

二元谓词：就是接受两个参数，返回一个布尔值的函数。

在算法库中，二元谓词都需要弱序，即非自反性 (自己不能小于自己)，非对称性 (a 小于 b，那么 b 不能小于 a)，传递性。

对于 Comp 这个类型，我们假设前一个参数是 a，后一个是 b。那么有：

对 a 和 b 进行某种运算，如果希望最后算法需要保持 a 排在 b 的前面，那么就返回 true；如果算法认为 a 不应该排在 b 的前面，那么就返回 false。

最简单的办法是，假设已经按照一个顺序排列，然后取出前两个元素为 a 和 b，将他们放入表达式，如果返回 true，那么这就是你要的顺序，为 false 则是另外一个顺序。

std::sort
#

sort 有第三个参数，传入一个二元谓词，在 cppreference 中类型为 Comp ,如果是一个函数的话，只需要传地址所以不用 ()。这个函数必须严格弱序的。

std::for_each
#

foreach 可以用于方便的遍历可以迭代的容器。给定开始和结束的迭代器，和要调用的函数地址（这个函数只能传入一个参数，可用 auto ），就可以自动迭代。

同时和 std::next 配合使用，可以跳过一部分迭代器，获得很高的灵活性。这时候就有了比基于范围的 for 循环更加灵活。

ranges (C++20)
#

从 C++20 开始，很多算法添加了对应的重载，直接传入容器的地址就可以实现操作，即 std::ranges::for_each(arr)。

函数指针
#

C 的函数指针如果不用 typedef将会非常复杂，而 C++ 提供了一个模板，以一个传入 int, int 返回 int 的函数指针为例：

#include<functional>
std::function<int(int, int)> ptr {&foo};
std::function<int(int, int)> bar(){
    // some implementation
}

现代 C++ 笔记：类、构造函数与成员初始化

Mon, 29 Sep 2025 08:25:14 +0800

枚举
#

枚举实现了内容与整形相关联的数据结构，是隐式的编译时常量。

枚举类型，枚举符和枚举变量。

枚举符会放入当前命名空间和其本身的命名空间中，如果是全局的枚举 (unscoped),那么可以直接使用。

对枚举变量空初始化会使得枚举符是 0，所以推荐把第一个枚举符设置成未知/无效。

枚举类用enum class Name{};定义，只能在其本身的作用域使用，无法被隐式转换成整数，在安全性上更优。

可以在需要的使用using enum Name;来简化使用 (C++20)。

结构体
#

对其中某些参数进行初始化：

struct Worker {
    int id{};
    int age{};
    double wage{};
};

Worker John { .id{1},.wage{5000}}; //部分列表初始化，age 初始化为 0，clangd 有 bug 会警告

Worker John { .id{1},John.age, .wage{5000}}; //这样可以占位，一样使得 age 初始化为 0

结构体模板
#

结构体当然也可以传入模板参数，不过在 C++20 更加完善，如果使用 C++17，可能需要手动指定推断：

template <typename T>
struct Pair
{
    T first{};
    T second{};
};

// Here's a deduction guide for our Pair (needed in C++17 only)
// Pair objects initialized with arguments of type T and T should deduce to Pair<T>
template <typename T>
Pair(T, T) -> Pair<T>;

int main()
{
    Pair<int> p1{ 1, 2 }; // explicitly specify class template Pair<int> (C++11 onward)
    Pair p2{ 1, 2 };      // CTAD used to deduce Pair<int> from the initializers (C++17)

    return 0;
}

可以为类型模板起别名：

template <typename T>
using Coord = Pair<T>; // Coord is an alias for Pair<T>

类
#

类的成员变量，成员函数是隐式内联的，所以放在头文件中被多个源文件引用的时候，不违反 ODR 原则。

在类中，不强制声明语句位于使用之前，只要他们都在同一个类中即可。

调用常量类对象内部的函数，要将此成员函数声明为const。

void foo() const {
  //...
}

struct和class仅有的差异：struct默认使用public:，而class默认使用private:。在继承性上也是这样。

protect:允许派生的类访问，其可见性介于两者之间。

成员初始化列表
#

现代 C++ 使用成员初始化列表，而不是直接初始化列表。具体是：

class Foo{
    int m_a{};
    int m_b{};
    
    Foo(int a, int b) : m_a{a}, m_b{b} {
        //other...
    }
}

以前 (C++03) 之前则是用的()直接初始化。

成员初始化的顺序和成员初始化列表无关，只跟泪中定义成员变量的顺序有关。

`std::string_view`特殊处理
#

一个例子：

#include <iostream>
#include <string>
#include <string_view>

class Ball
{
private:
	std::string m_color { "none" };
	double m_radius { 0.0 };

public:
	Ball(std::string_view color, double radius)
		: m_color { color }
		, m_radius { radius }
	{
	}

	const std::string& getColor() const { return m_color; }
	double getRadius() const { return m_radius; }
};

void print(const Ball& ball)
{
    std::cout << "Ball(" << ball.getColor() << ", " << ball.getRadius() << ")\n";
}

int main()
{
	Ball blue { "blue", 10.0 };
	print(blue);

	Ball red { "red", 12.0 };
	print(red);

	return 0;
}

为什么这里构造函数需要用string_view作为参数？不能用const string&来替换？

string_view提供了灵活性，如果选择后者，那么如果传入一个 C 语言的字面量字符串的时候，就必须在堆上构建临时的string对象，而这对性能开销很大；对于前者，永远不会构造临时对象，而是只有一个指针，在真正初始化的时候完成一次复制。(甚至后面还能用移动语义)

为什么getter不能像上面一样反过来？

因为在类内部的存储对象就是真正的string，给出它的引用使得外部访问的类型明确，不会造成歧义；同时也提示这个引用的生命周期是明确的————跟成员变量一致。

构造函数
#

构造函数用于初始化类，在此我们可以手动指定成员变量如何初始化。

转化构造函数
#

转化构造函数其实就是特殊的构造函数，其只拥有一个参数。如果传入一个该参数类型的变量，那么就会自动把这这个变量转化成类。

默认构造函数
#

class Foo{
    int m_a;
    int m_b{};
    
  public:
    Foo () = default; //可以显式的声明构造函数为默认构造函数，此时 m_a 会被默认初始化为 0。
    Foo () {} //用户自己初始化，但是空初始化，此时 m_a 不会被初始化，是垃圾值。
}

委托构造函数
#

在一个构造函数的:后面写上参数更多的重载构造函数，可以用另一个构造函数来初始化，但是此构造函数就不能再初始化成员变量。

尽量不要使用太多的构造函数。

复制构造函数
#

复制构造函数的参数必须是引用，要不然就会发生无限递归的调用复制函数。

复制构造函数不应用于复制以外的意图，因为编译器可能会发生复制省略 (copy elision)

explicit 关键字
#

禁止隐式转换：从单个参数隐式转换成类对象；从列表{xxx,xxx}转换成类对象。

在具有单个参数的构造函数前加入，避免编译器执行隐式转换。

由于 C++ 对于用户定义的转换，只允许转换一次，所以下面的代码会报错：

#include <iostream>
#include <string>
#include <string_view>

class Employee
{
private:
    std::string m_name{};

public:
    Employee(std::string_view name)
        : m_name{ name }
    {
    }

    const std::string& getName() const { return m_name; }
};

void printEmployee(Employee e) // has an Employee parameter
{
    std::cout << e.getName();
}

int main()
{
    // 此时要经历两次转换：C-Style string -> string_view -> class Employee
    printEmployee("Joe"); // compile error
    
    // 修正：
    // 方法 1:
    // using std::literals;
    // printEmployee("Joe"sv);
    // 方法 2:
    // printEmployee(Employee{"Joe"});


    return 0;
}

不对复制/移动构造函数使用explicit，因为他们不执行隐式转换。

如果转换的时候两者等效且零开销，可以不使用explicit。

比如：

const char* -> string_view
string -> string_view

constexpr 问题
#

从 C++14 开始，constexpr修饰函数仅仅是作为编译时求值的提示，如果传入的变量不是一个constexpr，那么这个函数就具有运行时的上下文，constexpr修饰就不起作用。

对于struct，其作为一个聚合体，默认的构造函数无须加入constexpr就可以用它初始化一个类对象。但是对于class，就必须public，同时手动指定构造函数是constexpr，比如：

Foo {
  public:
    constexpr Foo = default;
}

而constexpr修饰一个类对象的时候，如果涉及到的函数（构造函数、setter以及使用到的成员函数）都有constexpr修饰，表示这个类具有编译时的上下文，会让此对象成为一个编译时常量。在编译时如果此对象是用临时对象初始化的，对临时对象是可以修改的，但是一旦这个对象初始化完毕，那么就不再可以修改。

后续要访问此constexpr对象，那么所有的函数()后，都必须有const，保证不修改此对象。

参考 (learncpp - 14.17)[https://www.learncpp.com/cpp-tutorial/constexpr-aggregates-and-classes/]

this 指针
#

this指针是一个const指针（顶层），指向当前操作的类。

this指针出现比引用早，不然它多少是个引用。

成员函数类外定义
#

成员函数可以在类外定义，要加上域访问解析符::。如果是类的正下方（.h中），前面加inline关键字以防止重复包含；如果是对应的 cpp 中，无须加inline。

默认参数在声明时给出。

类型模板参数
#

可以在类指定类型模板参数，不过如果成员函数先声明，然后在类外定义，那么需要单独再指定一次模板参数。

模板类外的成员函数要紧挨着类定义的下面。

注意：

所有的模板函数都是默认内联的，所以就算在类外定义，已经隐式inline了。
类外定义的函数的类型模板参数必须与类的一致。

传入类模板的参数，无须加<T>，因为已经在Pair<T>::作用域中了。

template <typename T>
bool Pair<T>::isEqual(const Pair& pair) // note the parameter has type Pair, not Pair<T>
{
    return m_first == pair.m_first && m_second == pair.m_second;
}

静态成员变量
#

静态成员变量在所有实例化的对象都可用，具有相同的值，在未实例化的时候也可以使用，直接用类名和域访问解析符访问。

声明的时候，在类内加static关键字，类外定义不能加关键字。

位置：直接在类后面/类对应的cpp，头文件中可以加inline。

只有静态成员变量可以自动推断，普通的不允许。

用途：一个根据数量递增的 ID

静态成员函数
#

静态成员函数用于访问静态全局变量。

有替代品：

命名空间：没有访问控制
静态全局类对象

友元
#

在被访问的类中声明，从而使得外部的类/函数能够访问private和protected的对象。

友元函数
#

在类中声明，自动成为非成员的函数，类外定义。

此项特性对于运算符重载非常有用。

友元类
#

直接在类内定义。

现代 C++ 笔记：引用、右值与函数模板

Thu, 25 Sep 2025 16:18:15 +0800

函数默认参数
#

声明的时候带默认参数，定义的时候可以不带。但是不能定义的时候有默认参数而声明的时候没有。
如果用默认参数，那么必须从右到左都有（左边可以没有，不能中断）。
传入参数的时候，只能从左往右传入，未传入的自动使用默认的参数。

模板
#

定义：

template<typename T> T foo(T a) {
    //your function
}

如果还有一个同名的非模板函数：

int foo(int a) {
    // function
}

调用的时候：

如果使用foo()，那么会直接调用非模板的函数。
如果用foo<>()，那么会自动推断，并从模板实例化函数。如果指定类型，则直接从模板按指定的类型实例化函数。

在两个不同的模板参数时，可以定义模板返回用auto关键字，让编译器自动推导返回类型。这是 C++17 后的 CTAD(class template auto deduction)。

注意： CTAD 仅用于推断实参 (argument，调用时) 不能推断形参 (parameter，函数声明)

在 C++20 后，函数参数传入auto会自动变成模板。

非类型模板：定义constexpr或者consteval（C++20）,不写 typename 。

template <int N>
auto foo() {
    std::cout<<N;
}

foo<5>(); // print 5

由于模板展开需要看到定义，所以模板函数应该放在头中。模板不违反单一定义原则。

左值和右值
#

左值表达式：在表达式结束之后，还能用标识对象访问的表达式。
右值表达式：表达式结束之后立即销毁的临时量。

特别：++x是左值，x++是右值。

引用
#

左值引用
#

左值引用只能绑定到可修改的左值。

常量左值引用可以绑定到可修改/不可修改的左值，右值。

一个常量引用可以引用非常量的对应对象，这使得此引用由编译器保证不修改其引用的对象，而且是函数的只读参数的推荐做法。

如果类型不匹配，引用会尝试将其进行隐式类型转换，得到一个临时对象。需要注意：

只允许数值提升和非窄化转换。
此时转化后的临时对象会被引用持有，生命周期与引用本身相同。
修改原始对象不会对因引用产生的临时对象造成影响。

小心！引用无法延长函数返回值的声明周期，以下例子为 UB：

const int& a = getTempVar();

引用和指针
#

左值引用可以绑定到右值，但是必须是常量的引用才可以。同时，对于右值的常量引用会使得直接绑定的临时对象生命周期被延长。

而右值引用 (&&) 则是用于移动语义。

与 auto 相结合
#

顶级const: 指的是修饰此别名/对象的const
低级const: 指的是被引用绑定/被指针指向的const

指针可以同时拥有两种const，但是引用不行，因为引用不是对象。

当用auto关键字以及引用来初始化对象时，遵守：

引用会被删除。
顶层的常量会被删除。

当然可以用auto&来重新添加引用，不过这样会同时保留顶级的const。我们一般推荐要手动加上const，这样会让语义更加清晰。

constexpr不是表达式的一部分，所以auto不会自动推断出它，如果需要则要在 auto 前面手动加上，就像这样：

constexpr const auto& ref{getConstRef()};

但是推断指针的时候，auto会完整的保留指针的类型。

有一点比较特殊，使用const auto和auto const是同义的，都会使得新对象成为一个常量的指针。但是如果你想const auto const，那就会报错。

如果想要这么做，最好明确一点，就像这样：

const auto*
auto* const
const auto* const

这样就很明显的看出，在*左边的意义是指向常量，在右边的意义是常量的指针，事实上既然都auto了，也不差这几个关键字吧？我其实比较担心auto不够智能这个问题。

为什么呢？

因为指针是一个对象，而引用可以理解成一个别名，所以当我们对引用进行推断的时候，实际上是推断原始的对象究竟是什么类型。

in/out 参数
#

为了避免拷贝，可以预先初始化一个对象传入其引用，这样可以避免拷贝，不过使得参数列表很乱。如果可行，还是通过返回值优化或者移动语义。

现代 C++ 笔记：类型转换、auto 与标准 I/O

Tue, 23 Sep 2025 08:50:10 +0800

循环，条件与分支
#

这个东西老生常谈了，我本来没有看的欲望，但是有一道题目很有意思，在此记录：

从 1 开始，向上计数，将任何只能被 3 整除的数字替换为“fizz”一词，将任何只能被 5 整除的数字替换为“buzz”一词，将任何可被 3 和 5 整除的数字替换为“fizzbuzz”一词，如果还可被 7 整除，那么替换为“fizzbuzzpop”。

首先，介绍一个名词：分支预测。

简单来说，现代 CPU 在进行多分支的判断（if-else）的时候，其实会去猜程序下一步的路径，如果猜对了，那么效率会提升；如果猜错了，那么只能把流水线上面的内容清空，然后重新执行指令。

所以无论如何，应该尽量避免写if-else。

题目给出的答案是这么写的：

// h/t to reader Waldo for suggesting this quiz
#include <iostream>

void fizzbuzz(int count) {
    for (int i{1}; i <= count; ++i) {
        bool printed{false};
        if (i % 3 == 0) {
            std::cout << "fizz";
            printed = true;
        }
        if (i % 5 == 0) {
            std::cout << "buzz";
            printed = true;
        }
        if (i % 7 == 0) {
            std::cout << "pop";
            printed = true;
        }

        if (!printed)
            std::cout << i;

        std::cout << '\n';
    } // end for loop
}

int main() {
    fizzbuzz(150);

    return 0;
}

能运行吗？能，优雅吗？我不太满意。

所以说，有没有一个办法，不同于这个思路，同时又能更计算机一点？

评论区的思路：

#include <iostream>

void fizzbuzz(int n)
{
  for (int i{ 1 }; i <= n; i++)
  {
    int f = (i%7 == 0)*4 + (i%5 == 0)*2 + (i%3 == 0);
    switch (f)
    {
    case 0:
      std::cout << i;
      break;
    case 1:
      std::cout << "fizz";
      break;
    case 2:
      std::cout << "buzz";
      break;
    case 3:
      std::cout << "fizzbuzz";
      break;
    case 4:
      std::cout << "pop";
      break;
    case 5:
      std::cout << "fizzpop";
      break;
    case 6:
      std::cout << "buzzpop";
      break;
    case 7:
      std::cout << "fizzbuzzpop";
      break;
    }
    std::cout << '\n';
  }
  return;
}

int main()
{
  fizzbuzz(22);
}

这个方法非常巧妙，把每一个分支映射到了一个二进制的向量空间上面，这将会极大的提高性能，因为对于 CPU 来说，移位操作是原生的。但是，带来的就是更多相似字符串的重复占用，不知道这是不是良好的实践呢？

如果还想减少的话，还是用if来去测试位，不过这样又引入了分支。

其实这么用的地方还是很多的，POSIX 的权限就是个例子。但是，用的时候就是想不到啊！

标准输出，标准错误和标准输入
#

这三者是这样的：

名字	文件描述符	在 c++ 中的对应
标准输入	0	`std::cin`
标准输出	1	`std::cout`
标准错误	2	`std::cerr`

类型转换
#

数值提升 (numberic promotion):
#

同类型，把一个更短的类型转换成一个更长的类型，安全，不会造成精度丢失。

只有两条路径：

bool，有/无负号的短整形，字符型->int->unsigned int
float->double

注意，从int到long不是提升，是转换。

数值转换 (numberic conversion):
#

基本类型的转换，包括：

窄化 (narrowing conversion)：长的类型转化成一个更短的类型，在{}中不被允许。

但是constexpr是允许的，因为是编译时求值，所以实际上是截断不是转化。

算术转换 (arithmetic conversion):
#

对基本算术操作符两端的不同类型进行转换，有些规则：

整数转浮点。
对于无符号/有符号：

如果没超过有符号上限，那就转换成有符号。
超过了，那就转换成无符号。

static_cast在编译时检查（类型在编译时是确定的），dynamic_cast在运行时检查。

不建议使用 C-Style 的转换，因为他可能使用上面中的任意一个以及const_cast。

auto
#

对于auto来说，必须要先确定得到的结果是什么，才能做推断，不能对没有初始化值的变量做推断。

在用std::cin的时候，给的类型是istream，所以自动推断会推出这个类型，肯定不是你想要的结果。

auto不会保留const的修饰，所以如果需要保留，用const auto。

auto 的尾随返回值
#

这其实一点都不auto，只是为了让函数名对齐，然后用->给出返回类型罢了。

auto add(int x, int y) -> int;
auto divide(double x, double y) -> double;
auto printSomething() -> void;
auto generateSubstring(const std::string &s, int start, int len) -> std::string;

现代 C++ 笔记：string_view、static 与内部链接

Fri, 19 Sep 2025 19:13:57 +0800

符号变量
#

magic number 这个词，我一直认为是大家约定好了的一组数，但是这里是不同的含义。

它指的是直接放在函数里面，没有任何交代的数据，使得程序更加难读。

所以做法一般是推荐用const修饰，如果标准高的话，constexpr，请。

字符串
#

从 c 开始那么久，都一直没认真了解过字符串，这会终于明白了std::string的一些基本操作。

众所周知，字符串里面不可避免包含空白字符，那么办法就是通过std::getline()，但是如果在std::cin之后使用，大概率这么传入(std::cin, target)是无效的，因为cin在读到空白字符之后会停止，并且把空白字符留在缓冲区，那么下一次读取的时候，直接就把一个\n传入了，所以你的字符串啥都没有。

问题解决是通过流操纵符std::ws（这个需要每次 cin 的时候都提供），控制如果一开始就读取到空白字符，那么就忽略掉这个字符继续读取后面的东西。

这时就很好的解决了读取到\n的问题，除非读取到下一个\n，那么getline才停止读取，此时字符串也成功存入了这一行。

怎么说呢，感觉比 c 先进一点点（？

string
#

因为string本身就是一个类，其构造函数本身就是重载的，所以无论在初始化的时候传入string,C-Style string还是string_view，都不会发生隐式转换。

但是如果函数要求的只是一个string参数，那么把别的类型传入，就会发生编译错误。原因是不允许发生string_view到string的窄化转换，性能问题。

string_view
#

// 用 string_view 指向 string 的话，不产生多余的拷贝，只是在初始化的时候拷贝进入 string
std::string name {"John"}; //此处产生拷贝
std::string_view name_v {name}; // 不拷贝

// 实际上，是让 string_view 指向一个 c 风格的字符串，这个过程没有拷贝。
std::string_view name {"John"};

如果常量能够在编译时确定，那么就可以应用constexpr。很显然，前者是不可行的，后者可以。

⚠️ string_view 的行为与普通的引用和指针不一致。

当用string来初始化string_view，然后string被修改之后，string_view并不会更新string的新长度。

如果要避免，得更新视图。（不知道智能指针是否有帮助？）

不建议用string_view来返回，除非它是用 C 式的字符串初始化的。

对于用string_view来说，推荐用法：

std::string_view s{"aaa"sv}; //在堆上分配了 C-Style 字符串，但是用的构造函数不一致，在复制省略中，这是一种过编译的办法。

实现零成本抽象，原因嘛，以后再补充…

对于流程控制的一些建议
#

对于只有两个分支的if，可以考虑用三元运算符? :。

如果表达式本身只有为0/1两种可能，那么就无须写==，直接把表达式扔上去即可。

static 与内部链接
#

在变量前加入static关键字，不仅仅会使变量在整个程序的生命周期有效，还会使得无法被外部文件访问此变量。

现代 cpp 已经不推荐使用此关键字了。转而替代的是匿名命名空间，后者可以实现里面的变量直接在当前文件访问，其他文件不可访问。

没加static的变量默认是全局变量，在别的文件使用extern引入，const默认就是内部变量。

static 的最佳用法

static最适合用于函数内的计数场景，比如调用了函数几次，只需在函数内声明一个静态局部变量即可。

不推荐使用此方法实现相同的输入不同的输出内容，这其实也不符合 fp 的原则。如果必须要这么用，那么最好的办法是将条件一起传入。参考

inline 关键字
#

从 cpp17 开始，完善了inline，使得constexpr对于编译时常量跨文件有了最佳解决方案。

inline本义其实指的是把函数展开到调用的地方，但是修饰constexpr时，它被赋予了不同的意义。

inline修饰constexpr特殊，当在多个文件中定义的时候，会告诉链接器从任意一份中取出一份定义，并且在所有文件中共享，同时并不违反 ODR 原则，这使得把inline放在文件头里面，就可以向引入这个头文件的所有源文件进行分发。

inline同时还可以修饰命名空间，修饰非匿名的命名空间可以使得本来需要域解析操作符的使用，直接被透传到全局的命名空间中去。

下面是一个嵌套的命名空间的例子，使得接口能够安全的对当前文件中的其他函数暴露：

#include <iostream>

namespace V1 // declare a normal namespace named V1
{
    void doSomething()
    {
        std::cout << "V1\n";
    }
}

inline namespace V2 // declare an inline namespace named V2
{
    namespace // unnamed namespace
    {
        void doSomething() // has internal linkage
        {
            std::cout << "V2\n";
        }

    }
}

int main()
{
    V1::doSomething(); // calls the V1 version of doSomething()
    V2::doSomething(); // calls the V2 version of doSomething()

    doSomething(); // calls the inline version of doSomething() (which is V2)

    return 0;
}

inline作用于V2命名空间，使得内部内容能够无须域解析操作符，但是匿名命名空间保护性最强，使得内部内容只能有当前文件访问，无法暴露给外部文件。

In modern C++, the term inline has evolved to mean “multiple definitions are allowed”.

总结下，inline除了内联的意义，其实还有：

对于变量：在头文件中定义，使得此头被多次引入的时候只使用共享的一次，避免每次都加载到文件，在头文件被多次引用的时候很有用 (c++17)。同时，如果变量同时被static constexpr修饰，那么它是隐式inline的。
对于函数：在头文件中定义的函数需要加（但是不推荐，等到后面看到类的构造函数再会来补充），声明的函数无须加。
对于命名空间：把某个命名空间中的内容暴露到全局的命名空间，使得其中内容访问无须加域解析操作符。

using 语句和 using 声明
#

语句指的是用一个命名空间，这个一般范围过大，不推荐，此处狠狠批评那些教用using namespace std;的人。

using 声明是可以接受的，因为它比起别名更加清晰，而不是只让写代码的人看懂。

现代 C++ 笔记：初始化、字面量与编译期

Thu, 11 Sep 2025 08:10:38 +0800

前言
#

最近找到个个还不错的网站，适合我这种大白，遂开始学习，记录一些感受。

此系列可能没有很好的排版，因为是给自己看的。

不保证所有的内容一定正确，因为是学习过程中记录的，所以可能还会有完全不正确的理解。

澄清一个我混淆的概念
#

表达式：求值，调用函数，变量/常量和运算符相结合的东西

语句：有分号的东西，可以由多个表达式复合而成。

statement expression（原谅我不会翻译）：只含一个表达式的语句。

标识符：用户自定义的名称，不以数字开头。

关键字：系统保留字，用于流程控制。

cin/cout探秘
#

我一直好奇，<<是怎么实现的，还能同时接着，是怎么使用的。

事实上，这运用的是运算符重载，语义分析会处理左右两边的表达式，然后决定是否重载它。

<<是左结合的，所以优先处理左边的部分。<<一看到左边是一个ostream类型，右边是一个字符串，自动重载，通过运算返回一个ostream，接着再处理次级优先的，依次拼接一个完整的字符串流。

这里提到一个重要概念：副作用。

正常来说，一个函数应该要返回值。当我们只使用一个<<的时候，确实只用到了副作用，如果我们连在一起使用的时候，那么返回值就非常重要了。这是不是有点像 fp，给定输入得到输出，接着成为另一个输入？

现代的初始化
#

现在 c++ 推荐使用列表直接初始化，避免隐式类型转换。

如：foo{}

还有别的办法：

直接初始化：foo(1)
间接列表初始化：foo = {1}

⚠️不推荐在同一行定义多个变量，因为会在 git 中导致 diff 不清晰。

literal/variable
#

学过微机的人都知道，一个程序加载进内存，会分别放到代码段和数据段，接着获取到一些段（stack，pile）。

其中：

代码段是只读的，同时和堆栈段中间还相隔了一些部分，这是避免数据溢出破坏程序的运行。
对于字面量来说，使用它，就直接到数据段里面取，没有分配给他额外的空间。
而对于变量来说，使用它，先得从数据段中拷贝一份到栈/堆（假设初始化的话），接着读取这个地址指向的内容，才能进行访问。

compile-time / runtime
#

什么是编译时和运行时的概念？

编译时：编译器在进行语法检查的时候。

运行时：程序真正运行的时候。

所以说，我们有下面的内容：

标识符和编译时相对应，对象和运行时相对应。
作用域（scope）和编译时对应，生命周期（lifetime）和运行时相对应。
同时还有一个大杀器：constexpr

这个关键字的意思，指的是能够在编译时就确定常量（甚至函数），而不是运行时，从而把运行时开销转换成编译时间。

现在，对于简单的函数，不含new/delete，cin/cout，随机数生成的函数，我们都推荐使用constexpr。

需要注意的是，如果一个常量是在块作用域中，而且初始化用的是常量表达式（{} 零初始化 是常量表达式），那么它会自动成为常量表达式。

需要注意的是，在 C++11~20 的不同版本中，支持的类型略有差异，比如后期才支持流程控制的 for/while/if。

感觉 gemini 这么说不错：

标识符是编译时的抽象，是对象在代码中的名字和类型。对象是运行时的实体，是标识符所代表的内存和数据。

cmake 的一些使用方法（对于多文件/引入 libs）
#

加入这一行把需要的头包含进来，就可以直接在#include 里面写.h的文件了，无须写相对路径。
```
target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
```
在 cmake 3.30 之后，引入 Boost 直接用find_package(Boost)就好。

Best Practise
#

尽量在使用一个变量的正前面初始化。
尽量不要使用无符号整形，因为其具有的环绕特性会在一些行为（比如与有符号整数比较）上面让人难以调试。

操作系统笔记：设备与驱动程序

Wed, 02 Jul 2025 11:28:27 +0800

插上u盘，是如何工作的？
#

usb控制器检测到电平变化 -> 硬件中断 -> 总线驱动捕获中断 -> sysfs创建设备目录和属性文件 -> 内核通过netlink发出uevent消息，广播

为什么udev的效率高？
#

udev被内核发送的uevent唤醒，而不是一直去轮询内核。
udev是并行工作的。在多个设备插入的时候，为每个事件启动一个处理实例。
udev使用的Netlink为传递短小的控制信息优化，比其他IPC更加轻量和迅速。
udev启动的时候会读取所有.rules文件，并解析成快速查询的内存数据结构。（这个就像mihomo一样，提前把规则处理成一个搜索树，使得匹配效率大幅提高）

I/O设备控制
#

X86同时支持MMIO/PMIO，ARM只支持MMIO。

通过一条线，一条指令就可以实现控制。

控制方式：

MMIO: 把外部控制寄存器映射到内存地址空间。使得一块特定的内存地址不再对应物理RAM。像这块内存地址写入，就是发送到硬件的控制寄存器，而从这里读取，就是获取寄存器当前的状态。
PMIO: （微机里面的IN/OUT指令）

使用内存的地址空间，不会造成存的浪费吗？

早期的32位系统，你安装了4G内存，会发现只有3.几可用，剩下为硬件保留的内存就是这个原因。一般都是被强制保留给PCIe的MMIO。

GPIO
#

一个通用的IO，有别于专用IO（USB/HDMI）。可以编程，可以作为输入或者输出。

输入模式：读取外部世界。通过这个引脚送过来的电平是高或者低来感知外部世界。
输出模式：设置这个引脚为高电平或者低电平，从而控制外部设备。

学习笔记 on T.本秋的自留地

现代 C++ 笔记：I/O 流与字符串流

流 #

std::cin >> #

C-style 的函数 #

现代 C++ 笔记：继承、虚函数与异常处理

继承，派生 #

继承初始化 #

修改派生类的访问权限 #

访问修饰符 #

using来强制改变单个成员 #

隐藏功能 #

删除功能 #

虚函数 #

覆盖 #

协变返回类型 #

虚析构函数 #

绑定和调度 #

纯虚函数，纯虚类，虚基类 #

切片 #

RTTI #

dynamic_cast #

typeid #

委派重载函数 #

异常处理 #

异常对象的存储机制 #

在 catch 中抛出异常 #

函数级异常 #

noexcept #

std::move_if_noexcept #

现代 C++ 笔记：移动语义、智能指针与值类别

左右值、&&、移动语义、智能指针 #

类型 (Type) #

值类别 (Value Category) #

&&/& 作为函数形参 #

&& 在模板参数的使用 #

实现移动 #

智能指针 #

unique_ptr #

shared_ptr 和 weak_ptr #

关系 #

组合、聚合和关联 #

初始化列表 initializer_list #

现代 C++ 笔记：Lambda、运算符重载与闭包

命令行参数 #

std::stringstream #

std::stoi #

lambda 表达式 #

捕获 #

按对象捕获 #

默认捕获 #

创建闭包 #

实现一个简单的函数 #

lambda 表达式可以作为 lambda 类型的变量存储。 #

也可以声明的时候就调用： #

在算法库的应用 #

lambda 推断 #

带捕获的 lambda 拷贝 #

运算符重载 #

重载一元+/- #

重载自增/减 #

下标访问重载 #

飞船运算符 #

类型转换重载 #

复制运算符重载 #