escribir delante

Bueno, aprendiendo GO, así que con este artículo
El contenido de la publicación del blog es 《GO语言实战》una de las notas de lectura.
Principalmente relacionado con el conocimiento relacionado con la matriz

A excepción de tus padres, nadie en el mundo debería tratarte bien. ——La Ópera de los Príncipes de Fenghuo "Sword Comes"

Implementación interna y funciones básicas de arreglos

Las matrices están en GOarmonía, 切片y los amigos que 映射han 基础数据结构aprendido otros idiomas deberían estar familiarizados con las matrices. Básicamente todos los lenguajes tienen el concepto de arreglos.

数组（Array）es una 线性estructura de datos. Utiliza un conjunto 连续de 内存空间, para almacenar un conjunto de 相同类型的数据.

Implementación interna

En el Golenguaje, una matriz es un tipo de datos de longitud fija que se utiliza para almacenar un bloque contiguo de elementos del mismo tipo. El tipo almacenado por la matriz puede ser un tipo integrado, como 整型or 字符串o algo 结构类型.

Las matrices se asignan de forma contigua debido a la memoria que ocupan. La CPU puede almacenar en caché los datos en uso durante períodos de tiempo más prolongados. Y la memoria es contigua y es fácil calcular el índice, que puede iterar rápidamente sobre todos los elementos de la matriz. La información de tipo de una matriz puede proporcionar la distancia que debe moverse en la memoria cada vez que se accede a un elemento.

Mi comprensión personal de la oración anterior:

Estructura de matriz 内存连续分配, por lo que es fácil 计算索引(dirección relativa de elementos), 等差数列y al mismo tiempo 内存连续, se puede usar muy CUP的缓存bien.Al CPUacceder 首地址, se cargará automáticamente 从内存中加载当前数组其他元素到CUP Cache, y se determina cuánto se carga CPU Cache Line, por lo que CPUlos datos en uso pueden almacenarse en caché durante más tiempo. Cuando la memoria es discontinua, no se puede leer , y los elementos de datos solo se pueden leer de la memoria repetidamente, y las funciones CPU Cacheno se pueden utilizar por completo .CPU Cache
Los elementos de la matriz se pueden iterar rápidamente por índice.Si a representa la primera dirección de la matriz, a[0]es la posición del desplazamiento 0, es decir, la primera dirección, que representa la posición del a[k]desplazamiento , por lo que la dirección de memoria calculada solo necesita use esta fórmula , para que la dirección de memoria se pueda iterar rápidamente a través de la confirmación del índice, y el grado de replicación de tiempo teórico es de nivel constante.ktype_sizea[k]a[k]_address = base_address + k * type_size

declaración e inicialización

声明数组Cuando necesite especificar los datos almacenados internamente 类型y los elementos que deben almacenarse数量

Declarar una matriz y establecerla en valor cero

var arrays [5]int

Declarar una matriz usando un literal de matriz

arrays := [5]int{
    
    10,12,13}

Vamos a calcular Goautomáticamente la longitud de la matriz declarada

array := [...]int{
    
    10, 20,30, 40, 50}

Declare la matriz y especifique el valor de un elemento específico, inicialice el elemento con índice 1y con el valor específico2

array := [5]int{
    
    1: 10, 2: 20}

usar una matriz

El diseño de la memoria es continuo, por lo que la matriz es una estructura de datos muy eficiente.Al acceder a cualquier elemento de la matriz, utilice []el operador

acceder a los elementos de la matriz

//声明一个包含 5 个元素的整型数组
array := [5]int{
    
    10, 20, 30, 40, 50}
// 修改索引为 2 的元素的值
array[2] = 35

声明一个所有元素都是指针的数组. *运算符Puede acceder al valor señalado por el puntero del elemento usando

acceder a un elemento de una matriz de punteros

// 声明包含 5 个元素的指向整数的数组
// 用整型指针初始化索引为 0 和 1 的数组元素
array := [5]*int{
    
    0: new(int), 1: new(int)}
// 为索引为 0 和 1 的元素赋值
*array[0] = 10
*array[1] = 20

En el Goidioma , una matriz es un valor. Esto significa que las matrices se pueden usar en operaciones de asignación. El nombre de la variable representa la matriz completa y una matriz del mismo tipo se puede asignar a otra matriz.

// 声明第一个包含 5 个元素的字符串数组
var array1 [5]string
// 声明第二个包含 5 个元素的字符串数组
// 用颜色初始化数组
array2 := [5]string{
    
    "Red", "Blue", "Green", "Yellow", "Pink"}
