C++与Go系列之基础语法篇




### 声明和定义

#### C++中的声明和定义

**声明（Declaration）**

声明告诉编译器变量、函数或类型的名称和类型，但不分配存储空间或定义其实现。声明通常出现在头文件中，以便其他文件可以引用这些声明。

示例：

1. **变量声明**
   ```cpp
   int a; // 声明变量a，未分配存储空间
   ```

2. **函数声明**
   ```cpp
   int add(int, int); // 声明函数add，没有提供函数实现
   ```

3. **类声明**
   ```cpp
   class MyClass; // 前向声明类MyClass，没有定义类的成员
   ```
   
在C++中，变量的声明需要指定数据类型。

```cpp
#include <iostream>

int main() {
    int a = 10;
    double b = 3.14;
    std::string s = "Hello, C++";

    std::cout << a << " " << b << " " << s << std::endl;
    return 0;
}
```
**定义（Definition）**

定义不仅声明了变量、函数或类型的名称和类型，还分配存储空间或提供实现。定义通常出现在源文件中。

示例：

1. **变量定义**
   ```cpp
   int a = 10; // 定义变量a，并分配存储空间
   ```

2. **函数定义**
   ```cpp
   int add(int x, int y) {
       return x + y;
   } // 定义函数add，并提供函数实现
   ```

3. **类定义**
   ```cpp
   class MyClass {
   public:
       void doSomething();
   }; // 定义类MyClass，并提供类的成员声明
   ```

#### Go语言中的声明和定义

Go语言中，声明和定义往往是同时进行的。每次声明变量或函数时，通常也会同时进行定义。

**声明和定义变量**

在Go中，变量声明通常伴随着定义。

```go
package main

import "fmt"

func main() {
    var a int = 10 // 声明并定义变量a
    b := 20       // 简短声明并定义变量b

    fmt.Println(a, b)
}
```

**声明和定义函数**

函数声明和定义也是同时进行的。

```go
package main

import "fmt"

func add(x, y int) int { // 声明并定义函数add
    return x + y
}

func main() {
    result := add(3, 4)
    fmt.Println("3 + 4 =", result)
}
```

**声明和定义类型**

Go语言中也可以声明和定义自定义类型。

```go
package main

import "fmt"

type MyStruct struct { // 声明并定义结构体MyStruct
    x int
    y int
}

func main() {
    var s MyStruct // 声明并定义变量s
    s.x = 10
    s.y = 20

    fmt.Println(s)
}
```


Go语言的变量声明需要指定数据类型，但提供了更简洁的声明方式（使用`:=`操作符）。

```go
package main

import "fmt"

func main() {
    var a int = 10
    var b float64 = 3.14
    var s string = "Hello, Go"

    // 简洁声明
    x := 42
    y := 2.718
    z := "Go is fun"

    fmt.Println(a, b, s)
    fmt.Println(x, y, z)
}
```

### 行末尾分号

#### C++

在C++中，大多数语句和声明都需要以分号结尾。这是C++语法的基本要求，用于分隔各个语句。

```cpp
#include <iostream>

int main() {
    int a = 10;  // 变量声明需要分号
    int b = 20;  // 变量声明需要分号

    std::cout << a + b << std::endl;  // 输出语句需要分号
    return 0;  // 返回语句需要分号
}
```

#### Go

在Go中，行末不需要显式的分号。Go编译器会自动在每行的末尾插入分号。然而，在同一行内编写多条语句时，仍需使用分号进行分隔。

```go
package main

import "fmt"

func main() {
    a := 10 // 变量声明不需要分号
    b := 20 // 变量声明不需要分号

    fmt.Println(a + b) // 输出语句不需要分号

    a++; b++ // 在同一行内编写多条语句时，需要分号进行分隔
    fmt.Println(a, b)
}
```



### 函数定义

#### C++

C++中，函数的定义需要指定返回类型和参数类型。

```cpp
#include <iostream>

int add(int x, int y) {
    return x + y;
}

int main() {
    int result = add(3, 4);
    std::cout << "3 + 4 = " << result << std::endl;
    return 0;
}
```

#### Go

