基础语法 on 鹿鸣青野的blog

C++ 基础遗漏知识点：bool、sizeof、auto、nullptr 与 static

Tue, 13 Oct 2026 00:00:00 +0000

容易被忽略但常出问题的基础语法点：bool 与 boolalpha、sizeof 的指针陷阱、auto 的 const 剥离、nullptr 与 static。

1. bool 类型与 boolalpha

核心规则

场景	结果	说明
`bool b = true`	输出 `1`	默认输出数字
`bool b = false`	输出 `0`	默认输出数字
`bool b = -8`	输出 `1`	非零即为 true
`bool b = 0`	输出 `0`	零即为 false

boolalpha 操纵符

使用 std::boolalpha 可以让 cout 输出 true/false 而不是 1/0。

#include <iostream>
using namespace std;

int main() {
 bool isTrue = true;

 // 默认输出（数字）
 cout << "默认: " << isTrue << endl; // 输出: 1

 // 使用 boolalpha（文字）
 cout << boolalpha;
 cout << "boolalpha: " << isTrue << endl; // 输出: true

 // 非零值也为 true
 bool b = -8;
 cout << "-8 转 bool: " << b << endl; // 输出: true

 return 0;
}

常见陷阱

// 陷阱1：非零即为 true
bool b1 = 42; // true
bool b2 = -1; // true
bool b3 = 0.001; // true
bool b4 = nullptr; // false (C++11)

// 陷阱2：bool 与整数混合运算
int a = true + true; // a = 2（true 被提升为 1）
int b = true * 10; // b = 10

2. sizeof 运算符

基本用法

#include <iostream>
using namespace std;

int main() {
 cout << "char: " << sizeof(char) << endl; // 1
 cout << "short: " << sizeof(short) << endl; // 2
 cout << "int: " << sizeof(int) << endl; // 4
 cout << "long: " << sizeof(long) << endl; // 4 或 8
 cout << "long long: " << sizeof(long long) << endl; // 8
 cout << "float: " << sizeof(float) << endl; // 4
 cout << "double: " << sizeof(double) << endl; // 8

 // 数组
 int arr[10];
 cout << "int[10]: " << sizeof(arr) << endl; // 40

 // 指针
 int* p;
 cout << "int*: " << sizeof(p) << endl; // 4 或 8

 return 0;
}

动态数组的 sizeof 陷阱

int* arr = new int[10];
cout << sizeof(arr) << endl; // 输出 4 或 8（指针大小，不是数组大小！）

// 正确获取动态数组大小：需要额外传参或用 vector

3. auto 关键字（C++11）

基本用法

auto x = 42; // int
auto y = 3.14; // double
auto z = "hello"; // const char*
auto flag = true; // bool

// 推荐用于复杂类型
#include <vector>
#include <map>

std::vector<int> v = {1, 2, 3};
auto it = v.begin(); // std::vector<int>::iterator

std::map<std::string, int> m;
auto pair = std::make_pair("key", 1);

注意事项

// auto 会忽略顶层 const
const int a = 10;
auto b = a; // b 是 int，不是 const int
const auto c = a; // c 是 const int

// 引用形式的 auto 才保留底层 const
const int& ref = a;
auto ref2 = ref; // ref2 是 int 拷贝——普通 auto 剥离引用,连同底层 const 一起丢
auto& ref3 = ref; // ref3 是 const int&——auto& 保留底层 const(不能改 *ref3)

4. nullptr（C++11）

与 NULL 的区别

// NULL 在 C++ 中可能是 0 或 (void*)0
void func(int);
void func(char*);

func(NULL); // 编译错误！歧义
func(nullptr); // OK，调用 func(char*)

最佳实践

// 初始化指针
int* p = nullptr;

// 判断指针
if (p != nullptr) {
 // 使用 p
}

// 函数参数
void foo(int* ptr) {
 if (ptr == nullptr) {
 return;
 }
}

5. const 与 constexpr（简记）

特性	const	constexpr
初始化时机	运行时	编译时
可用于函数返回值	是	是
编译期常量	否	是

const int x = 10; // OK
constexpr int y = 20; // OK，编译期常量

// constexpr 函数
constexpr int square(int n) {
 return n * n;
}
constexpr int val = square(5); // 编译期计算

const 与 constexpr 的完整对比、constexpr 函数、if constexpr、C++20 的 consteval/constinit，见另一篇《C++ namespace、const 与 constexpr 知识点总结》。

Map（哈希表）

Tue, 13 Oct 2026 00:00:00 +0000

Go 的内置关联容器，键值对存储，底层是哈希表

一、概述

map 是 Go 的内置数据结构，用于存储键值对。它等价于 C++ 的 std::unordered_map——基于哈希表实现，不是红黑树（Go 没有 std::map 那样的有序容器）。

核心特性：

引用类型，赋值和传参共享底层数组
键必须支持 == 比较（可哈希）
遍历顺序不确定（哈希表特性）
并发读写会触发 fatal（不是 data race，直接崩程序）

二、C++ 对照速查表

Go	C++	说明
`map[K]V` 类型声明	`std::unordered_map<K,V>` 类型声明	声明一个 map 类型
`m := map[string]int{}`	`auto m = unordered_map<string,int>();`	字面量初始化
`m := make(map[string]int)`	`auto m = unordered_map<string,int>();`	make 初始化
`m := make(map[string]int, 64)`	`auto m = unordered_map<string,int>(64);`	预分配容量
`m["key"] = 42`	`m["key"] = 42;`	插入/修改
`delete(m, "key")`	`m.erase("key");`	删除键
`val, ok := m["key"]`	`auto it = m.find("key"); it != m.end()`	查找（双返回值）
`len(m)`	`m.size()`	获取大小
`nil map`	`nullptr` 的 map	未初始化的 map
`for k, v := range m`	`for (auto& [k, v] : m)`	遍历
无	`std::map<K,V>`	Go 没有有序 map

