feat: add some learning notes

learncpp2-4

Author: minortex

content/posts/learncpp_1/index.md

@@ -2,7 +2,7 @@
 title: "cpp学习笔记（1）"
 date: 2025-09-11T08:10:38+08:00
 draft: false
-lastmod: 2025-09-20T21:59:46+08:00
+lastmod: 2025-09-30T10:28:08+08:00
 ---
 
 ## 前言
@@ -78,7 +78,9 @@ statement expression（原谅我不会翻译）：只含一个表达式的语句
 
 3. 同时还有一个大杀器：`constexpr`
 
-    这个关键字的意思，指的是能够在编译时就确定常量（甚至函数），而不是运行时，从而把运行时开销转换成编译时间，这是不是算是性能优化呢？
+    这个关键字的意思，指的是能够在编译时就确定常量（甚至函数），而不是运行时，从而把运行时开销转换成编译时间。
+
+    现在，对于简单的函数，不含`new/delete`，`cin/cout`，随机数生成的函数，我们都推荐使用`constexpr`。
 
     需要注意的是，在C++11~20的不同版本中，支持的类型略有差异，比如后期才支持流程控制的for/while/if。
 

content/posts/learncpp_2/index.md

@@ -1,7 +1,8 @@
 +++
 date = '2025-09-19T19:13:57+08:00'
-draft = true
+draft = false
 title = 'cpp学习笔记（2）'
+lastmod = '2025-09-25T10:55:18+08:00'
 +++
 ## 符号变量
 
@@ -47,3 +48,93 @@ std::string_view name {"John"};
 ---
 
 不建议用`string_view`来返回，除非它是用C式的字符串初始化的。
+
+对于用`string_view`来说，推荐用法：
+
+```cpp
+std::string_view s{"aaa"sv};
+```
+
+实现零成本抽象，原因嘛，以后再补充...
+
+## 对于流程控制的一些建议
+
+对于只有两个分支的`if`，可以考虑用三元运算符`? :`。
+
+如果表达式本身只有为`0/1`两种可能，那么就无须写`==`，直接把表达式扔上去即可。
+
+## static与内部链接
+
+在变量前加入`static`关键字，不仅仅会使变量在整个程序的生命周期有效，还会使得无法被外部文件访问此变量。
+
+现代cpp已经不推荐使用此关键字了。转而替代的是匿名命名空间，后者可以实现里面的变量直接在当前文件访问，其他文件不可访问。
+
+没加`static`的变量默认是全局变量，在别的文件使用`extern`引入，`const`默认就是内部变量。
+
+> static的最佳用法
+
+`static`最适合用于函数内的计数场景，比如调用了函数几次，只需在函数内声明一个静态局部变量即可。
+
+不推荐使用此方法实现相同的输入不同的输出内容，这其实也不符合fp的原则。如果必须要这么用，那么最好的办法是将条件一起传入。[参考](https://www.learncpp.com/cpp-tutorial/static-local-variables/)
+
+## inline关键字
+
+从cpp17开始，完善了`inline`，使得`constexpr`对于编译时常量跨文件有了最佳解决方案。
+
+`inline`本义其实指的是把函数展开到调用的地方，但是修饰`constexpr`时，它被赋予了不同的意义。
+
+`inline`修饰`constexpr`特殊，当在多个文件中定义的时候，会告诉链接器从任意一份中取出一份定义，并且在所有文件中共享，同时并不违反ODR原则，这使得把`inline`放在文件头里面，就可以向引入这个头文件的所有源文件进行分发。
+
+`inline`同时还可以修饰命名空间，修饰非匿名的命名空间可以使得本来需要域解析操作符的使用，直接被透传到全局的命名空间中去。
+
+下面是一个嵌套的命名空间的例子，使得接口能够安全的对当前文件中的其他函数暴露：
+
+```cpp
+#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`除了内联的意义，其实还有：
+
+1. 对于变量： 在头文件中定义，使得此头被多次引入的时候只使用共享的一次，避免每次都加载到文件，在头文件被多次引用的时候很有用(c++17)。
+2. 对于函数：在头文件中定义的函数需要加（但是不推荐，等到后面看到类的构造函数再会来补充），声明的函数无须加。
+3. 对于命名空间： 把某个命名空间中的内容暴露到全局的命名空间，使得其中内容访问无须加域解析操作符。
+
+## using语句和using声明
+
+语句指的是用一个命名空间，这个一般范围过大，不推荐，此处狠狠批评那些教用`using namespace std;`的人。
+
+using声明是可以接受的，因为它比起别名更加清晰，而不是只让写代码的人看懂。

content/posts/learncpp_3/index.md

@@ -0,0 +1,179 @@
++++
+date = '2025-09-23T08:50:10+08:00'
+draft = false
+title = 'cpp学习笔记(3)'
+lastmod = '2025-09-26T09:27:20+08:00'
++++
+
+## 循环，条件与分支
+
+这个东西老生常谈了，我本来没有看的欲望，但是有一道题目很有意思，在此记录：
+
+> 从 1 开始，向上计数，将任何只能被 3 整除的数字替换为“fizz”一词，将任何只能被 5 整除的数字替换为“buzz”一词，将任何可被 3 和 5 整除的数字替换为“fizzbuzz”一词，如果还可被7整除，那么替换为“fizzbuzzpop”。
+
+首先，介绍一个名词：分支预测。
+
+简单来说，现代CPU在进行多分支的判断（`if-else`）的时候，其实会去猜程序下一步的路径，如果猜对了，那么效率会提升；如果猜错了，那么只能把流水线上面的内容清空，然后重新执行指令。
+
+所以无论如何，应该尽量避免写`if-else`。
+
+题目给出的答案是这么写的：
+
+```cpp
+// 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;
+}
+```
+
+能运行吗？能，优雅吗？我不太满意。
+
+
+所以说，有没有一个办法，不同于这个思路，同时又能更计算机一点？
+
+评论区的思路：
+
+```cpp
+#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):
+
+同类型，把一个更短的类型转换成一个更长的类型，安全，不会造成精度丢失。
+
+只有两条路径：
+
+1. `bool`，有/无负号的短整形，字符型->`int`->`unsigned int`
+2. `float`->`double`
+
+注意，从`int`到`long`不是提升，是转换。
+
+### 数值转换(numberic conversion):
+
+基本类型的转换，包括：
+
+窄化(narrowing conversion)：长的类型转化成一个更短的类型，在{}中不被允许。
+
+> 但是`constexpr`是允许的，因为是编译时求值，所以实际上是截断不是转化。
+
+### 算术转换(arithmetic conversion):
+
+对基本算术操作符两端的不同类型进行转换，有些规则：
+
+1. 整数转浮点。
+2. 对于无符号/有符号：
+  
+  - 如果没超过有符号上限，那就转换成有符号。
+  - 超过了，那就转换成无符号。
+
+`static_cast`在编译时检查（类型在编译时是确定的），`dynamic_cast`在运行时检查。
+
+不建议使用C-Style的转换，因为他可能使用上面中的任意一个以及`const_cast`。
+
+## auto
+
+对于`auto`来说，必须要先确定得到的结果是什么，才能做推断,不能对没有初始化值的变量做推断。
+
+在用`std::cin`的时候，给的类型是`istream`，所以自动推断会推出这个类型，肯定不是你想要的结果。
+
+`auto`不会保留`const`的修饰，所以如果需要保留，用`const auto`。
+
+---
+
+### auto的尾随返回值
+
+这其实一点都不`auto`，只是为了让函数名对齐，然后用`->`给出返回类型罢了。
+
+```cpp
+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;
+```