今日任务：

1. LeetCode977 有序数组的平方
2. LeetCode209 长度最小的子数组 
3. LeetCode59 螺旋矩阵Ⅱ



> 今日心情：今天一天的课，在椅子上缩着坐了一天，腰好累。

资料来源：

[977.有序数组的平方](https://programmercarl.com/0977.%E6%9C%89%E5%BA%8F%E6%95%B0%E7%BB%84%E7%9A%84%E5%B9%B3%E6%96%B9.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE)

[209.长度最小的子数组](https://programmercarl.com/0209.%E9%95%BF%E5%BA%A6%E6%9C%80%E5%B0%8F%E7%9A%84%E5%AD%90%E6%95%B0%E7%BB%84.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE)

[59.螺旋矩阵II](https://programmercarl.com/0059.%E8%9E%BA%E6%97%8B%E7%9F%A9%E9%98%B5II.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE)

### 1 LeetCode977 有序数组的平方


:::info{title="题目"}

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：
```
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
```
示例 2：
```
输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]
```

提示：

* 1 <= nums.length <= 104
* -104 <= nums[i] <= 104
* nums 已按 非递减顺序 排序
:::

在一开始看到这道题的时候，我原本是有思路的，想着从数组的两端同时向中间循环，被循环的值进行比较。但是只想着在原数组中进行操作了，想着根据比较的结果交换位置，但是越换越乱，在看了视频之后才如梦初醒。

``` python
from typing import List

# 对于取绝对值和insert函数这种 还是允许我稍微偷个懒吧（）
# 毕竟这里insert起到的作用起到的作用和反向填充数组是一样的
class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        first = 0
        last = len(nums) - 1
        return_list = list()
        while first <= last:
            if abs(nums[first]) < abs(nums[last]):
                return_list.insert(0, nums[last] * nums[last])
                last -= 1
            else:
                return_list.insert(0, nums[first] * nums[first])
                first += 1
        return return_list
```

### 2 LeetCode209 长度最小的子数组


:::info{title="题目"}
给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的 连续
子数组
 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

 

示例 1：
```
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
```
示例 2：
```
输入：target = 4, nums = [1,4,4]
输出：1
```
示例 3：
```
输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0
```

提示：

* 1 <= target <= 109
* 1 <= nums.length <= 105
* 1 <= nums[i] <= 105
:::

在看到窗口之后，大致就知道这题是个什么思路了，只是在最后一轮要根据`left`结束循环的时候，总是数组越界，最后烦不胜烦直接`while True`然后在`left += 1`之后找条件`break`掉。

``` python
from typing import List

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        right, left, summary, return_len = 0, 0, nums[0], float('inf')
        # float('inf')即为python的无穷大
        while True:
            if summary >= target:
                if (left - right + 1) < return_len:
                    return_len = left - right + 1
                summary -= nums[right]
                right += 1
            else:
                left += 1
                if left >= len(nums):
                    break
                summary += nums[left]
        if return_len == float('inf'):
            return 0
        return return_len
```

### 3 LeetCode59 螺旋矩阵Ⅱ


:::info{title="题目"}
给你一个正整数 n ，生成一个包含 1 到 $n^2$ 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

示例 1：
```
输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]
```
示例 2：
```
输入：n = 1
输出：[[1]]
```

提示：

* 1 <= n <= 20
:::

简而言之晕晕，晕的地方倒不是说怎么固定每次填充的区间，主要是体现在坐标上的加加减减有点晕。看了代码随想录的文档之后逐渐摸清了思路，然后写出来了。

``` python
from typing import List

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        return_list = list()
        for _ in range(n):
            return_list.append([0] * n)
        count, offset = 1, 1
        x, y = 0, 0  # 竖向是x 横向是y
        for _ in range(int(n / 2)):  # 圈数
            for y in range(y, n - offset):
                return_list[x][y] = count
                count += 1
            y += 1
            for x in range(x, n - offset):
                return_list[x][y] = count
                count += 1
            x += 1
            for y in range(y, offset - 1, -1):
                return_list[x][y] = count
                count += 1
            y -= 1
            for x in range(x, offset - 1, -1):
                return_list[x][y] = count
                count += 1
            y += 1
            offset += 1
        if (n % 2) != 0:
            return_list[int(n / 2)][int(n / 2)] = count
        return return_list
```


:::warning{title="注意"}
1. 在python中，`for i in range(i, j)`可以等效`for(i; i < j; i++)`。
2. `range()`函数并不会自动生成逆序，需要在`step`参数处传入-1。
3. `list`有长度，创建定长`list`可以使用`a = [0] * n`。
:::

代码随想录算法训练营第二天 | LeetCode977 有序数组的平方、LeetCode209 长度最小的子数组、LeetCode59 螺旋矩阵Ⅱ

今日任务：

1. 数组理论基础
2. LeetCode704 二分查找
3. LeetCode27 移除元素



> 今日心情：今天第一天，万事开头难，终于是赶在睡之前写完了。还想写多个语言版本帮助自己熟悉新语言来着，脑子真是太困了。想想明天的满课就心累。最后祝自己能够找到想去的暑期实习吧。

资料来源：

[数组理论基础](https://programmercarl.com/%E6%95%B0%E7%BB%84%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html)

[704. 二分查找](https://programmercarl.com/0704.%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE)

[27. 移除元素](https://programmercarl.com/0027.%E7%A7%BB%E9%99%A4%E5%85%83%E7%B4%A0.html)

### 1 数组理论基础

（只补充之前没了解过的部分）

1. 二维数组在内存中的存储方式随语言不同而不同。C++的二维数组和一维数组是一样的，按顺序排列；而Java的二维数组，每个一维数组之间都是不相连的，由最上层的数组存储指向这些一维数组的地址。

（实在不想自己制图了，但是看图理解确实更快😂）
![image.png](https://www.misaka19327.cc/static/img/9df5cf7fcef472877d8ae258dd5280fb.image.png)

### 2 LeetCode704 二分查找

:::info{title="题目"}
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。


示例 1:
```
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
```

示例 2:
```
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
```

提示：

* 你可以假设 nums 中的所有元素是不重复的。
* n 将在 [1, 10000]之间。
* nums 的每个元素都将在 [-9999, 9999]之间。
:::

~~有一说一，我一开始看到这题以为能秒杀的，真的。~~

> 在计算机科学中，二分查找算法（英语：binary search algorithm），也称折半搜索算法（英语：half-interval search algorithm）、对数搜索算法（英语：logarithmic search algorithm），是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

二分查找的重点在于，如何在代码中规定查找的范围。按查找范围划分，分为**左闭右闭区间**和**左闭右开区间**。以下为二分查找代码的框架，出现问号的地方就是要根据区间不同而填充的地方：

``` python
from typing import List

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        right = 0
        left = ?
        while right ? left:
            middle = int((right + left) / 2)
            if nums[middle] == target:
                return middle
            elif target < nums[middle]:
                left = ?
            elif target > nums[middle]:
                right = ?
        return -1
```

1. 左闭右闭区间

如果在左闭右闭区间进行搜索，那么就**意味着`right`和`left`这两个变量都是要纳入搜索范围**的，所以在修改`right`和`left`的时候，都不应该等于`middle`，因为就是在`middle`不是`target`的情况下，才需要修改`right`和`left`。同理，`while`条件也应该是`right <= left`，因为在左闭右闭区间下，`left = right`是合理的。

``` python
from typing import List

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        right = 0
        left = len(nums) - 1
        while right <= left:
            middle = int((right + left) / 2)
            if nums[middle] == target:
                return middle
            elif target < nums[middle]:
                left = middle - 1
            elif target > nums[middle]:
                right = middle + 1
        return -1
```

2. 左闭右开区间

根据左闭右闭区间举一反三，如果在左闭右开区间进行搜索，那么就**意味着`right`在搜索范围里，而`left`不在搜索范围里**，所以在修改`right`和`left`的时候，`right`不应该等于`middle`，而`left`可以。同理，`while`条件也应该是`right < left`，因为在左闭右开区间下，`left = right`是不合理的。

``` python
from typing import List

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        right = 0
        left = len(nums)
        while right < left:
            middle = int((right + left) / 2)
            if nums[middle] == target:
                return middle
            elif target < nums[middle]:
                left = middle
            elif target > nums[middle]:
                right = middle + 1
        return -1
```

### 3 LeetCode27 移除元素


:::info{title="题目"}
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。


说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

```
// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}
```

示例 1：
```
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
```
示例 2：
```
输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,3,0,4]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
```

提示：

* 0 <= nums.length <= 100
* 0 <= nums[i] <= 50
* 0 <= val <= 100
:::

第一次做直接过了，做的时候想着想着才意识到这何尝不是另一种双指针法，然后看了之后才发现真的双指针法确实方便多了（。

``` python
from typing import List

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        first = 0
        length = len(nums)
        if length == 0:
            return 0
        last = length - 1
        while first <= last:
            if nums[first] == val and nums[last] != val:
                nums[first] = nums[last]
                length -= 1
                first += 1
                last -= 1
            elif nums[first] != val:
                first += 1
            elif nums[first] == val and nums[last] == val:
                last -= 1
                length -= 1
        if first == 0:
            nums.clear()
        return length
```

双指针法：两个指针一起在数组中循环，由快指针寻找不是`val`的值，找到之后就存到慢指针处，然后两个指针一起+1；如果找到的是和`val`相等的值，那么快指针+1，慢指针不动即可。最后循环完成，返回慢指针的位置即可。

``` python
from typing import List

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        fast = 0
        low = 0
        while fast < len(nums):
            if nums[fast] != val:
                nums[low] = nums[fast]
                low += 1
            fast += 1
        return low
```

代码随想录算法训练营第一天 | LeetCode704 二分查找、LeetCode27 移除元素 

网络编程技术 实验3

实验目标：通过套接字和WSL，实现局域网内的通信。



### 1 修改后的客户端代码


``` c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char const *argv[])
{
    printf("start sending message to server on 127.0.0.1:1324\n");

    // 创建客户端套接字
    int socketfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (socketfd == -1) {
        perror("create socket failed: \n");
        return -1;
    }

    // 创建服务器端地址
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(1324);
    server_addr.sin_addr.s_addr = inet_addr("172.20.201.19");

    // 开始发送数据
    char* message = "Hello from client! \0";
    ssize_t bytes_sent = sendto(socketfd, message, strlen(message), 0, (struct sockaddr*)&server_addr, sizeof(server_addr));
    if (bytes_sent == -1) {
        perror("sending message failed: \n");
        close(socketfd);
        return -1;
    }

    // 开始接收数据
    char buffer[1024];
    ssize_t bytes_recv = recvfrom(socketfd, buffer, sizeof(buffer), 0, NULL, NULL);
    if (bytes_recv == -1) {
        perror("receiving data failed: \n");
        close(socketfd);
        return -1;
    }
    printf("received from server:\n");
    printCharArrayToHex(buffer, 1024);

    // 关闭套接字
    close(socketfd);
    return 0;
}

// 将char数组中的内容按十六进制进行打印
void printCharArrayToHex(char *buf, int bytes) {
    int i;
    for (i = 0; i < bytes; i++)
    {
        printf("%x ", (unsigned char)buf[i]);
    }
    
}

```

### 2 修改后的服务端代码

``` c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

// 创建一个简单UDP服务器 监听1324端口

int main(int argc, char const *argv[])
{

    printf("start monitor on 192.168.189.17:1324 \n");

    // 创建套接字
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0); // SOCK_DGRAM是UDP套接字
    // sockfd这个名字中的fd 是文件描述符的缩写 在unix/linux中 fd是进程独有的文件描述符表的索引 它的意思是 socket可以被视作一个文件
    if (sockfd == -1) {
        perror("create socket failed: \n");
        return -1;
    }

    // 设置服务器地址
    struct sockaddr_in addr;
    addr.sin_family = AF_INET; // 地址族
    addr.sin_port = htons(1324); // 端口
    addr.sin_addr.s_addr = inet_addr("192.168.189.17"); // IP 另外 INADDR_ANY可表示0.0.0.0

    // 将套接字绑定到服务器地址上
    int ret = bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)); // addr这里 可以视作做了一个转型
    if (0 > ret) {
        // 绑定失败
        perror("bind failed: \n");
        close(sockfd);
        return -1;
    }

    // 设置客户端地址
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);
    char buffer[1024];

    while (1)
    {
        ssize_t bytes_recv = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&client_addr, &client_len);
        if (bytes_recv == -1) {
            perror("receive message error: \n");
            continue;
        }

        char client_ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &(client_addr.sin_addr), client_ip, INET_ADDRSTRLEN);
        int clinet_port = ntohs(client_addr.sin_port);
        printf("client ip: %s, port: %d\n", client_ip, clinet_port);

        printf("received from client: %s\n", buffer);
        memset(buffer, 0, sizeof(buffer));

        // 按老师要求 编写自定义回复内容
        const char* response = "Hello from server! \0";

        // 定义char数组
        char buf[1024];
        // 声明一个指针 并且指向buf数组的第一个元素
        u_int8_t *p;
        p = buf;
        // 填充24进去
        buf[0] = 24;
        // 指针转型 使得编辑的内容从一位变成了两位 另外多字节内容必须转换字节序
        *((u_int16_t*)(buf + 1)) = htons(2024);
        // 同上的指针转型
        *((u_int32_t*)(buf + 3)) = htonl(20240304);
        // 获取主机名 如果无法获取则填充"Unknown Host"
        if (gethostname(buf + 7, 1017) == -1) {
            strcpy(buf + 7, "Unknown Host");
        }

        ssize_t bytes_send = sendto(sockfd, buf, 1017, 0, (struct sockaddr*)&client_addr, client_len);
        if (bytes_send == -1) {
            perror("sending message error: \n");
        }
    }
    
    close(sockfd);
    return 0;
}

```

### 3 运行效果

![image.png](https://www.misaka19327.cc/static/img/27686d32346285f55db4996e3ebbae9e.image.png)


![image.png](https://www.misaka19327.cc/static/img/4756d3257201d52b6b6ff30ddf88a8da.image.png)

可见局域网内的两个IP成功地进行通信，并且通信内容中包含主机名。

### 4 注意事项

1. 局域网内的两个主机通过这种方式通信，必须关闭双方主机的防火墙：

    ![image.png](https://www.misaka19327.cc/static/img/2ffeffe708451624b9b4387f148066bb.image.png)
    
2. 如果WSL想要被外界以一个固定IP访问，那么必须修改用户文件夹下的`.wslconfig`文件，并且修改`hostAddressLoopback`参数为`true`。

    ![image.png](https://www.misaka19327.cc/static/img/4ff7ecbeeabfa0cf0b7a5909708f6b05.image.png)
    
    在这里附上微软官方的说明：
    
    ![image.png](https://www.misaka19327.cc/static/img/447d844920f1f7fc8f28b9677076b174.image.png)
    
    （请注意，该说明为2024年3月5日截取，实际微软可能修改，请以最新说明为准[WSL中的高级设置配置 | Microsoft Learn](https://learn.microsoft.com/zh-cn/windows/wsl/wsl-config)）
    
    实际效果：
    
    ![image.png](https://www.misaka19327.cc/static/img/51ff0ba23408a0e790b0165121ae11db.image.png)

网络编程技术 实验2

实验目标：通过套接字，创建客户端和服务端，并且实现基础的互相通信。



环境: Ubuntu 22.04 LTS(WSL)，gcc 11.04，GNU gdb (Ubuntu 12.1-0ubuntu1~22.04) 12.1

### 1 WSL + VS Code + C/C++配置

先安装WSL（必须是WSL2），并且在WSL中安装C/C++编译器，在VS Code中安装WSL扩展，C/C++所需扩展（后续记得在WSL中安装）：
![image.png](https://www.misaka19327.cc/static/img/1944894b85a75e20edc997a46552a50e.image.png)
> 安装C/C++编译器命令：
> 1. `sudo apt install gcc-11`
> 2. `sudo apt install g++-11`
> 3. `sudo apt install gdb`

![image.png](https://www.misaka19327.cc/static/img/913ad3de5a9f6a23154159042d3f8fd8.image.png)


之后在文件管理器里找到WSL的位置，随便创建一个.c文件，然后使用VS Code打开，并且在左侧的资源管理器里打开文件夹：

![image.png](https://www.misaka19327.cc/static/img/d7860b2d15bbe608d58df5744859d0e4.image.png)

打开之后，左下角会提示：We are working on folders in \\wsl...，点击“Reopen Folder in WSL”：

![image.png](https://www.misaka19327.cc/static/img/17bb84443b6337c5b2abd6a8709a3ad1.image.png)

在这个项目文件夹下新建.vscode文件夹，并且新建三个文件（settings.json不必要）：

![image.png](https://www.misaka19327.cc/static/img/7a858b235afd16aca824d4f5dbe4259a.image.png)

c_cpp_properties.json（C语言版）：
``` json
{
    "configurations": [
        {
            "name": "Linux",
            // includePath中的内容除了第一条 剩下的在WSL中运行"gcc-11 -v -E -x c -"(c配置)或"gcc-11 -v -E -x c++ -"(c++配置)后 见下图寻找内容
            "includePath": [
                "${workspaceFolder}/**",
                "/usr/lib/gcc/x86_64-linux-gnu/11/include",
                "/usr/local/include",
                "/usr/include/x86_64-linux-gnu",
                "/usr/include"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/gcc", // 编译器路径
            "intelliSenseMode": "linux-gcc-x64",
            "cStandard": "c11" // c语言标准
        }
    ],
    "version": 4
}
```

![image.png](https://www.misaka19327.cc/static/img/8237c0019f24d5bc56e205acfb6efb22.image.png)

c_cpp_properties.json（C++语言版）：
``` json
{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}/**",
                "/usr/include/c++/11",
                "/usr/include/x86_64-linux-gnu/c++/11",
                "/usr/include/c++/11/backward",
                "/usr/lib/gcc/x86_64-linux-gnu/11/include",
                "/usr/local/include",
                "/usr/include/x86_64-linux-gnu",
                "/usr/include"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/g++",
            "intelliSenseMode": "linux-gcc-x64",
            "cStandard": "c11"
        }
    ],
    "version": 4
}
```

launch.json：
``` json
{
    // 使用 IntelliSense 了解相关属性。 
    // 悬停以查看现有属性的描述。
    // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "gcc-11 - 生成和调试活动文件",
            "type": "cppdbg",
            "request": "launch",
            "program": "${fileDirname}/${fileBasenameNoExtension}",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "miDebuggerPath": "gdb",
            "setupCommands": [
                {
                    "description": "为 gdb 启用整齐打印",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ],
            "preLaunchTask": "Launch: build active file"
        }
    ]
}
```

tasks.json（C语言版）：
``` json
{
    "tasks": [
        {
            "type": "cppbuild",
            "label": "Launch: build active file",
            "command": "/usr/bin/gcc", // 编译器路径
            "args": [
                "-fdiagnostics-color=always",
                "-g",
                "${file}",
                "-o",
                "${fileDirname}/${fileBasenameNoExtension}"
            ],
            "options": {
                "cwd": "${fileDirname}"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "detail": "use /usr/bin/gcc-11"
        }
    ],
    "version": "2.0.0"
}
```

task.json（C++语言版）：
``` json
{
    "tasks": [
        {
            "type": "cppbuild",
            "label": "Launch: build active file",
            "command": "/usr/bin/g++",
            "args": [
                "-fdiagnostics-color=always",
                "-g",
                "${file}",
                "-o",
                "${fileDirname}/${fileBasenameNoExtension}"
            ],
            "options": {
                "cwd": "${fileDirname}"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "detail": "use /usr/bin/gcc-11"
        }
    ],
    "version": "2.0.0"
    }
```

之后，就可以编译并且运行C/C++代码了：

![image.png](https://www.misaka19327.cc/static/img/4d1233e0cc2692294eb2f90b87244542.image.png)

### 2 服务端代码

``` c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

// 创建一个简单UDP服务器 监听1324端口

int main(int argc, char const *argv[])
{

    printf("start monitor on 127.0.0.1:1324 \n");

    // 创建套接字
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0); // SOCK_DGRAM是UDP套接字
    // sockfd这个名字中的fd 是文件描述符的缩写 在unix/linux中 fd是进程独有的文件描述符表的索引 它的意思是 socket可以被视作一个文件
    if (sockfd == -1) {
        // 创建socket失败
        perror("create socket failed: \n"); // 该函数会查找全局变量errno 并且将其保存的错误码转换为可读的报错信息
        // 全局变量errno 是大部分标准库函数出错时保存报错码的位置
        return -1;
    }

    // 设置服务器地址
    struct sockaddr_in addr;
    addr.sin_family = AF_INET; // 地址族
    addr.sin_port = htons(1324); // 端口
    addr.sin_addr.s_addr = inet_addr("127.0.0.1"); // IP 另外 INADDR_ANY可表示0.0.0.0

    // 将套接字绑定到服务器地址上
    int ret = bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)); // addr这里 可以视作做了一个转型
    if (0 > ret) {
        // 绑定失败
        perror("bind failed: \n");
        close(sockfd); // 关闭套接字
        return -1;
    }

    // 设置客户端地址 这个结构体的作用是在下面的recvfrom函数中保存发送者的地址信息
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);
    char buffer[1024]; //缓冲区

    while (1)
    {
        ssize_t bytes_recv = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&client_addr, &client_len);
        if (bytes_recv == -1) {
            // 接收信息错误
            perror("receive message error: \n");
            continue;
        }

        char client_ip[INET_ADDRSTRLEN]; // INET_ADDRSTRLEN表示 32 位 IPv4 地址 的字符串表示形式所需的最大长度 为16
        inet_ntop(AF_INET, &(client_addr.sin_addr), client_ip, INET_ADDRSTRLEN); // 该函数用于将二进制格式的IPv4或IPv6地址 转换为文本格式
        int clinet_port = ntohs(client_addr.sin_port); // 转换字节的网络序和主机序 这里的ntohs是Network to Host Short的缩写 网络序转主机16位无符号短整数(u_short)
        // 类似的还有htonl: Host to Network u_long
        // htons: Host to Network u_short
        // ntohl: Network to Host u_long
        printf("client ip: %s, port: %d\n", client_ip, clinet_port);

        printf("received from client: %s\n", buffer);
        memset(buffer, 0, sizeof(buffer)); // 清除缓冲区

        const char* response = "Hello from server! \0";
        ssize_t bytes_send = sendto(sockfd, response, strlen(response), 0, (struct sockaddr*)&client_addr, client_len); // 发回去
        if (bytes_send == -1) {
            // 没发成功
            perror("sending message error: \n");
        }
    }
    
    close(sockfd);
    return 0;
}

```

### 3 客户端代码

``` c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char const *argv[])
{
    printf("start sending message to server on 127.0.0.1:1324\n");

    // 创建客户端套接字
    int socketfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (socketfd == -1) {
        perror("create socket failed: \n");
        return -1;
    }

    // 创建服务器端地址
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(1324);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    // 开始发送数据
    char* message = "Hello from client! \0";
    ssize_t bytes_sent = sendto(socketfd, message, strlen(message), 0, (struct sockaddr*)&server_addr, sizeof(server_addr));
    if (bytes_sent == -1) {
        perror("sending message failed: \n");
        close(socketfd);
        return -1;
    }

    // 开始接收数据
    char buffer[1024];
    ssize_t bytes_recv = recvfrom(socketfd, buffer, sizeof(buffer), 0, NULL, NULL);
    if (bytes_recv == -1) {
        perror("receiving data failed: \n");
        close(socketfd);
        return -1;
    }
    printf("received from server: %s\n", buffer);

    // 关闭套接字
    close(socketfd);
    return 0;
}

```

### 4 运行结果

客户端：

![image.png](https://www.misaka19327.cc/static/img/c6b13ab82edcd4fea58175392414f9b4.image.png)

服务端：

![image.png](https://www.misaka19327.cc/static/img/1fff9c7c7fe679e04a928e7d2bd34721.image.png)

### 5 WSL其他问题

1. 修改WSL用户密码

在PowerShell中，运行`wsl.exe --user root`进入WSL，之后再运行`passwd root`（root替换要修改密码的用户名）来修改用户名：

![image.png](https://www.misaka19327.cc/static/img/7dd44c71602bfe269af335856b344d4b.image.png)

2. WSL在默认情况下是英文，没有中文，所以中文显示会是乱码。对于Ubuntu来说，安装以下解决问题：

``` bash
sudo apt install fonts-noto-cjk
```

3. WSL文件管理器，Chrome安装，

``` bash
sudo apt install nautilus -y
wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo apt install --fix-missing ./google-chrome-stable_current_amd64.deb
```

4. Linux运行程序报错：error while loading shared libraries: libQt5Widgets.so.5: cannot open shared object file: No such file or directory

运行`sudo apt-get install libqt5widgets5`解决。

5. Linux运行二进制文件报错

![image.png](https://www.misaka19327.cc/static/img/1d15be68fc1e62b4879dc9cf9ccaf6fe.image.png)

该文件没有执行权限，`chmod 777 mNetAssist`即可解决。

6. 其他问题见官方说明[ 在适用于 Linux 的 Windows 子系统上运行 Linux GUI 应用 ](https://learn.microsoft.com/zh-cn/windows/wsl/tutorials/gui-apps)。