世界上存在成千上万种学习法，如果上天只让我掌握一种，那一定就是“费曼学习法”。


## 介绍
费曼学习法是由诺贝尔物理学奖获得者理查德·费曼提出的一种学习方法，其核心思想是将所学内容用自己的话表达出来，以此检验自己对知识的掌握程度。

费曼学习法可以简化为四个单词：**Concept**、**Teach**、**Review**、**Simplify**

具体而言，费曼学习法包括以下几个步骤：

- **Concept**：选择一个主题，并尽可能全面地了解这个主题；

- **Teach**：将所学内容以简明易懂的语言写下来或讲述给别人听，使用通俗易懂的语言和例子，避免使用学术术语和复杂的句子；

- **Review**：检查自己的表达是否清晰明了，是否有遗漏或错误；

- **Simplify**：基于反馈修正自己的表达，直到能够清晰表达该主题。

其优点是：

- 突出重点：在解释一个概念时，我们不得不选取最重要的信息，并将其用自己的话表达出来。这种方式可以帮助我们更好地理解和记忆知识点。

- 发现问题：当我们尝试用自己的话阐述某个主题时，常常会发现自己对某些内容并不理解或者存在疑问。这种方式可以帮助我们及时发现自己的盲点和问题，促进深层次的学习。

- 加深印象：通过不断反复的讲解和修正，我们能够形成对于某个主题的深层次理解，并加深对于相关概念的印象。

## 数据

美国学术界在1946年一项研究显示了不同学习方式的效益，准确的说，是学习者在两周以后还能记住内容（平均学习保持率）的多少。

下图是当时美国教育学家Engar Dale研究出的“学习金字塔”（The Cone of Learning）。

