Ir al tipo de datos 2

Ir al tipo de datos 2

Tipo de puntero

• Los punteros Go y C ++ están en orden inverso, vea el ejemplo:

package main

import "fmt"

func main() {
	param := 100
	var lp *int = &param
	fmt.Println("data = ", *lp)
}

• Go's * int es el int * de C ++, Go's ** int es el int ** de C ++
• La diferencia entre los punteros Go y C ++ es:

1. Go的指针没有->运算符， 通过.来调用
2. Go的空指针是如下定义的 —— var lp *int = nil

• El alcance en Go es similar a C ++, if, functions, etc.son todos un alcance, que no es lo mismo que python, por lo que el tipo de puntero puede cambiar el valor en todo el alcance, lo que también es la ventaja del tipo de puntero

Formación

• Inicialización de matriz unidimensional

var arr_1 [3]int = [3]int{1, 2, 3}
// 前后必须对应， 前面是[3], 后面也是[3],

• Inicialización de matriz bidimensional:

arr := [1][2]int{
   
   {1, 2}}


var arr [1][2]int
arr = [1][2]int{
   
   {1, 2}}
// 未初始化的元素全部被设置成0

• Los únicos operadores de comparación para matrices son == y! =, solo exactamente lo mismo es ==
• La matriz de Go se pasa por valor como un parámetro de función, que es diferente de C ++, por lo que si desea cambiarlo en una función, debe pasar un puntero
• El puntero de matriz de Go es similar a:

arr := [3]int{1, 2, 3}
var lp *[3]int = &arr
fmt.Printf("%T", lp)

Nota:
El [] de la matriz y el puntero de matriz deben corresponder, 3 está escrito en él y 3 también debe escribirse para el puntero de matriz

rebanada

• Los cortes son muy similares a los arreglos, la longitud específica escrita en [] es el arreglo y el vacío es el corte
• La forma en que se crea el corte:

arr := []int{1, 2, 3}
arr := make([]int, 2, 5) // 2是len， 5是cap容量
arr := make([]int, 2)

• La capacidad de la rebanada debe ser> = la longitud de la rebanada
• Los cortes generados a partir de la matriz afectarán la matriz subyacente

package main

import "fmt"

func main() {
	arr := [3]int{1, 2, 3}
	s := arr[0:2]  // 截取[0, 2）的切片， 容量会由系统为你指定也可以自己写
	s[0] = 10
	fmt.Println(arr)
	// 这时候就变成了10 2 3
}

• Agregar función use-es agregar nuevos elementos al final del segmento original

package main

import "fmt"

func main() {
	s := []int{}
	s = append(s, 1)
	fmt.Println(s)
}

• La función de copiar, como su nombre indica, es copiar elementos

package main

import "fmt"

func main() {
	s1 := []int{1, 1}
	s2 := []int{3, 3, 3}
	copy(s2, s1) // 把s1的元素拷贝到s2， 最后的结果为1， 1， 3
	fmt.Println(s2)
}

• El segmento como parámetro de función no se pasa por valor, afectará al segmento original

package main

import "fmt"

func change(s []int) {
	s[0] = 10
}

func main() {
	s1 := []int{1, 1}
	change(s1)
	fmt.Println(s1)// 结果是10 1
}

mapa

• El mapa de Go se puede entender por analogía con el mapa de C ++ y el dict de Python
• La creación del mapa es la siguiente: [] es la clave, seguida del valor

var mp1 map[int]int

mp2 := make(map[int]int) // 此处可以指定初始的容量cap， 但是一旦元素len超过cap会自动扩容

mp3 := map[int]int{1: 1, 2: 2}

• La clave del mapa es única y la clave no puede ser una variable con semántica de referencia, como un segmento. Debe admitir == y! =
• La operación de asignación predeterminada del mapa es crear un par clave-valor
• Cuando el mapa accede a una clave que no existe, devolverá datos v vacíos o 0 similares
• Eliminar elementos del mapa:

package main

import "fmt"

func main() {
	mp := map[int]string{1: "1", 2: "2"}
	delete(mp, 1) // 删除mp之中key为1的键值对

	fmt.Println(mp)
}

• El mapa tiene semántica de referencia, consulte el siguiente ejemplo:

package main

import "fmt"

func f(mp map[int]string) {
	delete(mp, 1)
}

func main() {
	mp := map[int]string{1: "1", 2: "2"}
	f(mp)
	fmt.Println(mp)
}

Estructura

• La definición de la estructura, renombrada con type

type Person struct {
	age int
	name string
	sex bool
}

Nota:
las variables que contiene no necesitan escribir var

• Inicialización de la estructura:

// 完全初始化， 必须写完整
var person Person = Person{10, "xiaohua", true}

// 部分初始化， 剩下的自动填充为0
person1 := Person{age:15}

• Puntero de estructura

package main

import "fmt"

type Person struct {
	age int
	name string
	sex bool
}

func main() {
	var person *Person = &Person{10, "xiaohua", true}
	fmt.Println(*person)

	person1 := &Person{age:15}
	fmt.Println(*person1)
}

• Los miembros internos de las variables de estructura y las operaciones de puntero de variable son operados por.

package main

import "fmt"

type Person struct {
	age int
	name string
	sex bool
}

func main() {
	var person *Person = &Person{10, "xiaohua", true}
	person.age = 20 // 等价于(*person).age = 20
	fmt.Println(*person)
}

• La estructura como parámetro de función se pasa por valor