# FFmpe读取UVC摄像头推流

摄像头是USB免驱摄像头，Go搭建RTSP服务器，ffmpeg命令行工具推流。


用go启动一个rtsp服务器：

```go

package main

import (
    "github.com/bluenviron/gortsplib/v4"
    "log"
    "sync"

    "github.com/pion/rtp"

    "github.com/bluenviron/gortsplib/v4/pkg/base"
    "github.com/bluenviron/gortsplib/v4/pkg/description"
    "github.com/bluenviron/gortsplib/v4/pkg/format"
)

// This example shows how to
// 1. create a RTSP server which accepts plain connections
// 2. allow a single client to publish a stream with TCP or UDP
// 3. allow multiple clients to read that stream with TCP, UDP or UDP-multicast

type serverHandler struct {
    s         *gortsplib.Server
    mutex     sync.Mutex
    stream    *gortsplib.ServerStream
    publisher *gortsplib.ServerSession
}

// called when a connection is opened.
func (sh *serverHandler) OnConnOpen(ctx *gortsplib.ServerHandlerOnConnOpenCtx) {
    log.Printf("conn opened")
}

// called when a connection is closed.
func (sh *serverHandler) OnConnClose(ctx *gortsplib.ServerHandlerOnConnCloseCtx) {
    log.Printf("conn closed (%v)", ctx.Error)
}

// called when a session is opened.
func (sh *serverHandler) OnSessionOpen(ctx *gortsplib.ServerHandlerOnSessionOpenCtx) {
    log.Printf("session opened")
}

// called when a session is closed.
func (sh *serverHandler) OnSessionClose(ctx *gortsplib.ServerHandlerOnSessionCloseCtx) {
    log.Printf("session closed")

    sh.mutex.Lock()
    defer sh.mutex.Unlock()

    // if the session is the publisher,
    // close the stream and disconnect any reader.
    if sh.stream != nil && ctx.Session == sh.publisher {
       sh.stream.Close()
       sh.stream = nil
    }
}

// called when receiving a DESCRIBE request.
func (sh *serverHandler) OnDescribe(ctx *gortsplib.ServerHandlerOnDescribeCtx) (*base.Response, *gortsplib.ServerStream, error) {
    log.Printf("describe request")

    sh.mutex.Lock()
    defer sh.mutex.Unlock()

    // no one is publishing yet
    if sh.stream == nil {
       return &base.Response{
          StatusCode: base.StatusNotFound,
       }, nil, nil
    }

    // send medias that are being published to the client
    return &base.Response{
       StatusCode: base.StatusOK,
    }, sh.stream, nil
}

// called when receiving an ANNOUNCE request.
func (sh *serverHandler) OnAnnounce(ctx *gortsplib.ServerHandlerOnAnnounceCtx) (*base.Response, error) {
    log.Printf("announce request")

    sh.mutex.Lock()
    defer sh.mutex.Unlock()

    // disconnect existing publisher
    if sh.stream != nil {
       sh.stream.Close()
       sh.publisher.Close()
    }

    // create the stream and save the publisher
    sh.stream = gortsplib.NewServerStream(sh.s, ctx.Description)
    sh.publisher = ctx.Session

    return &base.Response{
       StatusCode: base.StatusOK,
    }, nil
}

// called when receiving a SETUP request.
func (sh *serverHandler) OnSetup(ctx *gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
    log.Printf("setup request")

    // no one is publishing yet
    if sh.stream == nil {
       return &base.Response{
          StatusCode: base.StatusNotFound,
       }, nil, nil
    }

    return &base.Response{
       StatusCode: base.StatusOK,
    }, sh.stream, nil
}

// called when receiving a PLAY request.
func (sh *serverHandler) OnPlay(ctx *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
    log.Printf("play request")

    return &base.Response{
       StatusCode: base.StatusOK,
    }, nil
}

// called when receiving a RECORD request.
func (sh *serverHandler) OnRecord(ctx *gortsplib.ServerHandlerOnRecordCtx) (*base.Response, error) {
    log.Printf("record request")

    // called when receiving a RTP packet
    ctx.Session.OnPacketRTPAny(func(medi *description.Media, forma format.Format, pkt *rtp.Packet) {
       // route the RTP packet to all readers
       sh.stream.WritePacketRTP(medi, pkt)
    })

    return &base.Response{
       StatusCode: base.StatusOK,
    }, nil
}

func main() {
    // configure the server
    h := &serverHandler{}
    h.s = &gortsplib.Server{
       Handler:           h,
       RTSPAddress:       ":8554",
       UDPRTPAddress:     ":8000",
       UDPRTCPAddress:    ":8001",
       MulticastIPRange:  "224.1.0.0/16",
       MulticastRTPPort:  8002,
       MulticastRTCPPort: 8003,
    }

    // start server and wait until a fatal error
    log.Printf("server is ready")
    panic(h.s.StartAndWait())
}
```