Go语言的函数定义也需要指定返回类型和参数类型，但参数类型可以一起声明。

```go
package main

import "fmt"

func add(x, y int) int {
    return x + y
}

func main() {
    result := add(3, 4)
    fmt.Println("3 + 4 =", result)
}
```

### 控制结构

#### 条件语句

##### C++

C++的条件语句与其他C风格语言类似。

```cpp
#include <iostream>

int main() {
    int a = 10;

    if (a > 5) {
        std::cout << "a is greater than 5" << std::endl;
    } else {
        std::cout << "a is not greater than 5" << std::endl;
    }

    return 0;
}
```

##### Go

Go语言的条件语句与C++相似，但不需要括号。

```go
package main

import "fmt"

func main() {
    a := 10

    if a > 5 {
        fmt.Println("a is greater than 5")
    } else {
        fmt.Println("a is not greater than 5")
    }
}
```

此外，Go语言允许在if语句中使用一个简单语句，用分号与条件分隔开，这在C++中是没有的。
 
**if语句中的简单语句**

Go语言中的if语句可以在条件判断之前执行一个简单语句，这个语句和条件之间用分号分隔。这样的用法在一些场景中非常有用，例如需要在条件判断前计算某个值。

```go
package main

import "fmt"

func main() {
    if b := 20; b > 15 {
        fmt.Println("b is greater than 15")
    } else {
        fmt.Println("b is not greater than 15")
    }
}
```

在这个示例中，`b := 20`是一个简单语句，它在条件判断前执行。这个简单语句的作用域仅限于if-else语句块内。

**if-else if-else 语句**

Go语言中的if-else if-else语句也支持这种简单语句的用法：

```go
package main

import "fmt"

func main() {
    if c := 25; c > 30 {
        fmt.Println("c is greater than 30")
    } else if c > 20 {
        fmt.Println("c is greater than 20 but less than or equal to 30")
    } else {
        fmt.Println("c is less than or equal to 20")
    }
}
```
 
#### 循环语句

##### C++

C++支持多种循环结构，如`for`、`while`和`do-while`。

```cpp
#include <iostream>

int main() {
    for (int i = 0; i < 5; ++i) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    int j = 0;
    while (j < 5) {
        std::cout << j << " ";
        ++j;
    }
    std::cout << std::endl;

    int k = 0;
    do {
        std::cout << k << " ";
        ++k;
    } while (k < 5);
    std::cout << std::endl;

    return 0;
}
```

##### Go

Go语言仅支持一种循环结构`for`，可以实现C++中的所有循环。

```go
package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Print(i, " ")
    }
    fmt.Println()

    j := 0
    for j < 5 {
        fmt.Print(j, " ")
        j++
    }
    fmt.Println()

    k := 0
    for {
        fmt.Print(k, " ")
        k++
        if k >= 5 {
            break
        }
    }
    fmt.Println()
}
```

### 数据结构

#### 数组

##### C++

在C++中，数组可以使用固定大小或动态分配。

```cpp
#include <iostream>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}
```

##### Go

Go语言中的数组和切片（slice）提供了更灵活的方式来管理集合数据。
（slice实际上是一个结构体）
```go
package mainß

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}

    for i := 0; i < len(arr); i++ {
        fmt.Print(arr[i], " ")
    }
    fmt.Println()

    // 使用切片
    slice := []int{1, 2, 3, 4, 5}
    for _, v := range slice {
        fmt.Print(v, " ")
    }
    fmt.Println()
}
```

#### 字典/映射

##### C++

C++使用`std::map`或`std::unordered_map`来实现字典


```cpp
#include <iostream>
#include <map>

int main() {
    std::map<std::string, int> dict;
    dict["one"] = 1;
    dict["two"] = 2;

    for (const auto& pair : dict) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}
```

##### Go

Go语言使用`map`关键字来实现字典。

```go
package main

import "fmt"

func main() {
    dict := map[string]int{
        "one": 1,
        "two": 2,
    }

    for key, value := range dict {
        fmt.Println(key, ":", value)
    }
}
```
### 结构体

#### C++ 中的结构（Struct）

