Go语言中可变与不可变类型及其内存与并发考量

package main

import "fmt"

func main() {
    x := 1 // x 存储值 1
    fmt.Printf("x 的初始值: %d, 地址: %p\n", x, &x)

    x = 2 // x 存储值更新为 2
    fmt.Printf("x 重新赋值后: %d, 地址: %p\n", x, &x)
    // 观察输出，x 的地址通常保持不变，只是存储的值发生了变化
}

package main

import "fmt"

func main() {
    s1 := "hello"
    fmt.Printf("s1 的初始值: %s, 地址: %p\n", s1, &s1) // 注意：&s1 获取的是字符串头部的地址，不是实际字符数据的地址

    s2 := s1 + " world" // 拼接操作会创建一个新的字符串 s2
    fmt.Printf("s2 的值: %s, 地址: %p\n", s2, &s2)

    // s1 仍然是 "hello"，内容未变
    fmt.Printf("s1 仍然是: %s\n", s1)
}

package main

import (
    "bytes"
    "fmt"
)

func main() {
    // 使用 []byte 进行原地修改
    data := []byte("hello")
    fmt.Printf("初始 []byte: %s, 地址: %p\n", data, &data)

    data[0] = 'H' // 修改第一个字符
    fmt.Printf("修改后 []byte: %s, 地址: %p\n", data, &data)

    // 使用 bytes.Buffer 高效构建字符串
    var buffer bytes.Buffer
    for i := 0; i < 10000; i++ {
        buffer.WriteString("a")
    }
    result := buffer.String() // 只在最后一次性转换为字符串
    fmt.Printf("通过 bytes.Buffer 构建的字符串长度: %d\n", len(result))
}

package main

import "fmt"

type Point struct {
    X, Y int
}

func modifyStructByValue(p Point) {
    p.X = 100 // 修改的是 p 的副本
    fmt.Printf("函数内修改后的Point (副本): %+v\n", p)
}

func main() {
    arr := [3]int{1, 2, 3}
    arrCopy := arr // 复制整个数组
    arrCopy[0] = 99
    fmt.Printf("原始数组: %v\n", arr)       // [1 2 3]
    fmt.Printf("复制数组: %v\n", arrCopy)    // [99 2 3]

    p1 := Point{X: 1, Y: 2}
    fmt.Printf("原始Point: %+v\n", p1)
    modifyStructByValue(p1)
    fmt.Printf("函数调用后原始Point: %+v\n", p1) // 原始 p1 未被修改
}

package main

import "fmt"

func modifySlice(s []int) {
    s[0] = 100 // 修改底层数组的第一个元素
    s = append(s, 4) // append可能会导致底层数组重新分配，此时 s 将指向新的底层数组
    fmt.Printf("函数内修改后的切片: %v, 地址: %p\n", s, s) // 注意：这里的 s 可能指向新的底层数组
}

func main() {
    mySlice := []int{1, 2, 3}
    fmt.Printf("原始切片: %v, 地址: %p\n", mySlice, mySlice)

    modifySlice(mySlice)
    fmt.Printf("函数调用后原始切片: %v, 地址: %p\n", mySlice, mySlice) // 原始切片的第一个元素被修改，但 append 操作不会影响原始切片
                                                                 // 因为 append 可能会创建新的底层数组，并更新函数内局部变量 s 的头部
                                                                 // 原始 mySlice 的头部没有更新
    fmt.Println("---")

    myMap := map[string]int{"a": 1, "b": 2}
    mapCopy := myMap // 复制的是 map 的头部（指针）
    mapCopy["a"] = 10
    mapCopy["c"] = 30 // 添加新元素
    fmt.Printf("原始映射: %v\n", myMap)   // map[a:10 b:2 c:30]
    fmt.Printf("复制映射: %v\n", mapCopy) // map[a:10 b:2 c:30]
}

package main

import "fmt"

type Counter struct {
    Value int
}

// IncrementValue 使用值接收器
func (c Counter) IncrementValue() {
    c.Value++ // 修改的是 c 的副本
    fmt.Printf("IncrementValue 方法内：Value = %d\n", c.Value)
}

func main() {
    myCounter := Counter{Value: 0}
    fmt.Printf("初始 Counter: %+v\n", myCounter)

    myCounter.IncrementValue()
    fmt.Printf("调用 IncrementValue 后 Counter: %+v\n", myCounter) // Value 仍然是 0
}

package main

import "fmt"

type Counter struct {
    Value int
}

// IncrementPointer 使用指针接收器
func (c *Counter) IncrementPointer() {
    c.Value++ // 通过指针修改原始 Counter 的 Value 字段
    fmt.Printf("IncrementPointer 方法内：Value = %d\n", c.Value)
}

func main() {
    myCounter := Counter{Value: 0}
    fmt.Printf("初始 Counter: %+v\n", myCounter)

    myCounter.IncrementPointer()
    fmt.Printf("调用 IncrementPointer 后 Counter: %+v\n", myCounter) // Value 变为 1
}