查看摄像头支持的输入格式：

```shell
v4l2-ctl -d /dev/video0 --list-formats-ext
```



推流命令：
```shell
ffmpeg -f v4l2 -input_format mjpeg -i /dev/video0 -vcodec libx264 -tune zerolatency -preset ultrafast -f rtsp rtsp://192.168.129.191:8554/live.sdp
```

可以通过fflay命令行工具或者vlc播放器播放
```shell
ffplay  rtsp://192.168.129.191:8554/live.sdp
```

FFmpe读取UVC摄像头推流

C++与Go系列之内存篇





### C++ 内存管理

C++ 提供了丰富的内存管理功能，从手动内存管理到自动内存管理都有涉及。

#### 手动内存管理

1. **动态内存分配**
   - `new` 和 `delete`：用于分配和释放单个对象。
     ```cpp
     int* ptr = new int; // 分配一个int
     delete ptr; // 释放内存
     ```
   - `new[]` 和 `delete[]`：用于分配和释放数组。
     ```cpp
     int* arr = new int[10]; // 分配一个int数组
     delete[] arr; // 释放内存
     ```

2. **C风格的内存管理函数**
   - **`malloc`**：分配指定字节数的内存，但不会初始化内存。
     ```cpp
     #include <cstdlib>

     int* ptr = (int*)malloc(sizeof(int) * 10); // 分配一个包含10个int的数组
     if (ptr == NULL) {
         // 处理分配失败的情况
     }

     // 使用内存

     free(ptr); // 释放内存
     ```
   - **`calloc`**：分配指定数量的元素并初始化为零。
     ```cpp
     int* ptr = (int*)calloc(10, sizeof(int)); // 分配并初始化包含10个int的数组
     if (ptr == NULL) {
         // 处理分配失败的情况
     }

     // 使用内存

     free(ptr); // 释放内存
     ```
   - **`realloc`**：重新分配内存大小。
     ```cpp
     int* ptr = (int*)malloc(sizeof(int) * 10); // 分配一个包含10个int的数组
     if (ptr == NULL) {
         // 处理分配失败的情况
     }

     ptr = (int*)realloc(ptr, sizeof(int) * 20); // 重新分配大小为20个int的内存
     if (ptr == NULL) {
         // 处理重新分配失败的情况
     }

     // 使用内存

     free(ptr); // 释放内存
     ```

3. **内存泄漏**
   - 未能释放分配的内存会导致内存泄漏。
   - 使用工具（如Valgrind）检测和调试内存泄漏。

#### 自动内存管理

1. **智能指针**
   - **`std::unique_ptr`**：独占所有权的智能指针，内存会在指针销毁时自动释放。
     ```cpp
     std::unique_ptr<int> ptr(new int(10));
     ```
   - **`std::shared_ptr`**：共享所有权的智能指针，引用计数为零时释放内存。
     ```cpp
     std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
     std::shared_ptr<int> ptr2 = ptr1; // 共享内存
     ```
   - **`std::weak_ptr`**：不增加引用计数的智能指针，用于打破循环引用。
     ```cpp
     std::weak_ptr<int> weakPtr = ptr1;
     ```

2. **RAII（资源获取即初始化）**
   - 通过构造函数获取资源（如内存），通过析构函数释放资源。
   - 标准库中的容器（如`std::vector`）使用RAII管理内存。

---

### Go 内存管理

Go语言提供了自动化的内存管理，主要依赖于垃圾回收（Garbage Collection）。

#### 垃圾回收

1. **自动内存管理**
   - Go语言中的内存分配和释放由垃圾回收器自动处理，开发者无需手动管理内存。
   - 使用`new`或`make`函数分配内存。
     ```go
     ptr := new(int) // 分配一个int
     arr := make([]int, 10) // 分配一个int数组
     ```

