Go基本语法

解释文档 1: Go 基础语法与变量声明

package main

import (
	"fmt"
	"sync"
	"time"
)

• package main：每个 Go 程序必须有一个 main 包，包含 main 函数作为程序的入口。
• import：导入标准库中的包，如 fmt、sync 和 time，用于格式化输出、同步机制以及时间处理。

Go 与 C++ 对比：

• Go 中不需要显式包含头文件，而是通过 import 直接导入包。在 C++ 中，头文件需要手动包含。

// 变量初始化的多种方式
var a int = 10         // 显式声明并初始化
b := 20                // 简短声明
var c float64          // 声明未初始化，默认值为零值
c = 30.5               // 后续赋值
var d, e = "Hello", 42 // 多变量同时初始化
const pi = 3.14        // 常量声明
fmt.Println(a, b, c, d, e, pi)

• var 和 :=：Go 支持两种变量声明方式，var 显式声明，:= 简短声明。
• 零值：未初始化的变量有默认值（如 int 为 0，float64 为 0.0）。
• const：Go 中常量使用 const 声明。
• fmt.Println：标准输出函数。

Go 与 C++ 对比：

• Go 自动为未初始化的变量赋予零值，C++ 中未初始化的变量则是未定义行为。
• Go 的简短声明 := 让代码更简洁，而 C++ 需要显式声明变量类型。

解释文档 2: 数组、切片和控制语句

// 数组和切片初始化
arr := [3]int{1, 2, 3}        // 数组，大小固定
slice := []string{"Go", "Python", "Java"} // 切片，大小可变
fmt.Println(arr, slice)

• arr 是一个数组，大小固定。
• slice 是 Go 的切片，类似于动态数组，大小可变且更灵活。

Go 与 C++ 对比：

• Go 提供了切片（slice），用于动态管理内存；C++ 使用 std::vector 达到类似效果。

// 判断语句
if a > b {
	fmt.Println("a is greater than b")
} else {
	fmt.Println("b is greater than or equal to a")
}

// switch 语句
switch e {
case 40:
	fmt.Println("e is 40")
case 42:
	fmt.Println("e is 42")
default:
	fmt.Println("e is neither 40 nor 42")
}

• if 和 switch：Go 的控制语句和 C++ 类似，不过 Go 的 switch 不需要 break，每个 case 自动终止。

Go 与 C++ 对比：

• Go 中 switch 不需要 break，简化了代码结构，而 C++ 需要显式使用 break。

// for 循环
for i := 0; i < 3; i++ {
	fmt.Printf("Loop iteration: %d\n", i)
}

// for-range 循环
for index, value := range slice {
	fmt.Printf("Index: %d, Value: %s\n", index, value)
}

• for 是 Go 唯一的循环结构，既能像 C++ 的 for 一样循环，也能像 for-each 遍历集合。

Go 与 C++ 对比：

• Go 只有 for 一种循环结构，而 C++ 还有 while 和 do-while。

解释文档 3: 结构体、接口与并发

// 定义接口
type Animal interface {
	Speak() string
}

// 定义结构体并实现接口
type Dog struct {
	Name string
	Age  int
}

func (d Dog) Speak() string {
	return "Woof!"
}

// 初始化结构体的另一种方式
type Cat struct {
	Name string
}

func (c Cat) Speak() string {
	return "Meow!"
}

• interface：Go 中的接口定义了一组方法，任何实现这些方法的类型都自动实现了该接口。
• struct：Go 中的结构体类似 C++ 中的类，但没有构造函数和继承，通过接口实现多态。

Go 与 C++ 对比：

• Go 使用接口实现多态，而 C++ 使用虚函数和继承。
• Go 没有类的概念，所有的封装通过结构体实现，C++ 则通过类（class）实现更复杂的面向对象编程。

// Goroutine 和 Channel
ch := make(chan int)

// 启动一个goroutine
go func() {
	fmt.Println("Goroutine: Sending value to channel")
	ch <- 100 // 向通道发送值
}()

// 在主 goroutine 中接收值
value := <-ch
fmt.Printf("Main Goroutine: Received value from channel: %d\n", value)

• goroutine：Go 的轻量级线程，通过 go 关键字启动。
• channel：Go 的并发原语，用于在 goroutine 之间通信。

Go 与 C++ 对比：

• Go 中的并发模型基于 CSP（通信顺序进程），通过 goroutine 和 channel 实现。C++ 则主要依赖于线程和锁机制来实现并发。

解释文档 4: 条件变量与同步机制

// 条件变量和等待机制
var wg sync.WaitGroup
var cond = sync.NewCond(&sync.Mutex{})
var sharedData = false

// 生产者函数
func producer() {
	defer wg.Done()
	time.Sleep(time.Second) // 模拟生产延迟
	cond.L.Lock()
	sharedData = true
	fmt.Println("Producer: Data produced")
	cond.Signal() // 通知等待中的消费者
	cond.L.Unlock()
}

// 消费者函数
func consumer() {
	defer wg.Done()
	cond.L.Lock()
	for !sharedData {
		fmt.Println("Consumer: Waiting for data")
		cond.Wait() // 等待生产者的通知
	}
	fmt.Println("Consumer: Data consumed")
	cond.L.Unlock()
}

func main() {
	// 启动生产者和消费者
	wg.Add(2)
	go producer()
	go consumer()

	// 等待所有 goroutine 完成
	wg.Wait()
	fmt.Println("Program finished.")
}

• sync.WaitGroup：用于等待一组 goroutine 完成。
• sync.Cond：条件变量，用于协调多个 goroutine 之间的同步操作。
• producer 和 consumer：模拟了经典的生产者-消费者模式，通过条件变量和锁来协调同步。

Go 与 C++ 对比：

• Go 的 sync.Cond 类似于 C++ 的条件变量（std::condition_variable），但 Go 的 goroutine 更轻量化，容易实现大规模并发。
• WaitGroup 提供了简单的等待 goroutine 完成的机制，而 C++ 通常使用 std::thread 和 std::future 等配合使用。