Go语言基础——基础语法

叁歲伎倆 2024-03-24 16:51 12阅读 0赞

> **作者**：非妃是公主  
> **专栏**：《Golang》  
> **博客地址**：[https://blog.csdn.net/myf\_666][https_blog.csdn.net_myf_666]  
> **个性签：顺境不惰，逆境不馁，以心制境，万事可成。——曾国藩**  
> ![在这里插入图片描述][d6e10e8cd5b342e8a44dd458ee6d28f7.jpeg]  
> 
> 
> #### 文章目录 ####
> 
>  *  一、Go语言的特点
>  *  二、基础语法
>  *   *  1. 变量
>      *  2. for
>      *  3. if
>      *  4. switch
>      *  5. 数组
>      *  6. 切片
>      *  7. map
>      *  8. range
>      *  9. 函数
>      *  10. 指针
>      *  11. 结构体
>      *  12. 类方法
>      *  13. 错误处理
>      *  14. 字符串
>      *  15. 字符串格式化——fmt
>      *  16. Json处理
>      *  17. 时间处理
>      *  18. 字符串和数字之间的转换
>      *  19. 进程信息

## 一、Go语言的特点 ##

![在这里插入图片描述][12d8efcb7e2e465b927d44a5052529c0.png_pic_center_x_16]

1.  高性能、高并发：Go语言是一种编译型语言，在高性能和高并发上着重进行优化，不需要利用第三方库就具有较高的性能以及并发能力。
2.  Go的语法十分简单，相比于C/C++，它更加高级，学习起来较容易上手。
3.  Go语言具有丰富的标准库，相对于Java，许多库我们需要采用第三方的，这时候可能会出现一些版本不兼容、以及存在bug等问题。而Go不会，它拥有丰富的标准库，仅仅利用标准库就可以完成丰富的开发工作。
4.  Go具有完善的工具链。比如测试工具、包管理、性能优化等。
5.  Go具有静态链接。所有的文件都是静态链接的，占用空间小，部署方便。
6.  快速编译。Go的编译速度很快，可以做到实时编译，不像C/C++一样，大项目编译一次需要耗费大量的实践。
7.  跨平台。
8.  具有垃圾回收机制，不需要考虑变量内存的管理。

--------------------

## 二、基础语法 ##

### 1. 变量 ###

1.  如果不声明类型，进行类型推断。
2.  变量类型放在变量名后面。
3.  常量没有确定的类型，会根据上下文推断类型，使用const。

package main
    
    import (
    	"fmt"
    	"math"
    )
    
    func main() {
        
    
    	var a = "initial"
    
    	var b, c int = 1, 2
    
    	var d = true
    
    	var e float64
    
    	f := float32(e)
    
    	g := a + "foo"
    	fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
    	fmt.Println(g)                // initialapple
    
    	const s string = "constant"
    	const h = 500000000
    	const i = 3e20 / h
    	fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
    }

运行结果如下：

![在这里插入图片描述][3f2819429a7d4384a7e5ef5e7843ba54.png_pic_center_x_16]

### 2. for ###

1.  支持以下几种类型，值得注意的是，Go中只存在for，不存在while、do while等。所有的循环都采用for进行。
2.  for循环结束条件不添加括号。
3.  for循环不写条件，表示死循环。
4.  break跳出循环，continue继续循环。

package main
    
    import "fmt"
    
    func main() {
        
    
    	i := 1
    	for {
        
    		fmt.Println("loop")
    		break
    	}
    	for j := 7; j < 9; j++ {
        
    		fmt.Println(j)
    	}
    
    	for n := 0; n < 5; n++ {
        
    		if n%2 == 0 {
        
    			continue
    		}
    		fmt.Println(n)
    	}
    	for i <= 3 {
        
    		fmt.Println(i)
    		i = i + 1
    	}
    }

输出结果：

![在这里插入图片描述][8410f44cb2cc43509995d25c473fe500.png_pic_center_x_16]

### 3. if ###

1.  if后面没有括号。
2.  if后面需要跟着大括号，不能将语句和if写到1行。

package main
    
    import "fmt"
    
    func main() {
        
    
    	if 7%2 == 0 {
        
    		fmt.Println("7 is even")
    	} else {
        
    		fmt.Println("7 is odd")
    	}
    
    	if 8%4 == 0 {
        
    		fmt.Println("8 is divisible by 4")
    	}
    
    	if num := 9; num < 0 {
        
    		fmt.Println(num, "is negative")
    	} else if num < 10 {
        
    		fmt.Println(num, "has 1 digit")
    	} else {
        
    		fmt.Println(num, "has multiple digits")
    	}
    }

![在这里插入图片描述][b63bae0b2c9940cbb1da173fbb228515.png_pic_center_x_16]

### 4. switch ###

1.  不需要break；遇到符合条件的执行完后，自动会跳出switch。
2.  更加灵活，可以当作 if 去使用，不需要类型。

package main
    
    import (
    	"fmt"
    	"time"
    )
    
    func main() {
        
    
    	a := 2
    	switch a {
        
    	case 1:
    		fmt.Println("one")
    	case 2:
    		fmt.Println("two")
    	case 3:
    		fmt.Println("three")
    	case 4, 5:
    		fmt.Println("four or five")
    	default:
    		fmt.Println("other")
    	}
    
    	t := time.Now()
    	switch {
        
    	case t.Hour() < 12:
    		fmt.Println("It's before noon")
    	default:
    		fmt.Println("It's after noon")
    	}
    }

运行结果如下：

![在这里插入图片描述][9d85ada3904a4b4892e3b3bfac8b803a.png_pic_center_x_16]

### 5. 数组 ###

数组的长度是固定的，使用如下，在真正的开发业务中很少去使用，更多地是使用大小可以变化的切片，具体用法如下：

package main
    
    import "fmt"
    
    func main() {
        
    
    	var a [5]int
    	a[4] = 100
    	fmt.Println("get:", a[2])
    	fmt.Println("len:", len(a))
    
    	b := [5]int{
        1, 2, 3, 4, 5}
    	fmt.Println(b)
    
    	var twoD [2][3]int
    	for i := 0; i < 2; i++ {
        
    		for j := 0; j < 3; j++ {
        
    			twoD[i][j] = i + j
    		}
    	}
    	fmt.Println("2d: ", twoD)
    }

运行结果如下：

![在这里插入图片描述][d4771bd79dff4a37b424474245e58350.png_pic_center_x_16]

### 6. 切片 ###

1.  切片是一个大小可变的数组。
2.  可以使用append去追加元素。(注意：必须要将append的返回值重新赋值给数组，因为如果内存不够，切片会自动扩容，内存重新分配所以内存地址会发生变化)
3.  存在copy操作，可以对切片内容进行拷贝。
4.  不支持负数索引(像python的-1表示倒数第1个元素)。
5.  切片的时候左闭右开。

package main
    
    import "fmt"
    
    func main() {
        
    
    	s := make([]string, 3)
    	s[0] = "a"
    	s[1] = "b"
    	s[2] = "c"
    	fmt.Println("get:", s[2])   // c
    	fmt.Println("len:", len(s)) // 3
    
    	s = append(s, "d")
    	s = append(s, "e", "f")
    	fmt.Println(s) // [a b c d e f]
    
    	c := make([]string, len(s))
    	copy(c, s)
    	fmt.Println(c) // [a b c d e f]
    
    	fmt.Println(s[2:5]) // [c d e]
    	fmt.Println(s[:5])  // [a b c d e]
    	fmt.Println(s[2:])  // [c d e f]
    
    	good := []string{
        "g", "o", "o", "d"}
    	fmt.Println(good) // [g o o d]
    }

运行结果如下：

![在这里插入图片描述][e417c329ce6f45f09c4107e2edcffdad.png_pic_center_x_16]

### 7. map ###

1.  map进行get操作时，第1个值是value，第2个值是ok，表示是否存在。
2.  delete操作可以对map中键值对进行删除。增、改操作直接赋值即可。

package main
    
    import "fmt"
    
    func main() {
        
    	m := make(map[string]int)
    	m["one"] = 1
    	m["two"] = 2
    	fmt.Println(m)           // map[one:1 two:2]
    	fmt.Println(len(m))      // 2
    	fmt.Println(m["one"])    // 1
    	fmt.Println(m["unknow"]) // 0
    
    	r, ok := m["unknow"]
    	fmt.Println(r, ok) // 0 false
    
    	delete(m, "one")
    
    	m2 := map[string]int{
        "one": 1, "two": 2}
    	var m3 = map[string]int{
        "one": 1, "two": 2}
    	fmt.Println(m2, m3)
    }

输出结果如下：

![在这里插入图片描述][72a0a02bf7ef4b0da89763de54769503.png_pic_center_x_16]

### 8. range ###

1.  range可以对数组、map等进行快速的遍历。
2.  对数组遍历时，可以很方便的获取它的index和value。
3.  对map遍历时，可以很方便的获取map的key和value。

package main
    
    import "fmt"
    
    func main() {
        
    	nums := []int{
        2, 3, 4}
    	sum := 0
    	for i, num := range nums {
        
    		sum += num
    		if num == 2 {
        
    			fmt.Println("index:", i, "num:", num) // index: 0 num: 2
    		}
    	}
    	fmt.Println(sum) // 9
    
    	m := map[string]string{
        "a": "A", "b": "B"}
    	for k, v := range m {
        
    		fmt.Println(k, v) // b 8; a A
    	}
    	for k := range m {
        
    		fmt.Println("key", k) // key a; key b
    	}
    }

输出结果如下：

![在这里插入图片描述][e57dbbe49efc44d3a4d3e07244b38f84.png_pic_center_x_16]

### 9. 函数 ###

1.  函数原生支持返回多个返回值。实际业务中，第一个值返回value，第二个值返回错误信息。
2.  参数类型后置。
3.  参数在前，返回值在后。

package main
    
    import "fmt"
    
    func add(a int, b int) int {
        
    	return a + b
    }
    
    func add2(a, b int) int {
        
    	return a + b
    }
    
    func exists(m map[string]string, k string) (v string, ok bool) {
        
    	v, ok = m[k]
    	return v, ok
    }
    
    func main() {
        
    	res := add(1, 2)
    	fmt.Println(res) // 3
    
    	v, ok := exists(map[string]string{
        "a": "A"}, "a")
    	fmt.Println(v, ok) // A True
    }

输出结果：

![在这里插入图片描述][79730bef3b0d466c92c6184309cf77fd.png_pic_center_x_16]

### 10. 指针 ###

1.  需要注意进行类型匹配，指针传参使用&，指针参数\*int，更改指针类型对应的值时要用\*(解操作)。
2.  带有指针的传参，对于一些大结构体来说可以提升程序性能。
3.  使用指针，可以修改变量值。

package main
    
    import "fmt"
    
    func add2(n int) {
        
    	n += 2
    }
    
    func add2ptr(n *int) {
        
    	*n += 2
    }
    
    func main() {
        
    	n := 5
    	add2(n)
    	fmt.Println(n) // 5
    	add2ptr(&n)
    	fmt.Println(n) // 7
    }

输出结果如下：

![在这里插入图片描述][d92bc430c099410eaf8db0d7d4f44542.png_pic_center_x_16]

### 11. 结构体 ###

1.  结构体定义如下。
2.  结构体作为参数有2中，指针类型和非指针类型。采用指针类型可以修改结构体值，同时，指针类型也可以避免大结构体传参造成的性能开销。

package main
    
    import "fmt"
    
    type user struct {
        
    	name     string
    	password string
    }
    
    func main() {
        
    	a := user{
        name: "wang", password: "1024"}
    	b := user{
        "wang", "1024"}
    	c := user{
        name: "wang"}
    	c.password = "1024"
    	var d user
    	d.name = "wang"
    	d.password = "1024"
    
    	fmt.Println(a, b, c, d)                 // {wang 1024} {wang 1024} {wang 1024} {wang 1024}
    	fmt.Println(checkPassword(a, "haha"))   // false
    	fmt.Println(checkPassword2(&a, "haha")) // false
    }
    
    func checkPassword(u user, password string) bool {
        
    	return u.password == password
    }
    
    func checkPassword2(u *user, password string) bool {
        
    	return u.password == password
    }

输出结果如下：

![在这里插入图片描述][a96ed0f55213477c82adc8ef441762f5.png_pic_center_x_16]

### 12. 类方法 ###

1.  类方法可以被对象调用，其中，定义的时候把类放在函数名前面即可。
2.  方法名前放非指针类型，不能修改调用对象。
3.  方法名前放指针类型，可以修改调用对象。

package main
    
    import "fmt"
    
    type user struct {
        
    	name     string
    	password string
    }
    
    func (u user) checkPassword(password string) bool {
        
    	return u.password == password
    }
    
    func (u *user) resetPassword(password string) {
        
    	u.password = password
    }
    
    func main() {
        
    	a := user{
        name: "wang", password: "1024"}
    	a.resetPassword("2048")
    	fmt.Println(a.checkPassword("2048")) // true
    }

输出结果如下：

![在这里插入图片描述][358f3ee8cbd44ab1bb627f828846f538.png_pic_center_x_16]

### 13. 错误处理 ###

1.  Go中的错误处理如下，如果函数处理中存在错误，则返回nil和error。
2.  如果函数处理正确则返回正确结果和nil。
3.  调用时，如果err项不为nil，则证明程序存在错误，需要进行错误处理。

package main
    
    import (
    	"errors"
    	"fmt"
    )
    
    type user struct {
        
    	name     string
    	password string
    }
    
    func findUser(users []user, name string) (v *user, err error) {
        
    	for _, u := range users {
        
    		if u.name == name {
        
    			return &u, nil
    		}
    	}
    	return nil, errors.New("not found")
    }
    
    func main() {
        
    	u, err := findUser([]user{
        {
        "wang", "1024"}}, "wang")
    	if err != nil {
        
    		fmt.Println(err)
    		return
    	}
    	fmt.Println(u.name) // wang
    
    	if u, err := findUser([]user{
        {
        "wang", "1024"}}, "li"); err != nil {
        
    		fmt.Println(err) // not found
    		return
    	} else {
        
    		fmt.Println(u.name)
    	}
    }

输出结果如下：

![在这里插入图片描述][3fcbbed8371140898b36c575c041a038.png_pic_center_x_16]

### 14. 字符串 ###

1.  GoLang包含了许多字符串处理函数。如下：
2.  `contains`：返回bool类型，为字符串中是否包含子串
3.  `HasPrefix`是否存在前缀
4.  `HasSuffix`是否存在后缀
5.  `Index`子字符串开始的位置
6.  `Join`字符串连接操作
7.  `repeat`复制n个字符串
8.  `replace`替换字符串中的字符
9.  `Split`分割字符串
10. `ToLower`变小写
11. `ToUpper`变大写
12. `len`字符串的长度，注意：这里指的是字符串的Byte数，而不是字符数，比如：“你好”含有两个字符，但是由于汉字编码较长，所以需要占3个Byte。关于编码问题可以详细看博主的这篇文章：[字符编码详解及利用C++ STL string遍历中文字符串][C_ STL string]

package main
    
    import (
    	"fmt"
    	"strings"
    )
    
    func main() {
        
    	a := "hello"
    	fmt.Println(strings.Contains(a, "ll"))                // true
    	fmt.Println(strings.Count(a, "l"))                    // 2
    	fmt.Println(strings.HasPrefix(a, "he"))               // true
    	fmt.Println(strings.HasSuffix(a, "llo"))              // true
    	fmt.Println(strings.Index(a, "ll"))                   // 2
    	fmt.Println(strings.Join([]string{
        "he", "llo"}, "-")) // he-llo
    	fmt.Println(strings.Repeat(a, 2))                     // hellohello
    	fmt.Println(strings.Replace(a, "e", "E", -1))         // hEllo
    	fmt.Println(strings.Split("a-b-c", "-"))              // [a b c]
    	fmt.Println(strings.ToLower(a))                       // hello
    	fmt.Println(strings.ToUpper(a))                       // HELLO
    	fmt.Println(len(a))                                   // 5
    	b := "你好"
    	fmt.Println(len(b)) // 6
    }

输出结果如下：

![在这里插入图片描述][e739e0670c1849a59fbdecd38f90567a.png_pic_center_x_16]

### 15. 字符串格式化——fmt ###

1.  可以打印字符串、数字、结构体
2.  %v可以在字符串中进行输出变量，值得注意的是，不同于C/C++，此处并不区分变量类型。
3.  `%+v`可以获得详细输出
4.  `%#v`可以获得更加详细的输出，具体代码示例如下：

package main
    
    import "fmt"
    
    type point struct {
        
    	x, y int
    }
    
    func main() {
        
    	s := "hello"
    	n := 123
    	p := point{
        1, 2}
    	fmt.Println(s, n) // hello 123
    	fmt.Println(p)    // {1 2}
    
    	fmt.Printf("s=%v\n", s)  // s=hello
    	fmt.Printf("n=%v\n", n)  // n=123
    	fmt.Printf("p=%v\n", p)  // p={1 2}
    	fmt.Printf("p=%+v\n", p) // p={x:1 y:2}
    	fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2}
    
    	f := 3.141592653
    	fmt.Println(f)          // 3.141592653
    	fmt.Printf("%.2f\n", f) // 3.14
    }