三、声明与初始化

3.1 字面量初始化（最常用）

package main

import "fmt"

func main() {
 // 字面量初始化：声明 + 赋值一步到位
 ages := map[string]int{
 "Alice": 30,
 "Bob": 25,
 "Carol": 28,
 }
 fmt.Println(ages) // map[Alice:30 Bob:25 Carol:28]

 // 空 map
 empty := map[string]int{}
 fmt.Println(len(empty)) // 0
}

3.2 make 初始化

// make 创建空 map，可选预分配容量（提高性能）
scores := make(map[string]int) // 零值容量
scores2 := make(map[string]int, 64) // 预分配 64 个槽位

// 适用场景：已知大致大小，预分配可减少扩容次数
users := make(map[int]string, 1000)

3.3 nil map（未初始化）

var m map[string]int // nil map，值为 nil
fmt.Println(m) // map[]
fmt.Println(len(m)) // 0 — len 对 nil map 返回 0

3.4 C++ 对照

Go	C++
`ages := map[string]int{"Alice": 30}`	`auto ages = unordered_map<string,int>{{"Alice", 30}};`
`m := make(map[string]int)`	`auto m = unordered_map<string,int>();`
`m := make(map[string]int, 64)`	`auto m = unordered_map<string,int>(64);`
`var m map[string]int` (nil)	`unordered_map<string,int>* m = nullptr;`

四、增删改查

4.1 增 / 改（赋值）

m := map[string]int{}

// 不存在的 key → 插入
m["apple"] = 5
m["banana"] = 3

// 已存在的 key → 修改
m["apple"] = 10

fmt.Println(m) // map[apple:10 banana:3]

4.2 查（双返回值 ok 模式）

m := map[string]int{"x": 1, "y": 2}

// 双返回值：值 + 是否存在（ok 模式）
val, ok := m["x"]
fmt.Println(val, ok) // 1 true

val2, ok2 := m["z"]
fmt.Println(val2, ok2) // 0 false（零值，不存在）

// C++ 对比：
// auto it = m.find("x");
// if (it != m.end()) { /* 找到 */ }

为什么需要 ok 模式？ 如果值类型是 int，零值是 0，无法区分"值为 0"和"不存在"。ok 布尔值解决了这个问题。

包与导入

Tue, 13 Oct 2026 00:00:00 +0000

Go 的"包"是组织代码的唯一单元。一个目录就是一个包，没有头文件，没有 .cpp/.h 分离。理解包的规则，是读懂 Go 项目结构的第一步。

1. 核心概念速览

package 声明

每个 .go 文件的第一行必须是 package 声明，且同一目录下所有文件必须声明相同的包名。

// 文件: mathutil/add.go
package mathutil

// 同目录的 subtract.go 也必须是:
// package mathutil

func Add(a, b int) int { return a + b }

package main — 程序入口

package main 是特殊约定，表示可执行程序的入口，不是库包。Go 没有独立的入口函数声明——入口就是 package main 里的 func main()。

package main

import "fmt"

func main() {
 fmt.Println("Hello, Go!")
}

C++ 对照: package main ≈ 包含 int main() 的那个编译单元。

2. C++ 对照速查表

Go 概念	C++ 对应	差异说明
`package`	`namespace` + `#include`	一个 package 同时提供命名空间和导入功能，不需要头文件
`import`	`#include`	import 加载的是编译好的包，不是文本包含
首字母大写 = 导出	`public` / `protected`	基于命名规则，不是关键字；小写 = 包内可见
首字母小写 = 私有	`private`	同上，没有 `private` 关键字
一个目录一个包	一个模块/目录	同目录必须同 package，不可混装
`init()`	全局变量的构造函数	更可靠，保证在 `main()` 之前执行
`import . "fmt"`	`using namespace std;`	同样不推荐，污染命名空间
循环导入	循环 `#include`	两者都是编译错误
`internal/`	C++ 无直接对应	类似 `friend` 的简化版，限制子包的可见性
`go.mod` 依赖管理	CMake / Conan / vcpkg	Go 原生支持，无需第三方工具

3. 导入语法

单行导入

package main

import "fmt"

func main() {
 fmt.Println("单行导入")
}

分组导入（推荐）

package main

import (
 "fmt"
 "os"
 "strings" // 标准库放一组
)

func main() {
 fmt.Println(strings.Join(os.Args[1:], " "))
}

C++ 对照: Go 的 import 会自动加载包内所有导出符号，不需要逐个 include 头文件。

变量、常量与类型

Tue, 13 Oct 2026 00:00:00 +0000

从 C++ 到 Go：变量声明、常量、基本类型与类型系统的核心差异

一、简述

Go 的类型系统比 C++ 更简单、更严格：没有隐式类型转换，没有函数重载，没有模板/泛型（Go 1.18 后有泛型但用法不同）。这看似"退步"，实际上大幅降低了代码的心智负担——编译器替你做了大量约束。

对于 C++ 开发者，最需要适应的三个变化：

所有未使用的变量都会报错（unused variable）
类型转换必须显式（没有 int x = 3.14 这种事）
string 是值类型（赋值和传参都会拷贝，不像 std::string 有引用计数）