2. **垃圾回收器**
   - Go的垃圾回收器采用并发标记-清除算法。
   - 垃圾回收的触发和执行由运行时自动管理，开发者可以通过调整环境变量（如`GOGC`）来影响垃圾回收的频率。
     ```go
     runtime.GC() // 手动触发垃圾回收
     ```

#### 内存泄漏和优化

1. **内存泄漏**
   - 虽然Go有垃圾回收，但依然可能出现内存泄漏，例如长时间持有大对象的引用。
   - 使用`pprof`工具分析和调试内存使用。
     ```go
     import (
         "runtime/pprof"
         "os"
     )

     func main() {
         f, _ := os.Create("memprofile")
         pprof.WriteHeapProfile(f)
         f.Close()
     }
     ```

2. **内存优化**
   - 避免不必要的内存分配和复制。
   - 使用池化技术（如`sync.Pool`）重用对象，减少垃圾回收压力。
     ```go
     var pool = sync.Pool{
         New: func() interface{} {
             return new(bytes.Buffer)
         },
     }

     buf := pool.Get().(*bytes.Buffer)
     buf.Reset()
     pool.Put(buf)
     ```

---

### 对比与总结

1. **手动 vs 自动**
   - C++需要手动管理内存，提供了强大的灵活性，但也增加了内存泄漏和错误的风险。
   - Go采用自动垃圾回收，简化了内存管理，但可能带来性能开销。

2. **工具与调试**
   - C++依赖于工具（如`Valgrind`）检测内存问题。
   - Go使用内置工具（如`pprof`）进行内存分析和优化。

3. **内存优化策略**
   - C++可以通过优化内存分配和使用智能指针来减少内存问题。
   - Go通过调整垃圾回收参数和使用对象池来优化内存使用。

总结来说，C++和Go在内存管理方面各有优劣，选择合适的内存管理方法需要根据具体的应用场景和需求来决定。

C++与Go系列(三)

C++与Go系列之编译篇

Linux系统下自带C++编译工具g++，而Go的编译工具需要安装。



**写在前面**

1.Ubuntu安装最新版本的稳定版 golang-go 可以通过 snap
`sudo snap install go --classic`

如果snap不存在，通过以下命令安装进行按照：`sudo apt install snapd`

如果要查看snap支持安装的版本：`snap info go`


2.Ubuntu安装最新版本的golang-go也可以通过PPA，需要先添加PPA源
`sudo add-apt-repository ppa:longsleep/golang-backports` 

然后执行安装命令
`sudo apt-get install golang-go`

如果要安装指定版本`sudo apt-get install golang-1.11-go`

如果add-apt-repository不存在，通过以下命令安装进行按照：`sudo apt-get install software-properties-common`

如果要查看支持安装的版本：`apt-cache madison golang-go`

3.一般安装完go后还需要设置模块包代理地址：
`go env -w GOPROXY=https://goproxy.cn,direct`
查看是否设置成功：
`go env | grep GOPROXY`

### C++ 代码编译与构建过程

1. **源文件编写**
   - C++源文件通常以`.cpp`、`.h`、`.hpp`等扩展名保存。

2. **预处理（Preprocessing）**
   - 预处理器指令（如`#include`、`#define`）在这一阶段处理。
   - 预处理的输出是一个纯文本文件，没有预处理器指令。

3. **编译（Compilation）**
   - 将预处理后的代码转换为汇编代码。
   - 每个源文件都会生成一个对应的汇编文件（`.s`）。

4. **汇编（Assembly）**
   - 汇编代码转换为机器码，生成目标文件（`.o`或`.obj`）。
   - 目标文件包含二进制代码，但还不是可执行文件。

5. **链接（Linking）**
   - 将所有目标文件和所需的库文件链接在一起，生成最终的可执行文件。
   - 静态链接：将所有依赖的库静态嵌入可执行文件。
   - 动态链接：将依赖库在运行时动态加载。

6. **构建系统**
   - 使用构建系统（如Make、CMake、Ninja）来管理和自动化编译与链接过程。

### Go 代码编译与构建过程

1. **源文件编写**
   - Go源文件以`.go`扩展名保存。

2. **导入包（Importing Packages）**
   - `import`语句用于导入标准库或第三方库。

3. **编译（Compilation）**
   - Go编译器将所有的Go文件编译成中间代码。
   - 所有依赖包在编译时会被解析和编译。