### 16. Json处理 ###

1.  定义结构体，但结构体要保证每一个字段名首字母是大写。如果需要设置小写，可以给字段添加tag(标签或别名)，如下面代码中userInfo中的Age字段。
2.  `json.Marshal(a)`将结构体转换为json
3.  答应json时，要转化为string，否则会打印出字符对应的编码。
4.  `json.MarshalIndent(a, "", "\t")`和`json.Marshal(a)`作用是相似的，但是输出中的每个JSON元素将在一个新的行上开始，以前缀开始，后面是根据缩进嵌套的一个或多个副本的缩进，利用了缩进来格式化输出。
5.  `json.Unmarshal(buf, &b)`将json转化为结构体。

package main
    
    import (
    	"encoding/json"
    	"fmt"
    )
    
    type userInfo struct {
        
    	Name  string
    	Age   int `json:"age"`
    	Hobby []string
    }
    
    func main() {
        
    	a := userInfo{
        Name: "wang", Age: 18, Hobby: []string{
        "Golang", "TypeScript"}}
    	buf, err := json.Marshal(a)
    	if err != nil {
        
    		panic(err)
    	}
    	fmt.Println(buf)         // [123 34 78 97...]
    	fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}
    
    	buf, err = json.MarshalIndent(a, "", "\t")
    	if err != nil {
        
    		panic(err)
    	}
    	fmt.Println(string(buf))
    
    	var b userInfo
    	err = json.Unmarshal(buf, &b)
    	if err != nil {
        
    		panic(err)
    	}
    	fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
    }