二、C++ 对照速查表

概念	C++	Go	备注
变量声明	`int x;`	`var x int`	Go 声明与赋值分离
类型推断	`auto x = 42;`	`x := 42`	`:=` = 声明 + 推断 + 赋值
常量	`const int X = 10;`	`const X = 10`	Go 常量不需要写类型
编译期常量	`constexpr int X = 10;`	`const X = 10`	Go 的 `const` 全部是编译期常量
枚举	`enum Color { RED, GREEN };`	`const ( RED = iota; GREEN )`	Go 用 `iota` 实现枚举
隐式转换	`double d = 42;`（合法）	不允许	Go 必须显式：`float64(42)`
字符串	`std::string s = "hi";`（引用语义）	`s := "hi"`（值类型）	Go string 赋值是拷贝
字符	`char c = 'A';`	`var c byte = 'A'` 或 `var c rune = 'A'`	Go 没有 `char` 类型
多变量声明	`int a, b;`	`var a, b int`	或 `a, b := 1, 2`
零值	未初始化（UB/随机值）	自动零值	Go 所有变量声明后都有零值
类型别名	`using MyInt = int;`	`type MyInt int`	Go 叫"类型定义"，不是别名
打印	`std::cout << x;`	`fmt.Println(x)`	Go 用 `fmt` 包格式化输出

三、变量声明

3.1 `var` 声明

package main

import "fmt"

func main() {
 // 基本语法：var 变量名 类型
 var name string // 声明但不赋值，零值为 ""
 var age int // 零值为 0
 var active bool // 零值为 false

 // 声明并赋值
 var score int = 100
 var lang string = "Go"

 // 类型推断：省略类型，编译器从右侧推断
 var version = 2 // 推断为 int
 var pi = 3.14 // 推断为 float64（Go 默认浮点类型）
 var greeting = "hello" // 推断为 string

 fmt.Println(name, age, active, score, lang, version, pi, greeting)
}

C++ 对照：

函数、多返回值与闭包

Tue, 13 Oct 2026 00:00:00 +0000

Go 函数的设计哲学：多返回值、闭包、defer——简洁而强大

一、函数定义

1.1 基本语法

// 格式：func 函数名(参数名 类型, ...) 返回类型
func add(a int, b int) int {
 return a + b
}

C++ 对照：

概念	C++	Go
函数定义	`int add(int a, int b)`	`func add(a int, b int) int`
类型位置	类型在前 `int a`	类型在后 `a int`
多返回值	`std::pair<T1,T2>` / `std::tuple`	直接返回 `(int, string)`
函数声明	头文件 + 源文件分离	同文件（包内导出靠大小写）

1.2 参数类型简写

相邻同类型参数可以合并：

// 两种写法等价
func calc(a int, b int, c int) int { ... }
func calc(a, b, c int) int { ... } // 更简洁

1.3 没有默认参数，没有函数重载

Go 不支持默认参数和函数重载。需要类似效果时用函数选项模式或可变参数：

// 用 Option 模式替代默认参数（后面会详细讲）
type ServerOption struct {
 Addr string
 Port int
}

// 或者更简单的做法：拆成多个函数
func NewServer(addr string) *Server { ... }
func NewServerWithPort(addr string, port int) *Server { ... }

二、多返回值

这是 Go 最核心的设计之一，C++ 没有直接对应。

环境与工具链

Tue, 13 Oct 2026 00:00:00 +0000

Go 的安装、配置与核心工具链速览

一、Go 的安装与配置

1.1 下载安装

平台	方式
Windows	下载 `.msi` 安装包：go.dev/dl
macOS	`brew install go` 或下载 `.pkg`
Linux	下载 `.tar.gz` 解压至 `/usr/local/go`

安装完成后验证：

go version
# go version go1.24.x windows/amd64

1.2 环境变量

Go 通过几个关键环境变量控制行为：

变量	作用	常用值
`GOROOT`	Go 安装目录（一般自动检测）	`/usr/local/go`
`GOPATH`	工作区目录（存放模块缓存和编译缓存）	`~/go`（默认）
`GOBIN`	`go install` 安装的可执行文件目录	`$GOPATH/bin`
`GOPROXY`	模块代理地址（国内必改）	`https://goproxy.cn,direct`
`GO111MODULE`	模块模式开关（1.16+ 默认开启）	`on`

国内加速配置（重要）：

# 永久生效（PowerShell）
go env -w GOPROXY=https://goproxy.cn,direct

# 或设置环境变量
set GOPROXY=https://goproxy.cn,direct

1.3 工作区结构（GOPATH）

GOPATH/
├── bin/ # go install 编译出的可执行文件
├── pkg/ # 编译缓存
└── src/ # [已废弃] 早期放源码，现在用 Go Modules

Go 1.16+ 不再需要把代码放在 GOPATH/src 下。使用 Go Modules 后，项目可以放在任意目录。

结构体与方法

Tue, 13 Oct 2026 00:00:00 +0000

Go 没有 class，结构体(struct) + 方法(method) 是面向对象的核心替代方案

一、C++ 对照速查表

C++ 概念	Go 对应	说明
`struct`	`struct`	默认 public，字段首字母大写才导出
`class`	`struct` + 方法	Go 没有 class 关键字
`this` 指针	Receiver（值/指针）	显式声明，名字自取
构造函数	`NewXxx()` 工厂函数	没有构造函数语法
析构函数	`defer` + `Close()`	没有析构函数语法
继承 (`is-a`)	嵌入 (`has-a`)	组合优于继承，没有继承
运算符重载	不支持	Go 刻意不提供
访问控制 `private/protected/public`	首字母大小写	大写=导出，小写=包内可见
模板/泛型	泛型（Go 1.18+）	`func F[T any](x T) T`
虚函数 / 多态	接口隐式实现	鸭子类型，无需声明 implements

