为了更好地理解 Go 语言中的 切片（slice），我们可以将它与 C++ 中的数组或容器（如 std::vector）进行比较，但要注意的是，它们之间有一些关键的区别。让我们逐步将 Go 的切片与 C++ 中的概念进行对应：
1. 数组 vs 切片
在 C++ 中，数组（array） 是一种固定大小的数据结构，大小必须在编译时确定，并且不能动态调整。例如：
int arr[5] = {1, 2, 3, 4, 5}; // C++ 中的静态数组，大小为5
Go 语言中的 数组 也是固定大小的，一旦定义，其长度是不可变的。例如：
var arr [5]int = [5]int{1, 2, 3, 4, 5} // Go中的数组，大小为5
但是 Go 中的 切片（slice） 是一种动态、可变长度的结构，相当于在 C++ 中使用 std::vector。Go 的切片是对底层数组的引用，可以在运行时动态调整大小。
2. 切片 vs std::vector
C++ 中的 std::vector 与 Go 语言中的 切片（slice） 比较类似。两者都提供了可变长度的数组功能，并且它们都可以动态增加或缩小。
- C++ 中的
std::vector：
#include <vector>
std::vector<int> vec = {1, 2, 3, 4, 5}; // C++ 中的动态数组
vec.push_back(6); // 动态增加元素
- Go 中的 切片：
slice := []int{1, 2, 3, 4, 5} // Go 中的切片
slice = append(slice, 6) // 动态增加元素
在 C++ 中，std::vector 可以动态调整大小，并自动管理底层内存。同样地，Go 的切片也可以通过 append 函数动态增加元素。就像 std::vector 可以在其容量不足时自动分配更多内存，Go 的切片也是如此。
3. 长度和容量
-
在 C++ 的
std::vector中，容量（capacity）指的是分配的内存空间大小，可以容纳的元素数量，而长度（size）指的是实际存储的元素个数。std::vector<int> vec = {1, 2, 3}; int size = vec.size(); // 当前存储的元素个数，输出: 3 int capacity = vec.capacity(); // 分配的内存容量 -
在 Go 中，切片也有类似的概念：
- 长度（len）：切片中实际包含的元素个数。
- 容量（cap）：从切片的起始位置到底层数组末尾的元素数量。
slice := []int{1, 2, 3} fmt.Println(len(slice)) // 输出：3 fmt.Println(cap(slice)) // 输出：3
当向 std::vector 或切片追加元素时，容量不足时会重新分配更大的内存空间。
4. 底层数组和内存共享
在 C++ 中，当你操作 std::vector 时，通常是一个独立的内存块，每次操作都不会影响到其他 vector。然而，在 Go 中，切片是共享底层数组的。如果从一个数组或切片中创建另一个切片，多个切片可以共享同一底层数组。这与 C++ 的数组指针类似。
例如，假设我们有一个 C++ 的数组指针：
int arr[] = {1, 2, 3, 4, 5};
int* ptr = arr + 1; // 指向数组的第二个元素
ptr[0] = 100; // 修改数组
这种情况下，修改 ptr 所指向的内容会影响到原始数组。
在 Go 中，切片共享底层数组的特性与此类似：
arr := [5]int{1, 2, 3, 4, 5}
slice1 := arr[1:4] // 创建一个从索引1到3的切片
slice1[0] = 100 // 修改 slice1 的第一个元素，影响了底层数组
fmt.Println(arr) // 输出: [1 100 3 4 5]
5. append 函数的行为
当我们在 Go 中向切片追加元素时，底层数组的容量可能会重新分配。当容量不足时，Go 会创建一个新的底层数组，并将现有的数据复制过去，这与 C++ 中 std::vector 的扩容机制类似。
- 在 C++ 中，当
std::vector容量不足时，会自动分配更多内存，现有元素会被复制到新的内存空间中。 - 在 Go 中，
append可能会导致重新分配底层数组，类似地也会将现有数据复制到新的数组中。
std::vector<int> vec = {1, 2, 3};
vec.push_back(4); // 如果容量不足，重新分配内存
Go 中的对应逻辑：
slice := []int{1, 2, 3}
slice = append(slice, 4) // 如果容量不足，重新分配底层数组
6. C++ 中的指针 vs Go 中的切片
在 C++ 中，如果你通过指针操作数组的部分元素，或者传递数组指针到函数内，这种行为类似于 Go 中的切片。例如：
- C++ 中通过指针操作数组：
void modifyArray(int* arr) {
arr[0] = 100;
}
int main() {
int arr[] = {1, 2, 3};
modifyArray(arr);
// arr[0] 现在是 100
}
- 在 Go 中，切片类似于数组的引用，因此可以在函数中直接修改底层数组：
func modifySlice(s []int) {
s[0] = 100
}
func main() {
arr := []int{1, 2, 3}
modifySlice(arr)
fmt.Println(arr) // 输出: [100 2 3]
}
7. 总结：C++ vs Go 切片理解
- 切片与 C++ 的
std::vector相似，因为两者都可以动态扩展，并且容量和长度是分开的概念。 - 切片共享底层数组，类似于在 C++ 中通过指针访问数组的某部分，多个切片可以引用同一块内存。
- Go 切片的追加操作（
append）与 C++ 中std::vector的扩容机制类似，当容量不足时，会自动分配新的更大的底层数组。 - 切片的指针行为 类似于 C++ 中通过指针操作数组元素的方式。
理解这些相似点和不同点，可以帮助你更快适应 Go 的切片操作，特别是在你熟悉 C++ 的数组和 std::vector 时。