输出结果如下：  
![在这里插入图片描述][c70cd302a21a4adda4032d36fdcfc147.png_pic_center_x_16]

### 17. 时间处理 ###

1.  时间处理函数如下。
2.  可以获取当前时间，初始化日期。
3.  其中，日期的格式化可以采用一个实例去设置，输出会和这个示例一样的日期格式，十分方便。
4.  `t2.sub(t0)`可以获取两个日期之间的时间长度。
5.  时间长度可以转化为分、秒。通过.minutes、.seconds()
6.  日期类型可以进行符号比较。
7.  Parse和Format作用都是格式化时间，但是参数不同，用法不同，具体可以看下面的代码示例。
8.  可以通过`now.Unix()`获取当前时间戳

package main
    
    import (
    	"fmt"
    	"time"
    )
    
    func main() {
        
    	now := time.Now()
    	fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
    	t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
    	t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
    	fmt.Println(t)                                                  // 2022-03-27 01:25:36 +0000 UTC
    	fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25
    	fmt.Println(t.Format("2006-01-02 15:04:05"))                    // 2022-03-27 01:25:36
    	diff := t2.Sub(t)
    	fmt.Println(diff)                           // 1h5m0s
    	fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
    	t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
    	if err != nil {
        
    		panic(err)
    	}
    	fmt.Println(t3 == t)    // true
    	fmt.Println(now.Unix()) // 1648738080
    }