4. **链接（Linking）**
   - 将所有中间代码和所需的库链接成一个单一的可执行文件。
   - Go使用静态链接，所有依赖库都嵌入到可执行文件中。

5. **构建工具**
   - Go有内置的构建工具，如`go build`、`go install`、`go run`。
   - `go build`：编译包及其依赖项，但不安装结果。
   - `go install`：编译并安装包。
   - `go run`：编译并运行Go程序。

### 对比总结

1. **编译过程**
   - C++有多个独立的阶段（预处理、编译、汇编、链接），而Go的编译过程更简化，直接从源码到可执行文件。
   
2. **构建系统**
   - C++常用第三方构建系统，如Make、CMake，Go则使用内置工具，简化了构建过程。当然，Make也可以用于构建Go项目
   
3. **依赖管理**
   - C++的依赖管理通常通过手动配置或使用包管理器（如vcpkg、Conan）。
   - Go有内置的模块管理系统（Go Modules），方便依赖管理。

### 示例代码与命令

**C++ 构建示例**
```cpp
// main.cpp
#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}
```
```bash
g++ -o hello main.cpp
./hello
```

**Go 构建示例**
```go
// main.go
package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}
```
```bash
go build -o hello main.go
./hello
```

编译后的文件比对(编译器版本不同可能编译出来的大小不一样)，其hello_cpp采用动态链接libstdc++.so：

```
root@ubuntu:~/cpp-go# ls -alh
total 1.9M
drwxr-xr-x 2 root root 4.0K Jul 21 10:19 .
drwxr-xr-x 6 root root 4.0K Jul 20 23:07 ..
-rwxr-xr-x 1 root root 9.7K Jul 20 23:08 hello_cpp
-rw-r--r-- 1 root root   97 Jul 20 23:07 hello_cpp.cpp
-rwxr-xr-x 1 root root 1.9M Jul 21 10:19 hello_go
-rw-r--r-- 1 root root   77 Jul 20 23:07 hello_go.go
```

### 关于交叉编译

交叉编译（Cross-compilation）是指在一种平台上编译生成可在另一种平台上运行的二进制文件的过程。也就是说，在Linux上编译生成Windows的程序，或者在x86_64架构的Linux上编译生成适用于ARM64架构的Linux程序，都是要通过交叉编译。

#### C++交叉编译

##### 工具链

C++交叉编译通常需要特定的工具链，例如`gcc`、`g++`的交叉编译版本。常见的工具链有：

- `arm-linux-gnueabi-g++`：用于ARM架构的Linux系统。
- `x86_64-w64-mingw32-g++`：用于64位的Windows系统。

##### 示例：在Linux上为ARM编译


```bash
arm-linux-gnueabi-g++ -o hello_arm main.cpp
```

如果还没有安装ARM交叉编译工具链，可以使用以下命令进行安装：

```bash
sudo apt-get install g++-arm-linux-gnueabi
```

##### 示例：在Linux上为Windows编译



```bash
x86_64-w64-mingw32-g++ -o hello_windows.exe main.cpp
```

如果还没有安装Windows交叉编译工具链，可以使用以下命令进行安装：

```bash
sudo apt-get install g++-mingw-w64
```

#### Go交叉编译

Go语言的交叉编译比C++要简单得多，因为Go编译器本身就支持多平台交叉编译。

##### 设置环境变量

在Go中进行交叉编译，只需设置几个环境变量：

- `GOOS`：目标操作系统，如`linux`、`windows`、`darwin`。
- `GOARCH`：目标架构，如`amd64`、`arm`、`386`。

##### 示例：在Linux上为Windows编译



```bash
GOOS=windows GOARCH=amd64 go build -o hello_windows.exe main.go
```

##### 示例：在Linux上为ARM编译


```bash
GOOS=linux GOARCH=arm go build -o hello_arm main.go
```

#### 对比与总结

1. **工具链**
   - C++需要特定的交叉编译工具链，如`arm-linux-gnueabi-g++`、`x86_64-w64-mingw32-g++`。
   - Go内置支持交叉编译，只需设置环境变量`GOOS`和`GOARCH`。

2. **编译命令**
   - C++需要安装并使用对应的交叉编译器。
   - Go通过内置支持，直接设置环境变量即可实现交叉编译。

3. **配置简易性**
   - C++的交叉编译配置相对复杂，需要了解并配置对应的工具链。
   - Go的交叉编译配置简单，编译过程更为直观。

C++与Go系列(二)

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)