##### 定义和使用
在C++中，结构（struct）是一种用户定义的数据类型，类似于类（class），但有一些关键的区别。结构体主要用于将不同类型的数据组合在一起。

```cpp
#include <iostream>
#include <string>

struct Person {
    std::string name;
    int age;
    
    // 可以在结构体中定义成员函数
    void introduce() {
        std::cout << "My name is " << name << " and I am " << age << " years old." << std::endl;
    }
};

int main() {
    // 创建结构体实例
    Person person1;
    person1.name = "Alice";
    person1.age = 30;
    
    // 调用结构体的成员函数
    person1.introduce();
    
    return 0;
}
```

##### 关键特点
1. **默认访问控制**：C++中的结构体成员默认是public的，而类的成员默认是private的。
2. **成员函数**：结构体可以包含成员函数，就像类一样。
3. **继承**：C++的结构体可以进行继承，但通常情况下更倾向于使用类进行继承。

#### Go 中的结构（Struct）

##### 定义和使用
在Go中，结构体（struct）也是一种用户定义的数据类型，用于将一组不同类型的数据组合在一起。Go语言的结构体在语法上与C++有一些相似，但在使用上有一些显著的不同。

```go
package main

import "fmt"

// 定义结构体
type Person struct {
    Name string
    Age  int
}

// 定义方法
func (p Person) Introduce() {
    fmt.Printf("My name is %s and I am %d years old.\n", p.Name, p.Age)
}

func main() {
    // 创建结构体实例
    person1 := Person{Name: "Alice", Age: 30}
    
    // 调用结构体的方法
    person1.Introduce()
}
```

##### 关键特点
1. **默认访问控制**：Go语言中，结构体的成员名首字母大写表示导出（public），首字母小写表示未导出（private）。
2. **方法**：Go语言通过方法来为结构体定义行为，方法可以是值接收者（值传递）或指针接收者（引用传递）。
3. **嵌入和组合**：Go语言没有传统的继承机制，而是通过嵌入其他结构体来实现代码复用。
 

### Go语言的变量和函数大小写规则

在Go语言中，变量和函数名称的首字母大小写决定了它们的可见性（visibility）。具体规则如下：

#### 大写开头的变量和函数

大写开头的变量和函数在包外可见，即它们是导出的（exported）。这意味着它们可以被其他包导入和使用。

**示例：**

```go
package main

import "fmt"

// 导出的变量
var PublicVar = "I am visible outside this package"

// 导出的函数
func PublicFunc() {
    fmt.Println("I am visible outside this package")
}

func main() {
    fmt.Println(PublicVar)
    PublicFunc()
}
```

在另一个包中，可以这样使用导出的变量和函数：

```go
package main

import (
    "fmt"
    "path/to/your/package"
)

func main() {
    fmt.Println(package.PublicVar)
    package.PublicFunc()
}
```

#### 小写开头的变量和函数

小写开头的变量和函数在包外不可见，即它们是未导出的（unexported）。这意味着它们只能在声明它们的包内使用。

**示例：**

```go
package main

import "fmt"

// 未导出的变量
var privateVar = "I am not visible outside this package"

// 未导出的函数
func privateFunc() {
    fmt.Println("I am not visible outside this package")
}

func main() {
    fmt.Println(privateVar)
    privateFunc()
}
```

在另一个包中，无法访问未导出的变量和函数：

```go
package main

import (
    "fmt"
    "path/to/your/package"
)

func main() {
    // fmt.Println(package.privateVar) // 编译错误：无法访问未导出的变量
    // package.privateFunc()           // 编译错误：无法访问未导出的函数
}
```

### 总结

C++需要在大多数语句和声明末尾使用分号，而Go语言则不需要。Go语言通过变量和函数名称的大小写规则来控制可见性。

C++与Go系列(一)

mac下配置STM32开发环境可能稍微复杂点


## 准备工作

**开发板：**

STM32F103C8T6

**安装开发环境（macOS）：**

开发软件安装：CLion、STM32CubeMX

**所需安装工具如下：**
```
gcc-arm-embedded

open-ocd

stlink

STM32CubeProgrammer
```
STM32CubeProgrammer和Open-OCD选其中一个安装即可。本文推荐Open-OCD，因为Open-OCD+CLion配置烧录较为方便。