输出结果如下：

![在这里插入图片描述][85d1f46961e445788843ed0ad3e51e50.png_pic_center_x_16]

### 18. 字符串和数字之间的转换 ###

1.  字符串可以解析成Float、Int类型，其中，在解析为Int类型时，需要注意时10进制、2进制、16进制，在第二个参数进行指定，如果第二个参数指定为0，则为自动推断类型。第三个参数表示位数，64表示转化为64位float类型。
2.  Atoi表示字符串转化为int类型。如果无法转化，则会返回错误信息。

package main
    
    import (
    	"fmt"
    	"strconv"
    )
    
    func main() {
        
    	f, _ := strconv.ParseFloat("1.234", 64)
    	fmt.Println(f) // 1.234
    
    	n, _ := strconv.ParseInt("111", 10, 64)
    	fmt.Println(n) // 111
    
    	n, _ = strconv.ParseInt("0x1000", 0, 64)
    	fmt.Println(n) // 4096
    
    	n2, _ := strconv.Atoi("123")
    	fmt.Println(n2) // 123
    
    	n2, err := strconv.Atoi("AAA")
    	fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
    }

程序运行结果如下：

![在这里插入图片描述][0d742365655b4806a142f9f11c34f84c.png_pic_center_x_16]

### 19. 进程信息 ###