二、结构体定义与零值

package main

import "fmt"

// 定义结构体：type + struct 关键字
// C++ 对比：类似 struct MyPoint { double x; double y; }; 但没有方法体
type Point struct {
 X float64 // 首字母大写 = 导出字段（其他包可访问）
 Y float64
 name string // 首字母小写 = 未导出（仅本包内可访问）
}

func main() {
 // 零值：所有字段自动初始化为各自类型的零值
 // float64 -> 0.0, int -> 0, string -> "", bool -> false, 指针/切片/map -> nil
 var p Point
 fmt.Printf("零值: %+v\n", p) // {X:0 Y:0 name:}
}

三、结构体初始化

package main

import "fmt"

type User struct {
 Name string
 Age int
 Email string
}

func main() {
 // 方式1: 字面量（最常用，推荐）
 u1 := User{Name: "张三", Age: 25, Email: "zhangsan@example.com"}
 fmt.Println(u1)

 // 方式2: 按字段名初始化（部分字段，其余为零值）
 u2 := User{Name: "李四"} // Age=0, Email=""
 fmt.Println(u2)

 // 方式3: 按顺序初始化（不推荐！字段顺序变化会导致 bug）
 u3 := User{"王五", 30, "wangwu@example.com"} // 需要 import fmt 不会用到，编译器不检查字段名
 fmt.Println(u3)

 // 方式4: new 返回指针，所有字段为零值
 u4 := new(User) // *User 类型
 u4.Name = "赵六" // Go 允许对指针直接访问字段，自动解引用
 fmt.Println(u4)

 // 方式5: 声明后再赋值
 var u5 User
 u5.Name = "钱七"
 u5.Age = 28
 fmt.Println(u5)
}

NewXxx 工厂函数（替代构造函数）

// Go 没有构造函数，惯用 NewXxx 工厂函数
func NewUser(name, email string, age int) *User {
 return &User{
 Name: name,
 Age: age,
 Email: email,
 }
}

// 使用
// u := NewUser("张三", "zhangsan@example.com", 25)
// 优点：返回指针，避免大结构体拷贝；可以做参数校验

四、结构体比较

package main

import "fmt"

type Point struct {
 X int
 Y int
}

func main() {
 a := Point{1, 2}
 b := Point{1, 2}
 c := Point{3, 4}

 // 同类型结构体可以用 == 比较（逐字段比较）
 fmt.Println(a == b) // true
 fmt.Println(a == c) // false

 // 包含不可比较字段（slice, map）的结构体不能用 ==
 // type Bad struct { Data []int }
 // var x, y Bad
 // x == y // 编译错误！slice 不能比较
}

五、方法定义

package main

import "fmt"

type Rectangle struct {
 Width float64
 Height float64
}

// 值 Receiver：操作的是副本，不会修改原值
// C++ 对比：相当于 void method() const（不能修改成员）
func (r Rectangle) Area() float64 {
 return r.Width * r.Height
}

// 指针 Receiver：操作的是原值，可以修改字段
// C++ 对比：相当于非 const 的 this 指针方法
func (r *Rectangle) SetWidth(w float64) {
 r.Width = w // 直接修改原结构体
}

// String 方法实现 fmt.Stringer 接口
func (r Rectangle) String() string {
 return fmt.Sprintf("Rectangle(%.1f x %.1f)", r.Width, r.Height)
}

func main() {
 rect := Rectangle{Width: 3, Height: 4}
 fmt.Println(rect.Area()) // 12

 rect.SetWidth(5)
 fmt.Println(rect) // Rectangle(5.0 x 4.0)

 // Go 会自动处理取地址/解引用：
 rectPtr := &Rectangle{Width: 1, Height: 2}
 rectPtr.Area() // 值方法：自动解引用 (*rectPtr).Area()
 (*rectPtr).Area() // 手动解引用，效果相同

 rect2 := Rectangle{Width: 1, Height: 2}
 rect2.SetWidth(3) // 指针方法：自动取地址 (&rect2).SetWidth(3)
}

六、值 Receiver vs 指针 Receiver

选择原则

场景	推荐 Receiver	原因
只读取，不修改字段	值 Receiver	避免不必要的拷贝开销（小结构体）
需要修改字段	指针 Receiver	必须修改原值
结构体较大	指针 Receiver	避免每次调用都拷贝
实现接口	同一类型保持一致	混用会导致方法集问题（见下文）
slice/map 字段需修改	指针 Receiver	虽然 slice 底层是引用，但语义更清晰

关键区别

type Counter struct {
 Value int
}

// 值 Receiver：操作的是拷贝
func (c Counter) IncByValue() {
 c.Value++ // 修改的是副本，原值不变！
}

// 指针 Receiver：操作的是原值
func (c *Counter) IncByPtr() {
 c.Value++ // 直接修改原值
}

func main() {
 c := Counter{Value: 0}
 c.IncByValue()
 fmt.Println(c.Value) // 0 —— 没变！

 c.IncByPtr()
 fmt.Println(c.Value) // 1 —— 变了
}

七、结构体嵌入（Embedding）—— 组合优于继承

package main

import "fmt"

// 基础结构体
type Person struct {
 Name string
 Age int
}