**具体环境配置教程参考以下三篇博客：**

[Mac+CLion+STM32+ST-Link:搭建嵌入式开发环境](https://blog.csdn.net/Marslicy/article/details/132179588)

[CLion配置STM32项目](https://segmentfault.com/a/1190000022798805)

[MacOS 烧写STM32 (使用 STM32_Programmer_CLI 命令工具)](https://leiblog.wang/MacOS%20%E7%83%A7%E5%86%99STM32/)

**连接烧录器：**
按照下边的接线，将烧录器与STM32开发板连接。
![image.png](/static/img/4a884c059f950269186026773014c203.image.webp)

## 开始项目

STM32CubeMX新建工程后，设置Debug模式：SYS 设置，选择 Debug 为 Serial Wire

**非常重要的一步，否则会造成第一次烧录程序后续无法识别调试器**

![image.png](/static/img/9a9e5484bff08b9f3d546e26c8e03093.image.webp)

注意Timebase Source再选择TIM4 代替 Systick 是因为 FreeRTOS 会占用 Systick，使用其他定时器代替Systick避免不必要的错误。



![image.png](/static/img/584bf9098f1725aa0f216bea73290864.image.webp)


时钟选择外部高速时钟

![image.png](/static/img/a4e40f8ce415ef77957d3df3856ee6f9.image.webp)

配置时钟频率


![image.png](/static/img/cd6b7b023e4c513e5bd486f359e67bf6.image.webp)


### 配置FreeRTOS
**什么是FreeRTOS？**

FreeRTOS，简而言之，就是一个实时操作系统，那么为什么需要操作系统？ 因为STM32的代码一般都是顺序执行的，当需要实现的功能越来越复杂时，这种顺序执行的方式很不能同时处理多任务。而FreeRTOS可以让STM32的程序同时进行多任务调度。

**STM32CubeMX配置FreeRTOS**

STM32CubeMX里点击 Middleware -> 选择 FreeRTOS -> 下拉框选择 V2 版本 CMSIS

配置USE_NEWLIB_REENTRANT


![image.png](/static/img/a913e40d7d3ecbcbf4df16dc1762a281.image.webp)

STM32快速上手

C++常用的包管理工具有vcpkg，CPM，conan。本文主要记录Ubuntu下的cmake中使用conan的ffmpeg使用方法以及采坑。


下载地址
https://conan.io/downloads.html

安装完成：

```
 conan -v
#出现
Conan version 2.0.7

```
跟着官网的文档：https://docs.conan.io/2.0/tutorial/consuming_packages/build_simple_cmake_project.html
写一个conanfile.txt
```
[requires]
ffmpeg/5.1

[generators]
cmake


[settings]
compiler=g++
```
如果刚安装完conan，但未使用，先初始化一下：
`conan profile detect --force`
出了警告
```
$ conan profile detect --force
Found gcc 7
gcc>=5, using the major as version
gcc C++ standard library: libstdc++11
Detected profile:
[settings]
arch=x86_64
build_type=Release
compiler=gcc
compiler.cppstd=gnu14
compiler.libcxx=libstdc++11
compiler.version=7
os=Linux

WARN: This profile is a guess of your environment, please check it.
WARN: The output of this command is not guaranteed to be stable and can change in future Conan versions.
WARN: Use your own profile files for stability.
Saving detected profile to ~/.conan2/profiles/default

```
直接install命令
`conan install . --output-folder=build --build=missing`
很不幸，报错了
```
$ conan install . --output-folder=build --build=missing

======== Input profiles ========
Profile host:
[settings]
arch=x86_64
build_type=Release
compiler=gcc
compiler.cppstd=gnu14
compiler.libcxx=libstdc++11
compiler.version=7
os=Linux

Profile build:
[settings]
arch=x86_64
build_type=Release
compiler=gcc
compiler.cppstd=gnu14
compiler.libcxx=libstdc++11
compiler.version=7
os=Linux

ERROR: <your project path>:
ConfigParser: Unrecognized field 'settings'

```
然后修改conanfile.txt，去掉settings
```
[requires]
ffmpeg/5.1

[generators]
cmake

```
再次
`conan install . --output-folder=build --build=missing`
很不幸，再次报错
```
Skipped binaries
    meson/1.0.0, ninja/1.11.1
vaapi/system: RUN: dpkg-query -W -f='${Status}' libva-dev | grep -q "ok installed"
dpkg-query: 没有找到与 libva-dev 相匹配的软件包

ERROR: vaapi/system: Error in system_requirements() method, line 38
        apt.install(["libva-dev"], update=True, check=True)
        ConanException: System requirements: 'libva-dev' are missing but can't install because tools.system.package_manager:mode is 'check'.Please update packages manually or set 'tools.system.package_manager:mode' to 'install' in the [conf] section of the profile, or in the command line using '-c tools.system.package_manager:mode=install'

```
方法一：尝试现在手动安装：
```
sudo apt update
sudo apt install libva-dev

```
经过多次实践，需要好几个包 

```
sudo apt-get install libva-dev libvdpau-dev libx11-dev libx11-xcb-dev libfontenc-dev libice-dev libsm-dev libxau-dev libxaw7-dev libxcomposite-dev libxcursor-dev libxdamage-dev libxdmcp-dev libxext-dev libxfixes-dev libxi-dev libxinerama-dev libxkbfile-dev libxmu-dev libxmuu-dev libxpm-dev libxrandr-dev libxrender-dev libxres-dev libxss-dev libxt-dev libxtst-dev libxv-dev libxvmc-dev libxxf86vm-dev libxcb-render0-dev libxcb-render-util0-dev libxcb-xkb-dev libxcb-icccm4-dev libxcb-image0-dev libxcb-keysyms1-dev libxcb-randr0-dev libxcb-shape0-dev libxcb-sync-dev libxcb-xfixes0-dev libxcb-xinerama0-dev libxcb-dri3-dev uuid-dev libxcb-cursor-dev  libxcb-util-dev libxcb-util0-dev  -y
```

方法二（废案）：conan install加上参数` -c tools.system.package_manager:mode=install` 

即再执行`conan install . --output-folder=build --build=missing -c tools.system.package_manager:mode=install`

这里看起来有危险操作，尚未加sudo权限。

```
vaapi/system: System requirements:  already installed
vdpau/system: RUN: dpkg-query -W -f='${Status}' libvdpau-dev | grep -q "ok installed"
dpkg-query: 没有找到与 libvdpau-dev 相匹配的软件包

vdpau/system: RUN: apt-get update
正在读取软件包列表... 完成
E: 无法打开锁文件 /var/lib/apt/lists/lock - open (13: 权限不够)
E: 无法对目录 /var/lib/apt/lists/ 加锁
W: 用 unlink 删除文件 /var/cache/apt/pkgcache.bin 出错 - RemoveCaches (13: 权限不够)
W: 用 unlink 删除文件 /var/cache/apt/srcpkgcache.bin 出错 - RemoveCaches (13: 权限不够)

ERROR: vdpau/system: Error in system_requirements() method, line 38
        apt.install(["libvdpau-dev"], update=True, check=True)
        ConanException: Command 'apt-get update' failed

```

C++包管理工具之conan

# 使用 Nginx 配置 SSL/TLS 加密和 Let's Encrypt 免费证书自动续订

## 介绍

 Let's Encrypt 提供了免费、开放、自动的 SSL/TLS 证书，使得获取和部署证书变得更加容易。

本文将会介绍如何在 Nginx 上配置 SSL/TLS 加密，并使用 Let's Encrypt 免费证书实现证书自动续订。



## 前置条件

在开始之前，请确保以下条件已经满足：

- 拥有一个可用的域名（例如 `example.com`）
- 安装并配置了 Nginx
- 通过防火墙或者路由器打开了 80 和 443 端口

## 步骤

### 第一步：安装 Certbot

Certbot 是一个 Let's Encrypt 证书自动化管理工具，可以帮助我们快速获取和管理 Let's Encrypt 证书。在 Ubuntu 上，你可以使用以下命令来安装 Certbot：

```
sudo apt-get update
sudo apt-get install certbot python3-certbot-nginx
```

### 第二步：获取证书

现在，需要使用 Certbot 获取 Let's Encrypt 证书了。运行以下命令以获取证书：

```
sudo certbot --nginx -d example.com
```

在运行该命令时，请将 `example.com` 替换为自己的域名。Certbot 将会自动探测 Nginx 的配置并获取 Let's Encrypt 证书。

如果一切顺利，会看到类似以下内容的提示信息：

```
Congratulations! Your certificate and chain have been saved at:
/etc/letsencrypt/live/example.com/fullchain.pem
Your key file has been saved at:
/etc/letsencrypt/live/example.com/privkey.pem
```

这些文件路径就是 SSL/TLS 证书和私钥的路径。

### 第三步：更新 Nginx 配置

更新 Nginx 的配置文件，将 SSL 相关配置替换为以下内容：

```
# SSL 相关配置
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

# 其他 Nginx 配置
```

在这里，使用 Certbot 获取的 SSL 证书和私钥的路径替换了之前的 `/path/to/ssl/certificate` 和 `/path/to/ssl/certificate/key`。

### 第四步：测试配置

运行以下命令重启 Nginx 并测试配置是否生效：

```
sudo systemctl restart nginx
sudo nginx -t
```

如果测试通过，则说明已经成功配置了 SSL/TLS 加密和 Let's Encrypt 免费证书自动续订。

### 可选步骤：设置自动更新

Certbot 默认会在到期前 30 天尝试更新证书并自动续订证书。如果想手动修改自动更新计划，可以运行以下命令：

```
sudo certbot renew --dry-run
```

该命令会模拟自动续订操作，但不会实际更新证书。如果一切顺利，则说明自动续订功能可用。

要修改自动更新计划，请编辑 `/etc/crontab` 文件，并添加以下内容：

```
0 0 1 * * root
```

使用 Nginx 配置 SSL/TLS 加密和 Let's Encrypt 免费证书自动续订

**两个表格查找关联数据,并填充指定内容**
假设在一个Excel表中，有“成绩录入”和“Sheet1”两个工作表如下：

成绩录入：

| 序号 | 姓名 | 班级ID | 课程班级<分制>                            | 成绩 |
| ---- | ---- | ------ | ----------------------------------------- | ---- |
| 1    | 张三 | 1024   | 通信工程181班大学英语上<学业成绩 100分制> |      |
| 2    | 李四 | 1024   | 通信工程181班大学英语上<学业成绩 100分制> |      |

Sheet1：

| 姓名 | 学号        | 学校       | 班级        | 大学英语 | 大学物理 | 高等数学 |
| ---- | ----------- | ---------- | ----------- | -------- | -------- | -------- |
| 李四 | 20181024001 | 常青藤大学 | 通信工程181 | 61       | 71       | 71       |
| 张三 | 20181024002 | 常青藤大学 | 通信工程181 | 72       | 73       | 72       |

快速把成绩录入，使用公式`=IFERROR(VLOOKUP(B2,Sheet1!A$1:G$150,5,FALSE),0)`

这个公式是用来在Sheet1表格中查找姓名列与成绩录入表格中B2单元格相匹配的数据，并将该匹配行的第5列（即成绩）返回到成绩录入表格中的E2单元格中。

具体来说，公式中的：

- B2：是成绩录入表格中的姓名，即张三；
- Sheet1!A$1:G$150：是指Sheet1表格中的A1到G150单元格的范围，其中包括姓名列、成绩列和其他相关信息；
- 5：表示要返回Sheet1表格中匹配行的第5列，即大学英语的成绩列，即72；
- FALSE：表示要求查找姓名列时必须是精确匹配，不能有近似值。

另外：如果VLOOKUP函数找到了匹配的数据，则会返回Sheet1表格中该行的第5列（即成绩）的值；如果VLOOKUP函数找不到匹配的数据，则会返回0。为了避免因找不到匹配数据而出现#N/A错误，这里使用了IFERROR函数，将VLOOKUP函数的结果在出现错误时改为返回0。