1.  可以`os.Args`获取一些命令行参数；
2.  `os.Getenv("PATH")`获取环境变量；
3.  `os.Setenv("AA", "BB")`设置环境变量；
4.  `exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()`启动子进程，并获取输出。

package main
    
    import (
    	"fmt"
    	"os"
    	"os/exec"
    )
    
    func main() {
        
    	// go run example/20-env/main.go a b c d
    	fmt.Println(os.Args)           // [/var/folders/8p/n34xxfnx38dg8bv_x8l62t_m0000gn/T/go-build3406981276/b001/exe/main a b c d]
    	fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...
    	fmt.Println(os.Setenv("AA", "BB"))
    
    	buf, err := exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()
    	if err != nil {
        
    		panic(err)
    	}
    	fmt.Println(string(buf)) // 127.0.0.1       localhost
    }

程序输出如下：

![在这里插入图片描述][7a21779d0bc840e9947a2ec2a2a9c9d7.png_pic_center_x_16]

[https_blog.csdn.net_myf_666]: https://blog.csdn.net/myf_666
[d6e10e8cd5b342e8a44dd458ee6d28f7.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/972569f8f02d45cd90394ca6e778e446.png
[12d8efcb7e2e465b927d44a5052529c0.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/7a5e3cc287ba422ca67a7044baff592f.png
[3f2819429a7d4384a7e5ef5e7843ba54.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/c8046cf349ee4c74b362151970da2253.png
[8410f44cb2cc43509995d25c473fe500.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/6317e4baac344ef29ad62e878462295c.png
[b63bae0b2c9940cbb1da173fbb228515.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/8216f95686024871a51237e2fc4aa489.png
[9d85ada3904a4b4892e3b3bfac8b803a.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/a8f7716fa6054d5b84f00ec5f87b20e2.png
[d4771bd79dff4a37b424474245e58350.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/c9a19e1cbc144d1c9aedc9f88790ee35.png
[e417c329ce6f45f09c4107e2edcffdad.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/70426d1730544b5199e6abeb7df21543.png
[72a0a02bf7ef4b0da89763de54769503.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/0842042786104f369f2b889c3e1ecea3.png
[e57dbbe49efc44d3a4d3e07244b38f84.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/4ac2129285d34f71b9797ec8f33e0cd3.png
[79730bef3b0d466c92c6184309cf77fd.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e9e2d13897364ae2b7861628afb43e3a.png
[d92bc430c099410eaf8db0d7d4f44542.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/f0b41ecf63a34a2aa58c65db65d31f47.png
[a96ed0f55213477c82adc8ef441762f5.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e498c0705c6a488398d2c00ae835fda0.png
[358f3ee8cbd44ab1bb627f828846f538.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/56185e5f9b8547f697d5bbaa23d4cee3.png
[3fcbbed8371140898b36c575c041a038.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/f3dc309989924aee9bb47c897f365fbf.png
[C_ STL string]: https://blog.csdn.net/myf_666/article/details/128604637
[e739e0670c1849a59fbdecd38f90567a.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/44706de49fb5421ca2ba1068c100114f.png
[c70cd302a21a4adda4032d36fdcfc147.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/d13292b5521d4c11bbcc67691388f48b.png
[85d1f46961e445788843ed0ad3e51e50.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/d2df9ee3d1974e09b4b4494e71b88cde.png
[0d742365655b4806a142f9f11c34f84c.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/a0cb66235dbf4a40b0d63fc4a445b2c6.png
[7a21779d0bc840e9947a2ec2a2a9c9d7.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/3f94078612944c18b141243ced93dbb0.png