new: cpp6,7

Author: minortex

content/posts/learncpp_6/index.md

@@ -0,0 +1,163 @@
++++
+date = '2025-10-13T08:25:04+08:00'
+draft = true
+title = 'cpp学习笔记(6)'
++++
+
+## std::vector
+
+此向量非彼向量。
+
+### 对于字符串
+
+推荐使用`string_view`配合C风格的字符串，这样效率最高，只发生一次堆内存分配。
+
+```cpp
+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
+
+推荐使用这些：
+
+1. **修改元素副本**：`auto`
+2. **修改原始元素**：`auto`
+3. **只需要查看**：`const auto&`（大多数情况）
+
+反向查看：使用`std::view::reverse()`
+
+### 容量和长度
+
+容量是分配给向量的内存，长度是实际使用的部分。
+
+`pop`的时候长度减少容量不变；`push`时如果遇到容量瓶颈，会自动复制扩容（2/1.5）倍。
+
+`resize`成员函数会同时改变容量和长度，`reserve`只改变容量。
+
+`emplace_back`会显示调用构造函数，直接在栈顶构建对象，如果是是临时对象，那么要注意如果有`explicit`那么不能执行隐式转换。而`push_back`会发生一次拷贝。
+
+## std::array
+
+`array` 大部分功能都与 `constexpr` 兼容。
+
+在 `constexpr` 表达式执行的从 `unsign` 到 `sign` 的转换是允许的，因为编译器对此信任程度很高。
+
+### .at()、[]和std::get()
+
+- **`.at()`**: 运行时边界检查。(C++17后编译时检查)
+- **`std::get<index>(arr)`**: 编译时边界检查。
+- **`[]`**: 不进行边界检查，C++11后可为 `constexpr` 。
+
+对于现代C++来说， `.at` 是更安全的选择。
+
+因为会在越界访问的时候抛出异常。而 `[]` 不会进行越界检查。
+
+### 用模板创建数组
+
+```cpp
+
+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带来的技术债。
+
+```cpp
+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：
+
+```cpp
+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` 的函数指针为例：
+
+```cpp
+#include<functional>
+std::function<int(int, int)> ptr {&foo};
+std::function<int(int, int)> bar(){
+    // some implementation
+}
+```

content/posts/learncpp_7/index.md

@@ -0,0 +1,231 @@
++++
+date = '2025-10-22T16:29:09+08:00'
+draft = true
+title = 'cpp学习笔记(7)'
++++
+
+## 命令行参数
+
+早就知道在 `c` 中是可以在 `main` 中获取从命令行传入的参数的。但是对于解析是一窍不通，这里简单说一下如何获取整形。
+
+不过，这些方法都仅仅适用于简单的字符串处理，而一个简单的带参 `cli` 程序，基本都要求参数能够无视顺序，可选参数，这些统统都不能实现...
+
+### `std::stringstream`
+
+这个函数用于把字符串转换成流，然后再把流输出到整形。
+
+```cpp
+std::stringstream convert{arcv[1]};
+int num{};
+if(convert>>num){
+    std::cout<<num;
+}
+```
+
+### std::stoi
+
+这个就是现代C++的方法了。
+
+直接转换就行：
+
+```cpp
+    int num{std::stoi(argv[1])};
+    std::cout << num;
+```
+
+## lambda表达式
+
+lambda表达式看起来像这样子：
+
+```cpp
+[<capture>](<parameter list>) -> <return type> {<body>};
+```
+
+参数列表可以省略，返回值也可以省略，会自动推断。
+
+所以说，最简的 `lambda` 表达式：`[]{}`。
+
+### 捕获
+
+对于以下变量来说，不需要捕获也可使用：
+
+- 全局变量，静态局部变量，线程局部变量
+- 常量表达式（包括被编译器视为常量表达式的变量）
+
+捕获语法是 `lambda` 表达式中一个不可缺少的部分，词法分析就是通过 `[]` 来发现这是一个表达式的。
+
+> `lambda` 表达式不和 `{}` 一样，不能访问上级大括号中的局部变量。它只能访问静态和全局的变量，以及 `constexpr`。
+
+而捕获其实就是把原来应该能让 `lambda` 能够使用的局部变量让它使用。
+
+捕获的时候可以声明新变量的，在 `[]` 内，可以使用当前块内能访问的变量来参与运算。
+
+捕获有两种类型：默认捕获和单个捕获。
+
+### 按对象捕获
+
+假设有变量 `a` `b`: 
+
+- 传值：`[a,b]`。默认传入变量的**常量**值，如果需要修改，需要在大括号前加上 `mutable`。
+- 传引用：`[&a,&b]`
+
+### 默认捕获
+
+默认捕获会捕获 `lambda` 中提到的所有变量。
+
+- `[=]`：传入值
+- `[&]`：传入引用
+
+不允许同时使用默认捕获和按对象的捕获。
+
+### 创建闭包
+
+提到闭包这个词，就不得不提函数式编程了。简单来说，函数是“一等公民”，就像我们传统的命令式编程的变量（对象）一样，可以作为参数传递，可以被返回，可以运行时创建等等。
+
+那么闭包就是保存了当前上下文中某些状态的函数。
+
+在C++中，想实现一个闭包，还是得定义一个普通函数（虽然说跟一般的匿名函数印象不太一样）：
+
+```cpp
+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` 类型的变量存储。
+
+```cpp
+    auto square{[](int base) { return base * base; }};
+    std::cout << square(3);
+```
+
+#### 也可以声明的时候就调用：
+
+```cpp
+[]() { 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`，那么就需要添加一个成员重载函数：
+
+```cpp
+const auto& operator[](T t) const;
+```
+
+这个函数被常量对象优先使用，被非常量对象次优先使用。
+
+在C++23，用右值引用解决此问题。
+
+### 飞船运算符
+
+外来语言的符号，用于比较两个数大小关系。
+
+返回下面类型：
+
+**`strong_ordering`**: 有`equivalent`、`equal`、`greater` 和 `less`。
+
+**`weak_ordering`**: 比 `strong` 少了相等，因为是弱，只有等效。
+
+**`partial_ordering`**: 相比 `weak` 多了 `unordered`，用于表示无法比较的情况。
+
+从上往下可以隐式转换。
+
+### 类型转换重载
+
+类型转换重载也是 `operator` 操作符，不过重载的目标其实有点像C的强制转换：
+
+```cpp
+class MyClass{
+    //...
+  public:
+    operator int() { 
+        // conversion
+        return <intType_obj>;
+    }
+};
+```
+
+无须返回值，也无须参数，因为显而易见的返回目标类型，传入的是这个类对象，这也必须是一个类成员函数。
+
+建议加上 `explicit` 关键字，因为我们不希望隐式转换带来的不确定性。
+
+> 如何平衡类型转换重载和转换构造函数？
+
+假设要把A转换成B：
+
+A可改，B不可改。那么就定义一个类型转换的重载。
+
+A不可改，B可改。那么就定义一个参数只含A的转换构造函数，让B去接收A。
+
+A、B都不可改。那么定义一个普通函数实现转换吧。
+
+### 复制运算符重载
+
+在动态分配内存中，有时为了避免自己赋值给自己，用一个 `if` 来设置保护防止出现空指针问题。
+
+在三/五/零原则中，如果不带指针，那么应该不应该定义这个复制运算符重载。（其他：析构、复制构造，移动运算符，移动构造函数）