// 嵌入 Person —— 注意：没有字段名！
// 这不是 "Person 字段"，而是把 Person 的字段和方法"提升"到 Employee 中
type Employee struct {
 Person // 嵌入（embedding），不是字段
 Company string
 Salary float64
}

// Person 的方法也会被提升
func (p Person) Greet() string {
 return fmt.Sprintf("你好，我是 %s", p.Name)
}

// Employee 自己的方法
func (e Employee) Info() string {
 return fmt.Sprintf("%s 在 %s 工作，薪资 %.0f", e.Name, e.Company, e.Salary)
}

func main() {
 // 初始化：嵌入结构体可以逐层初始化
 emp := Employee{
 Person: Person{Name: "张三", Age: 30},
 Company: "字节跳动",
 Salary: 30000,
 }

 // 字段提升：直接访问嵌入结构体的字段
 fmt.Println(emp.Name) // "张三" —— Person 的字段被提升
 fmt.Println(emp.Age) // 30
 fmt.Println(emp.Company) // "字节跳动"

 // 方法也被提升
 fmt.Println(emp.Greet()) // "你好，我是 张三"

 // 也可以显式指定
 fmt.Println(emp.Person.Name) // "张三"
}

嵌入接口

// 结构体可以嵌入接口
type Logger interface {
 Log(msg string)
}

type Server struct {
 Logger // 嵌入接口：Server 隐式实现了 Logger
 Addr string
}

// 使用时 Server 必须给 Logger 赋值，否则调用 Log 会 panic
// srv := Server{Logger: someLoggerImpl, Addr: ":8080"}

C++ 对比：嵌入 vs 继承

流程控制: if, for, switch

Tue, 13 Oct 2026 00:00:00 +0000

Go 的流程控制关键字精简而强大——没有 while、没有 do、switch 默认不穿透

一、C++ 对照速查表

概念	C++	Go	关键区别
条件判断	`if (cond) {}`	`if cond {}`	Go 不需要括号
初始化语句	`if (int x = f(); x > 0)` (C++17)	`if x := f(); x > 0`	语法几乎等价
基本循环	`for (init; cond; post) {}`	`for init; cond; post {}`	Go 统一用 `for`
while 循环	`while (cond) {}`	`for cond {}`	Go 无 `while` 关键字
do-while	`do {} while (cond);`	`for { ...; if !cond { break } }`	Go 无 `do-while`
无限循环	`for (;;) {}`	`for {}`	Go 写法更简洁
范围遍历	`for (auto& x : vec) {}`	`for i, v := range slice {}`	`range` 可解构 key/value
switch 穿透	默认穿透（需 `break`）	默认不穿透（需 `fallthrough`）	完全相反
switch 无条件	`switch { case ...: }`	`switch { case ...: }`	两者相同
类型判断	`dynamic_cast`/`typeid`	`switch v := x.(type)`	Go 的 type switch 更优雅
延迟执行	RAII / 析构函数	`defer`	`defer` 是函数级，非作用域级
goto	`goto label;`	`goto label;`	两者几乎相同
标号跳转	`break label`（跳出循环）	`break label`（跳出标签所在的 for）	Go 标签只对 `for` 有效

二、if 语句

2.1 基本用法——不需要括号

// Go: 条件表达式不需要括号
if x > 0 {
 fmt.Println("正数")
} else if x == 0 {
 fmt.Println("零")
} else {
 fmt.Println("负数")
}