![image.png](https://niuery.com/static/img/a270baa53b9f0798e17123dc62717220.image.png)

由上图可以看出，**Learning by teaching 可以说是学习效率最高的方式**。

Learning by teaching --- 费曼学习法

## 引言
前段时间，因新项目是的 `x64` 的，而老项目是 `x86` 的，新老项目又有一个共用的底层库是 `x86` 的，本来我新项目编译为`any CPU` 时在调用公共底层库也是没问题的，但是还有一个用于连接仪器的外部 `c++` 库文件是 `x64` ，此时 `any cpu` 的新项目， `x86` 底层库，加一个 `x64` 的外部 `c++` 库，此时这个 `c++`  库文件就无法使用了，为了糅合这种情况，也为了把公共底层库剥离出来（因为后续新项目仍然会用该库），想办法采用进程间通讯的方式，来解决这一问题



## 命名管道简介

:::warning{title="注意"}
以下内容来自AI
:::
命名管道（Named Pipe）是一种用于**进程间通信（IPC，Inter-Process Communication）** 的机制，主要作用是实现同一台计算机上不同进程之间（或网络中不同计算机的进程之间）的数据传输和交互。它是操作系统提供的一种高级IPC方式，相比其他通信方式（如信号、共享内存等）。

### 命名管道的核心作用：
1. **本地进程间通信**  
   最常见的用途是在同一台计算机上的不同进程之间传递数据。例如：
   - 一个应用程序（如视频编辑软件）可以通过命名管道向另一个进程（如渲染引擎）发送任务指令。
   - 后台服务（如数据库服务）可以通过命名管道接收客户端程序（如数据库管理工具）的请求并返回结果。

2. **跨网络通信**  
   命名管道支持网络通信（如Windows的"命名管道网络协议"），允许不同计算机上的进程通过网络进行数据交互。例如：
   - 客户端程序可以通过网络连接到远程服务器的命名管道，实现跨机器的数据传输。
   - 相比Socket，命名管道在Windows环境下的网络通信更简单，无需手动处理底层TCP/IP细节。

3. **双向通信支持**  
   命名管道可以配置为**双向通信模式**（`PipeDirection.InOut`），允许通信双方既发送数据又接收数据，适合需要交互对话的场景（如客户端与服务端的命令交互）。

4. **可靠的数据传输**  
   命名管道提供基于"流"或"消息"的传输模式，确保数据按顺序、完整地传递，避免数据丢失或错乱。例如：
   - 采用`PipeTransmissionMode.Message`模式时，接收方可以按消息边界准确拆分数据，无需手动处理分包。

5. **安全性控制**  
   支持通过权限设置（如`PipeSecurity`）限制访问者，确保只有授权进程能连接或读写数据，适合传输敏感信息。


### 命名管道的典型应用场景：
- 客户端-服务端架构（如数据库客户端与服务端通信）。
- 桌面应用与后台服务的交互（如杀毒软件前台界面与后台监控进程）。
- 复杂应用的模块化拆分（将功能拆分为多个进程，通过管道协作）。
- 跨网络的轻量级数据交换（相比HTTP/Socket更简单的局域网通信）。


### 与其他IPC方式的对比：
- **相比共享内存**：命名管道更易用，无需手动处理同步问题，但传输效率略低。
- **相比Socket**：在本地通信时更高效，无需经过网络协议栈；网络通信时封装了底层细节，使用更简单。
- **相比消息队列**：命名管道是点对点通信，更适合实时交互，而消息队列适合异步、一对多的场景。

总之，命名管道是一种平衡了易用性、安全性和效率的IPC机制，尤其在Windows环境下被广泛用于进程间的数据交互。

## 示例

### NamedPipeClient
代码如下：

```csharp
using System;
using System.IO;
using System.IO.Pipes;
using System.Text;
using System.Threading.Tasks;

class PipeClient
{
    static void Main(string[] args)
    {
        Console.WriteLine("命名管道客户端已启动...");
        Console.WriteLine("尝试连接到服务端...");

        // 创建命名管道客户端流，连接到本地计算机上的管道
        var clientStream = new NamedPipeClientStream(
           ".",                    // 服务器名称，"." 表示本地计算机
           "MyNamedPipe",          // 管道名称，必须与服务端一致
           PipeDirection.InOut,    // 双向通信
           PipeOptions.Asynchronous);

        try
        {
            // 连接到服务端，超时时间设置为5秒
            clientStream.Connect(5000);
            Console.WriteLine("已成功连接到服务端！");

            // 使用StreamReader和StreamWriter简化读写操作
            var reader = new StreamReader(clientStream, Encoding.UTF8);
            var writer = new StreamWriter(clientStream, Encoding.UTF8);

            string serverMessage;
            // 循环发送消息到服务端
            while (true)
            {
                Console.Write("请输入要发送给服务端的消息(输入exit退出): ");
                string clientMessage = Console.ReadLine();

                // 发送消息到服务端
                writer.WriteLine(clientMessage);
                writer.Flush();

                // 如果客户端发送"exit"，则退出通信
                if (clientMessage.Equals("exit", StringComparison.OrdinalIgnoreCase))
                {
                    Console.WriteLine("客户端请求断开连接...");
                    break;
                }

                // 等待服务端回应
                serverMessage = reader.ReadLine();
                if (serverMessage == null)
                {
                    Console.WriteLine("服务端已断开连接");
                    break;
                }

                Console.WriteLine($"收到服务端消息: {serverMessage}");

                // 如果服务端发送"exit"，则退出通信
                if (serverMessage.Equals("exit", StringComparison.OrdinalIgnoreCase))
                {
                    Console.WriteLine("服务端请求断开连接...");
                    break;
                }
            }

        }
        catch (TimeoutException)
        {
            Console.WriteLine("连接超时，无法连接到服务端");
        }
        catch (IOException ex)
        {
            Console.WriteLine($"通信错误: {ex.Message}");
        }


        Console.WriteLine("客户端已停止，按任意键退出...");
        Console.ReadKey();
    }
}

```

### NamedPipeServer
代码如下：

```csharp
using System;
using System.IO;
using System.IO.Pipes;
using System.Text;
using System.Threading.Tasks;

class PipeServer
{
    static void Main(string[] args)
    {
        Console.WriteLine("命名管道服务端已启动...");
        Console.WriteLine("等待客户端连接...");

        // 创建命名管道服务器流，使用 "." 表示本地计算机
        var serverStream = new NamedPipeServerStream(
         "MyNamedPipe",          // 管道名称
         PipeDirection.InOut,    // 双向通信
         NamedPipeServerStream.MaxAllowedServerInstances,
         PipeTransmissionMode.Message,
         PipeOptions.Asynchronous);

        // 等待客户端连接
        serverStream.WaitForConnection();
        Console.WriteLine("客户端已连接！");

        // 使用StreamReader和StreamWriter简化读写操作
        var reader = new StreamReader(serverStream, Encoding.UTF8);
        var writer = new StreamWriter(serverStream, Encoding.UTF8);

        try
        {
            string clientMessage;
            // 循环接收客户端消息
            while (true)
            {
                clientMessage = reader.ReadLine();

                Console.WriteLine($"收到客户端消息: {clientMessage}");

                // 如果客户端发送"exit"，则退出通信
                if (clientMessage.Equals("exit", StringComparison.OrdinalIgnoreCase))
                {
                    Console.WriteLine("客户端请求断开连接...");
                    break;
                }

                // 向客户端发送回应
                Console.Write("请输入要发送给客户端的消息: ");
                string serverMessage = Console.ReadLine();
                writer.WriteLine(serverMessage);
                writer.Flush();

                // 如果服务端发送"exit"，则退出通信
                if (serverMessage.Equals("exit", StringComparison.OrdinalIgnoreCase))
                {
                    Console.WriteLine("服务端请求断开连接...");
                    break;
                }
            }
        }
        catch (IOException ex)
        {
            Console.WriteLine($"通信错误: {ex.Message}");
        }


        Console.WriteLine("连接已关闭");

        Console.WriteLine("服务端已停止，按任意键退出...");
        Console.ReadKey();
    }
}

```

### 测试
将上述两个控制台程序编译后，直接运行两个程序后，会自动连接，如下图：

![image.png](https://niuery.com/static/img/8137421d7bff75d38c754cf4dba86d07.image.png)

在开发和测试过程中，也发现一些问题：
- 跨平台兼容性差，Windows 与 Linux/macOS 实现差异大；
- 网络通信局限，仅适用于局域网 SMB 环境，难用于互联网；
- 并发连接数有限，高并发需手动管理多实例；
- 性能不及共享内存，数据传输有内核缓冲区开销；
- 无内置消息队列，需手动实现缓存、重试；
- 调试难，连接失败原因模糊，异常易残留资源；
- 安全配置门槛高，权限规则需深入系统安全知识。

所以，重点关注第二节中**命名管道的核心作用**描述中的场景，仅在这些场景下，推荐使用命名管道进行进程间通讯。

进程间通讯 --- 命名管道

## 引言  
位运算是计算机底层最基础的操作，直接操作二进制位（0 和 1）。尽管现代编程语言提供了高级抽象，但理解位运算的本质能显著提升代码效率和解决特定问题的能力。本文将深入探讨位运算的核心原理、常见技巧及其实际应用场景。



## 一、位运算的本质：二进制视角  
所有位运算都基于二进制数的逐位操作。以下是六种基本操作：  
1. **与（AND）** `&`  
   - 规则：两位均为 1 时结果为 1，否则为 0。  
   - 示例：`1010 & 1100 = 1000`  
   - 本质：掩码操作（保留/清除特定位）。  

2. **或（OR）** `|`  
   - 规则：任意一位为 1 时结果为 1。  
   - 示例：`1010 | 1100 = 1110`  
   - 本质：组合标志位（如权限合并）。  

3. **异或（XOR）** `^`  
   - 规则：两位不同时结果为 1，否则为 0。  
   - 示例：`1010 ^ 1100 = 0110`  
   - 本质：开关特性（两次异或还原原值）。  

4. **非（NOT）** `~`  
   - 规则：按位取反。  
   - 示例：`~1010 = 0101`（假设 4 位）  
   - 本质：数值取反（`~x = -(x+1)`）。  

5. **左移（SHL）** `<<`  
   - 规则：二进制位向左移动，低位补 0。  
   - 示例：`1010 << 2 = 101000`  
   - 本质：乘以 $2^n$（无溢出时）。  

6. **右移（SHR）** `>>`  
   - 规则：二进制位向右移动，高位补符号位（算术右移）或 0（逻辑右移）。  
   - 示例：`1010 >> 2 = 0010`（逻辑右移）  
   - 本质：除以 $2^n$（向下取整）。  

---

## 二、位运算的实用技巧  
1. **判断奇偶性**  
   ```csharp  
   bool isOdd = (num & 1) == 1; // 末位为 1 则为奇数  
   ```  

2. **交换两个数（无临时变量）**  
   ```csharp  
   a ^= b; // a = a ^ b  
   b ^= a; // b = b ^ (a ^ b) = a  
   a ^= b; // a = (a ^ b) ^ a = b  
   ```  

3. **求绝对值（整数）**  
   ```csharp  
   int mask = num >> 31; // 负数得全1，正数得0  
   int abs = (num ^ mask) - mask; // 负数取反加1  
   ```  

4. **检查第 k 位是否为 1**  
   ```csharp  
   bool isSet = (num & (1 << k)) != 0;  
   ```  

---

## 三、实际应用场景  
1. **状态压缩**  
   - **场景**：用单个整数表示布尔集合（如背包问题、子集枚举）。  
   - **示例**：用 `bitmask` 表示开关状态：  
     ```csharp  
     int state = 0;  
     state |= (1 << 3); // 打开第3位  
     state &= ~(1 << 3); // 关闭第3位  
     ```  

2. **高效数学计算**  
   - **乘法模拟**：`a * 7 = a << 3 - a`（因 $7 = 8-1$）。  
   - **2的幂判断**：`(n & (n-1)) == 0`（如 `8 & 7 = 0`）。  

3. **数据加密**  
   - **简单加密**：通过异或密钥实现快速加解密：  
     ```csharp  
     byte encrypted = data ^ key;  
     byte decrypted = encrypted ^ key; // 还原  
     ```  

4. **位图（Bitmap）**  
   - **场景**：海量数据去重（如 40 亿整数中找重复值）。  
   - **原理**：用 1 位表示一个数是否存在，内存占用仅为传统数组的 1/32。  

---

## 四、注意事项  
1. **运算符优先级**：位运算优先级低于算术运算，建议多用括号：  
   ```csharp  
   int result = (a & b) << 2; // 避免歧义  
   ```  

2. **位移边界**  
   - 左移丢弃高位，右移丢弃低位。  
   - 避免位移位数超过数据类型宽度（如 `int << 32` 未定义）。  

3. **有符号数处理**  
   - 算术右移（`>>`）保留符号位，逻辑右移（`>>>`）补 0（C# 用 `>>>`）。  

---

## 结语  
位运算将复杂问题转化为底层二进制操作，在算法优化、系统编程等领域至关重要。掌握其本质后，可灵活应用于性能敏感场景（如游戏引擎、嵌入式系统）。后续文章将探讨位运算在算法题中的实战技巧。

数据结构与算法 --- 位运算

## 引言
最近有一些碎片时间，利用碎片时间在[力扣](https://leetcode.cn/)刷一刷算法题，碰到了一道题，算法过程的子算法需要反转部分链表，看了看题解，觉得这个链表翻转的算法很有趣，也是一种有趣的思路，记录一下。



## 代码实现
还是直接上代码吧

```csharp
public class ListNode
{
	public int val;
	public ListNode next;
	public ListNode(int val = 0, ListNode next = null)
	{
		this.val = val;
		this.next = next;
	}
}

public ListNode ListNodeReverse(ListNode head)
{

	ListNode prev = null;
	ListNode curr = head;
	while (curr != null)
	{
		ListNode nextTemp = curr.next;
		curr.next = prev;
		prev = curr;
		curr = nextTemp;
	}
	return prev;
}
```
算法讲解：
1. 初始状态：`prev` 指向 `null`，`curr` 指向原始链表的头节点（`head`）。
2. 核心逻辑：
    
    通过循环逐个处理节点，每次迭代中：
    
    ①：先保存当前节点的下一个节点（避免指针丢失）。
    
    ②：将当前节点的 `next` 指针反向指向 `prev`（完成一次反转）。
    
    ③：移动 `prev` 和 `curr` 指针，继续处理下一个节点。
3. 终止条件：当 `curr` 指向 `null` 时，说明所有节点已处理完毕，`prev` 此时指向反转后链表的头节点。

## 算法流程图
根据上述的算法，我手绘了算法流程图，以此方便更快的理解上述算法：
![链表的反转.jpg](https://niuery.com/static/img/5e618b936cd96be4e044fa13afd98f8a.%C3%A9%C2%93%C2%BE%C3%A8%C2%A1%C2%A8%C3%A7%C2%9A%C2%84%C3%A5%C2%8F%C2%8D%C3%A8%C2%BD%C2%AC.jpg)

## 小结
该流程的时间复杂度为 O(n)（需遍历所有节点），空间复杂度为 O(1)（仅使用 3 个指针变量），是反转链表的最优解法之一