// 把 array2 的值复制到 array1
array1 = array2

El compilador evitará que las matrices de diferentes tipos se asignen entre sí

package main

import "fmt"

func main() {
    
    
        fmt.Println("你好，世界")
        // 声明第一个包含 4 个元素的字符串数组
        var array1 [4]string

        // 声明第二个包含 5 个元素的字符串数组
        // 使用颜色初始化数组
        array2 := [5]string{
    
    "Red", "Blue", "Green", "Yellow", "Pink"}

        // 将 array2 复制给 array1
        array1 = array2
}

go vetuna examinacion

┌──[[email protected]]-[/usr/local/go/src/demo]
└─$go fmt array.go
array.go
┌──[[email protected]]-[/usr/local/go/src/demo]
└─$vim array.go
┌──[[email protected]]-[/usr/local/go/src/demo]
└─$go vet array.go
# command-line-arguments
vet: ./array.go:15:11: cannot use array2 (variable of type [5]string) as [4]string value in assignment
┌──[[email protected]]-[/usr/local/go/src/demo]
└─$

Matrices multidimensionales

Los arreglos en sí solo tienen una dimensión, pero puede combinar varios arreglos para crear arreglos multidimensionales. Las matrices multidimensionales facilitan la gestión de datos con relaciones padre-hijo o datos asociados con sistemas de coordenadas

declarar una matriz bidimensional

// 声明一个二维整型数组，两个维度分别存储 4 个元素和 2 个元素
var array [4][2]int
// 使用数组字面量来声明并初始化一个二维整型数组
array := [4][2]int{
    
    {
    
    10, 11}, {
    
    20, 21}, {
    
    30, 31}, {
    
    40, 41}}
// 声明并初始化外层数组中索引为 1 个和 3 的元素
array := [4][2]int{
    
    1: {
    
    20, 21}, 3: {
    
    40, 41}}
// 声明并初始化外层数组和内层数组的单个元素
array := [4][2]int{
    
    1: {
    
    0: 20}, 3: {
    
    1: 41}}

acceder a los elementos de una matriz bidimensional

// 声明一个 2×2 的二维整型数组
var array [2][2]int
// 设置每个元素的整型值
array[0][0] = 10

Las matrices multidimensionales se pueden asignar entre sí siempre que los tipos sean los mismos

// 声明两个不同的二维整型数组
var array1 [2][2]int
var array2 [2][2]int
// 为每个元素赋值
array2[0][0] = 10
array2[0][1] = 20
array2[1][0] = 30
array2[1][1] = 40

Asignación de matriz multidimensional del mismo tipo

// 将 array2 的值复制给 array1
array1 = array2

Use el índice para asignar valor a una matriz multidimensional

// 将 array1 的索引为 1 的维度复制到一个同类型的新数组里
var array3 [2]int = array1[1]
// 将外层数组的索引为 1、内层数组的索引为 0 的整型值复制到新的整型变量里
var value int = array1[1][0]

Pasar arreglos entre funciones

Pasar arreglos entre funciones es una operación costosa en términos de memoria y rendimiento. 在函数之间传递变量时，总是以值的方式传递的. Si la variable es una matriz, significa que toda la matriz, sin importar cuánto tiempo, se copiará en su totalidad y se pasará a la función.

Use pass-by-value para pasar matrices grandes entre funciones

// 声明一个需要 8 MB 的数组,创建一个包含 100 万个 int 类型元素的数组
var array [1e6]int
// 将数组传递给函数 foo
foo(array)
// 函数 foo 接受一个 100 万个整型值的数组
func foo(array [1e6]int) {
    
    
...
}

Memoria que se debe asignar en la pila cada vez que foose llama a una función8 MB

Hay una manera mejor y más eficiente de manejar esta operación. Simplemente puede pasar un puntero a la matriz, por lo que solo necesita copiar 8los bytes de datos en lugar 8 MBde los datos de memoria a la pila

Use punteros para pasar grandes arreglos entre funciones

// 分配一个需要 8 MB 的数组
var array [1e6]int
// 将数组的地址传递给函数 foo
foo(&array)
// 函数 foo 接受一个指向 100 万个整型值的数组的指针
func foo(array *[1e6]int) {
    
    
...
}

Para pasar la dirección de la matriz a la función, simplemente asigne 8 bytes de memoria en la pila al puntero.

Implementación interna y funciones básicas de arreglos en Go language combat