C++ 对照：if (x > 0) { ... } — Go 省略了括号，且 { 不能另起一行（编译器自动插入分号机制）。

数组与切片

Tue, 13 Oct 2026 00:00:00 +0000

Go 的序列容器：固定长度的数组与动态的切片——切片是 Go 中最常用的数据结构

一、C++ 对照速查表

C++	Go	关键差异
`std::array<T, N>`	`[N]T`	Go 数组长度是类型的一部分，`[3]int` 和 `[4]int` 是不同类型
`std::vector<T>`	`[]T`（切片）	切片是底层数组的引用/视图，不是独立容器
`vector::push_back`	`append`	append 返回新切片，必须重新赋值
`vector::size()` / `capacity()`	`len(s)` / `cap(s)`	完全对应
`vector<T>` 赋值	切片赋值	C++ vector 赋值是深拷贝；Go 切片赋值只是拷贝引用
`std::vector<T>` (值类型)	切片是引用语义	切片共享底层数组，修改会相互影响
数组 `==` 比较	`[N]T` 支持 `==`	切片不能用 `==` 比较（只能和 `nil` 比）

核心区别：C++ 的 std::vector 是一个拥有数据的容器；Go 的切片只是一个"窗口"——包含指针、长度、容量三个字段，指向某个底层数组。

二、数组 [N]T

2.1 基本语法

// 声明：长度在类型中，不可省略
var a [5]int // 零值：[0 0 0 0 0]
b := [3]string{"hello", "go", "world"} // 字面量初始化
c := [...]int{1, 2, 3} // 编译器自动推断长度 = 3

// 长度是类型的一部分：[3]int 和 [4]int 是不同类型！
// var x [3]int = [4]int{...} // 编译错误

2.2 数组是值类型（与 C++ std::array 一致）

func main() {
 a := [3]int{1, 2, 3}
 b := a // 值拷贝，b 是 a 的副本
 b[0] = 999 // 修改 b 不影响 a

 fmt.Println(a) // [1 2 3]
 fmt.Println(b) // [999 2 3]
}

2.3 数组支持 == 比较

a := [3]int{1, 2, 3}
b := [3]int{1, 2, 3}
fmt.Println(a == b) // true——长度相同、元素逐个相等即可比较

实际使用：Go 中几乎不用数组，绝大多数场景用切片。数组主要用于固定长度的场景（如 RGB 颜色 [3]byte、矩阵维度等）。

指针 (Pointers)

Tue, 13 Oct 2026 00:00:00 +0000

Go 保留了指针的核心能力（间接寻址、传地址），但砍掉了指针算术和引用类型 &T，换来内存安全和 GC 兼容。

C++ 对照速查表

概念	C++	Go	差异说明
声明指针	`int* p` / `int *p`	`var p *int`	Go 把 `` 放在类型前*
取地址	`&x`	`&x`	完全相同
解引用	`*p`	`*p`	完全相同
指针算术	`p++`, `p + n`	不支持	Go 禁止，用切片代替
空指针	`NULL` / `nullptr`	`nil`	Go 没有 NULL 关键字
引用类型	`int& ref = x`	不存在	Go 没有引用，统一用指针
new	`new int` (调用构造)	`new(int)` → `*int`	Go 的 new 只分配零值内存，不调用构造函数
struct 访问	`ptr->field`	`ptr.field`	Go 编译器自动解引用，不需要 `->`
make	无对应物	`make([]int, 5)`	仅用于 slice/map/channel，返回初始化后的值（不是指针）

1. 指针基础：&、、T

package main

import "fmt"

func main() {
 x := 42
 var p *int = &x // p 是指向 x 的指针，*int 表示"指向 int 的指针"

 fmt.Println("x 的值：", *p) // 解引用：通过指针读取值 → 42
 fmt.Println("x 的地址：", p) // 打印地址 → 0xc0000b4008（类似）

 *p = 100 // 通过指针修改原变量
 fmt.Println("修改后 x：", x) // → 100

 // 零值：指针的零值是 nil
 var q *int
 fmt.Println("q == nil:", q == nil) // → true
}

要点：*int 的 * 是类型修饰符（“int 的指针”），*p 的 * 是操作符（“解引用”）。

字符串与 Rune

Tue, 13 Oct 2026 00:00:00 +0000

Go 字符串的本质、Unicode 处理与常用操作速查

一、简述

Go 的 string 是不可变的字节序列，底层以 UTF-8 编码存储。它是一个值类型（赋值和传参都会拷贝），长度固定后不能修改。

与 C++ std::string 最大的区别：

不可变——没有 operator[] 返回引用，不能就地修改字符
UTF-8 原生支持——但 len() 返回的是字节数，不是字符数
rune 类型——用于表示单个 Unicode 码点（int32 别名）

二、C++ 对照速查表

Go	C++	说明
`string`	`std::string`	Go 是不可变值类型；C++ 可变
`rune`	`char32_t`	`rune` = `int32`，表示一个 Unicode 码点
`byte`	`uint8` / `unsigned char`	一个字节
`len(s)`	`s.size()`	Go 返回字节数，不是字符数
`s[i]`	`s[i]`	Go 返回 `byte`；C++ 返回 `char&`（可写）
`for _, r := range s`	`for (char32_t c : s)`	Go 遍历 rune；C++ 依赖编码
`strings.Builder`	`std::ostringstream`	高效字符串拼接
`strconv.Itoa(n)`	`std::to_string(n)`	整数转字符串
`strconv.Atoi(s)`	`std::stoi(s)`	字符串转整数
`strings.Contains`	`std::string::find`	判断子串是否存在
`[]byte(s)`	`reinterpret_cast`	显式转换（会拷贝数据）
没有隐式转换	`std::string` 构造	`string` 和 `[]byte` 必须显式转换

三、代码示例

3.1 string 底层：不可变字节序列

package main

import "fmt"

func main() {
 s := "Hello, 世界"
 fmt.Println("len:", len(s)) // 13（字节数！不是字符数）

 // s[0] = 'h' // 编译错误！字符串不可变

 // 底层就是字节数组的只读视图
 b := []byte(s) // 转为 []byte 后可修改
 b[0] = 'h'
 s2 := string(b) // 再转回 string
 fmt.Println(s2) // hello, 世界
}

3.2 rune 类型与 byte vs rune

package main

import "fmt"

func main() {
 s := "Go语言"

 // byte —— 字节视角
 fmt.Println("字节数:", len(s)) // 8（G=1, o=1, 语=3, 言=3）

 // rune —— 字符视角
 runes := []rune(s)
 fmt.Println("字符数:", len(runes)) // 4

 // 每个 rune 是一个 int32，代表一个 Unicode 码点
 fmt.Printf("语 的 Unicode: U+%04X\n", runes[2]) // U+8BED
}

3.3 遍历字符串：range vs 索引

package main

import "fmt"

func main() {
 s := "Hello世界"

 // 方式一：for range —— 按 rune 遍历（推荐用于字符级操作）
 fmt.Println("=== for range ===")
 for i, r := range s {
 fmt.Printf("字节索引 %d, rune: %c (U+%04X)\n", i, r, r)
 }
 // 输出：H(0), e(1), l(2), l(3), o(4), 世(5), 界(8)
 // 注意：i 是字节索引！"世"从第5字节开始，占3字节，"界"从第8字节开始

 // 方式二：for i —— 按字节遍历
 fmt.Println("=== for i (字节) ===")
 for i := 0; i < len(s); i++ {
 fmt.Printf("s[%d] = 0x%02X\n", i, s[i])
 }
 // 中文字符的字节是 0xE4 0xB8 0xAD 这样的三字节序列

 // 方式三：转为 []rune 后按索引遍历
 r := []rune(s)
 for i := 0; i < len(r); i++ {
 fmt.Printf("r[%d] = %c\n", i, r[i])
 }
}

3.4 utf8 包

package main

import (
 "fmt"
 "unicode/utf8"
)

func main() {
 s := "Go语言"

 // 获取 rune 数量（等价于 len([]rune(s)) 但更高效）
 fmt.Println("字符数:", utf8.RuneCountInString(s)) // 4

 // 验证是否为合法 UTF-8
 fmt.Println("合法 UTF-8:", utf8.ValidString(s)) // true

 // 非法 UTF-8 字节
 bad := []byte{0xCE, 0xBA, 0xE1, 0xBD, 0xB9, 0xCF, 0x83, 0xCE, 0xBC, 0xCE, 0xB5}
 fmt.Println("合法:", utf8.Valid(bad)) // false

 // RuneLen 返回某个 rune 编码后占多少字节
 fmt.Println("语 占字节:", utf8.RuneLen('语')) // 3
}

3.5 strings 包常用函数

package main

import (
 "fmt"
 "strings"
)

func main() {
 s := " Hello, Go World! "

 // 查找
 fmt.Println(strings.HasPrefix(s, " Hello")) // true
 fmt.Println(strings.HasSuffix(s, "! ")) // true
 fmt.Println(strings.Contains(s, "Go")) // true
 fmt.Println(strings.Index(s, "Go")) // 10（字节索引）

 // 裁剪
 fmt.Println(strings.TrimSpace(s)) // "Hello, Go World!"
 fmt.Println(strings.Trim(s, " !")) // "Hello, Go World"
 fmt.Println(strings.TrimLeft(s, " H")) // "ello, Go World! "
 fmt.Println(strings.TrimSuffix("test.go", ".go")) // "test"
 fmt.Println(strings.TrimPrefix("cmd/test.go", "cmd/")) // "test.go"

 // 替换
 fmt.Println(strings.Replace("aabbcc", "bb", "xx", 1)) // "aaxxcc" (只替换1次)
 fmt.Println(strings.ReplaceAll("aabbcc", "a", "x")) // "xxbbcc" (替换所有)
 fmt.Println(strings.ReplaceAll("aabbcc", "bb", "")) // "aacc" (删除子串)

 // 分割与合并
 parts := strings.Split("a,b,c", ",") // ["a", "b", "c"]
 joined := strings.Join(parts, "-") // "a-b-c"
 fmt.Println(joined)

 // 大小写
 fmt.Println(strings.ToUpper("hello")) // "HELLO"
 fmt.Println(strings.ToLower("HELLO")) // "hello"
 fmt.Println(strings.Title("hello go")) // "Hello Go" (1.18 后建议用 cases)

 // 重复与填充
 fmt.Println(strings.Repeat("ab", 3)) // "ababab"
 fmt.Println(strings.Repeat("=", 20)) // "===================="

 // 字段分割（按空白字符）
 fields := strings.Fields(" foo bar baz ")
 fmt.Println(fields) // [foo bar baz]
}

3.6 strconv 包：类型转换

package main

import (
 "fmt"
 "strconv"
)

func main() {
 // ---- 整数 ----
 // int -> string
 fmt.Println(strconv.Itoa(42)) // "42"
 fmt.Println(strconv.FormatInt(255, 2)) // "11111111" (二进制)

 // string -> int
 n, err := strconv.Atoi("42")
 if err != nil {
 fmt.Println("转换失败:", err)
 } else {
 fmt.Println(n) // 42
 }

 // 更灵活的解析
 n2, _ := strconv.ParseInt("FF", 16, 64) // 十六进制 -> int64
 fmt.Println(n2) // 255

 // ---- 布尔 ----
 b, _ := strconv.ParseBool("true")
 fmt.Println(b) // true
 fmt.Println(strconv.FormatBool(true)) // "true"

 // ---- 浮点数 ----
 f, _ := strconv.ParseFloat("3.14159", 64)
 fmt.Println(f) // 3.14159

 // 浮点数格式化
 fmt.Println(strconv.FormatFloat(3.14159, 'f', 2, 64)) // "3.14"
 fmt.Println(strconv.FormatFloat(0.15, 'f', 10, 64)) // "0.1500000000"
 fmt.Println(strconv.FormatFloat(3.14159, 'e', 4, 64)) // "3.1416e+00"
}

3.7 string 与 []byte 的转换

package main

import "fmt"

func main() {
 s := "你好世界"

 // string -> []byte（拷贝！底层数组不共享）
 b := []byte(s)
 b[0] = 'x' // 修改不影响原字符串
 fmt.Println(string(b)) // "x好世界"
 fmt.Println(s) // "你好世界"（原字符串不变）

 // string -> []rune（按字符拆分）
 r := []rune(s)
 r[0] = '我'
 fmt.Println(string(r)) // "我好世界"

 // 频繁转换的性能提示：
 // 如果需要反复读取 []byte，先转换一次再复用，不要反复转
}

3.8 字符串拼接：三种方式

package main

import (
 "fmt"
 "strings"
)

func main() {
 // ---- 方式一：+ 运算符（简单场景，少量拼接） ----
 hello := "Hello" + ", " + "World!"
 fmt.Println(hello)

 // 注意：每次 + 都会分配新内存并拷贝
 // 循环中使用 + 拼接性能差（O(n^2)）

 // ---- 方式二：strings.Builder（推荐，高效） ----
 var builder strings.Builder
 builder.Grow(100) // 预分配容量（可选但推荐）

 for i := 0; i < 10; i++ {
 builder.WriteString(fmt.Sprintf("item%d ", i))
 }
 result := builder.String()
 fmt.Println(result) // "item0 item1 item2 ... item9 "

 // 也可以用 WriteByte, WriteRune
 builder.Reset()
 builder.WriteString("Go")
 builder.WriteByte('!')
 fmt.Println(builder.String()) // "Go!"

 // ---- 方式三：strings.Join（拼接已有切片） ----
 items := []string{"apple", "banana", "cherry"}
 joined := strings.Join(items, " | ")
 fmt.Println(joined) // "apple | banana | cherry"
}

3.9 fmt.Sprintf 格式化

package main

import "fmt"

func main() {
 // 基本格式化
 fmt.Printf("整数: %d, 浮点: %f, 字符串: %s\n", 42, 3.14, "hello")

 // Sprintf 返回字符串而非打印
 s := fmt.Sprintf("年龄: %d, 成绩: %.1f%%", 18, 95.5)
 fmt.Println(s) // "年龄: 18, 成绩: 95.5%"

 // 常用格式动词
 fmt.Printf("十进制: %d\n", 255)
 fmt.Printf("八进制: %o\n", 255) // 377
 fmt.Printf("十六进制: %x\n", 255) // ff
 fmt.Printf("十六进制(大写): %X\n", 255) // FF
 fmt.Printf("二进制: %b\n", 255) // 11111111
 fmt.Printf("Unicode: %U\n", '语') // U+8BED
 fmt.Printf("字符: %c\n", 8364) // € (欧元符号)

 // 宽度与对齐
 fmt.Printf("[%10s]\n", "right") // [ right]
 fmt.Printf("[%-10s]\n", "left") // [left ]
 fmt.Printf("[%05d]\n", 42) // [00042]

 // 结构体格式化
 type Person struct {
 Name string
 Age int
 }
 p := Person{"Alice", 30}
 fmt.Printf("%+v\n", p) // {Name:Alice Age:30}
 fmt.Printf("%#v\n", p) // main.Person{Name:"Alice", Age:30}
 fmt.Printf("%T\n", p) // main.Person

 // 错误处理常用
 err := fmt.Errorf("文件 %s 不存在 (行号: %d)", "config.txt", 42)
 fmt.Println(err)
}

3.10 多行字符串

package main

import "fmt"

func main() {
 // ---- 反引号：原生字符串（推荐） ----
 // 不能包含反引号本身，不处理转义符
 raw := `
 第一行
 第二行（有缩进）
 \n 这不是换行，是字面量
 `
 fmt.Println(raw)

 // ---- 双引号 + 转义 ----
 escaped := "第一行\n第二行\n\t\t缩进\n路径: C:\\Users\\test"
 fmt.Println(escaped)

 // 反引号常用于：正则、SQL、模板、路径
 regex := `^\d{3}-\d{4}$`
 fmt.Println(regex) // 不需要转义反斜杠
}

四、常见坑

坑 1：len() 返回字节数，不是字符数

s := "你好"
fmt.Println(len(s)) // 6，不是 2！
fmt.Println(utf8.RuneCountInString(s)) // 2（正确获取字符数）

教训：涉及中文等多字节字符时，用 utf8.RuneCountInString() 或 len([]rune(s))。

基础语法 on 鹿鸣青野的blog

C++ 基础遗漏知识点：bool、sizeof、auto、nullptr 与 static

1. bool 类型与 boolalpha

核心规则

boolalpha 操纵符

常见陷阱

2. sizeof 运算符

基本用法

动态数组的 sizeof 陷阱

3. auto 关键字（C++11）

基本用法

注意事项

4. nullptr（C++11）

与 NULL 的区别

最佳实践

5. const 与 constexpr（简记）

Map（哈希表）

一、概述

二、C++ 对照速查表

三、声明与初始化

3.1 字面量初始化（最常用）

3.2 make 初始化

3.3 nil map（未初始化）

3.4 C++ 对照

四、增删改查

4.1 增 / 改（赋值）

4.2 查（双返回值 ok 模式）

包与导入

1. 核心概念速览

package 声明

package main — 程序入口

2. C++ 对照速查表

3. 导入语法

单行导入

分组导入（推荐）

变量、常量与类型

一、简述

二、C++ 对照速查表

三、变量声明

3.1 var 声明

函数、多返回值与闭包

一、函数定义

1.1 基本语法

1.2 参数类型简写

1.3 没有默认参数，没有函数重载

二、多返回值

环境与工具链

一、Go 的安装与配置

1.1 下载安装

1.2 环境变量

1.3 工作区结构（GOPATH）

结构体与方法

一、C++ 对照速查表

二、结构体定义与零值

三、结构体初始化

NewXxx 工厂函数（替代构造函数）

四、结构体比较

五、方法定义

六、值 Receiver vs 指针 Receiver

选择原则

关键区别

七、结构体嵌入（Embedding）—— 组合优于继承

嵌入接口

流程控制: if, for, switch

一、C++ 对照速查表

二、if 语句

2.1 基本用法——不需要括号

数组与切片

一、C++ 对照速查表

二、数组 [N]T

2.1 基本语法

2.2 数组是值类型（与 C++ std::array 一致）

2.3 数组支持 == 比较

指针 (Pointers)

C++ 对照速查表

1. 指针基础：&、*、*T

字符串与 Rune

一、简述

二、C++ 对照速查表

三、代码示例

3.1 `var` 声明

1. 指针基础：&、、T