SRE文档

深浅模式

1.golang指针 ​

Go语言中的函数传参都是值拷贝，当我们想要修改某个变量的时候，我们可以创建一个指向该变量地址的指针变量。传递数据使用指针，而无需拷贝数据。

类型指针不能进行偏移和运算

Go语言中的指针操作非常简单，只需要记住两个符号：&(取地址)和*(根据地址取值)

Go 语言虽然保留了指针，但与其他编程语言不同的是：

  • 默认值 nil，没有 NULL 常量。
  • 操作符"&"取变量地址，"*"通过指针访问目标对象。
  • 不支持指针运算，不支持"->"运算符，直接用"."访问目标成员。

1.0 内存地址 ​

内存地址：在声明变量时，会在计算机内存中申请一个位置，用于存储、修改和获取变量的值，这个位置被称为内存地址内存地址使用十六进制表示。

1.1 指针地址和指针类型 ​

每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。Go语言中使用&字符放在变量前面对变量进行取地址操作。Go语言中的值类型(int、float、bool、string、array、struct)都有对应的指针类型。如：*int、*int64、*string等。

1.2 指针语法 ​

一个指针变量指向了一个值的内存地址。（也就是我们声明了一个指针之后，可以像变量赋值一样，把一个值的内存地址放入到指针当中）

类似于变量和常量，在使用指针前你需要声明指针。格式如下：

go
var var_name *var-type

var-type --->为指针类型
var_name ---> 指针变量
* ---> 用于指定变量是作为一个指针
var var_name *var-type

var-type --->为指针类型
var_name ---> 指针变量
* ---> 用于指定变量是作为一个指针
go
package main

import "fmt"

func main() {
	var sp *string
	var s string = "hello"
	//把s赋值给sp
	sp = &s
	fmt.Printf("sp: %v\n", sp)
	fmt.Printf("sp: %v\n", *sp) //取值
}
package main

import "fmt"

func main() {
	var sp *string
	var s string = "hello"
	//把s赋值给sp
	sp = &s
	fmt.Printf("sp: %v\n", sp)
	fmt.Printf("sp: %v\n", *sp) //取值
}

2.golang指向数组的指针 ​

  • 语法，---->指向的是数组中的元素
go
var ptr [MAX]*int; 表示数组里面的元素的类型是指针类型

MAX--->变量
var ptr [MAX]*int; 表示数组里面的元素的类型是指针类型

MAX--->变量
go
const MAX = 3

func main() {
	a := []int{1, 2, 3}
	var ptr [MAX]*int
	fmt.Println(ptr)
	for i := 0; i < MAX; i++ {
		ptr[i] = &a[i]
	}
	for i := 0; i < MAX; i++ {
		fmt.Printf("a[%d]= %d\n", i, *ptr[i])
	}
}
const MAX = 3

func main() {
	a := []int{1, 2, 3}
	var ptr [MAX]*int
	fmt.Println(ptr)
	for i := 0; i < MAX; i++ {
		ptr[i] = &a[i]
	}
	for i := 0; i < MAX; i++ {
		fmt.Printf("a[%d]= %d\n", i, *ptr[i])
	}
}

3. 指针函数传参 ​

go
package main

import "fmt"

func updateInt(a int) {
	a = 100
}

func updateIntByPointer(a *int) {
	*a = 100
}

func main() {
	a := 10
	// 每个变量有2层含义，变量的内存和变量的地址

	fmt.Println("a的值:", a)     // a,变量的内存，也就是存在内存当中的内容
	fmt.Println("a的内存地址:", &a) //&a,变量的地址，也就是内存所在内存当中的位置，也叫指针

	// 语法糖声明
	// sp 是一个指针变量，存储的是a的内存地址
	sp := &a
	fmt.Println("sp的值:", sp)
	fmt.Println("sp的内存地址:", &sp)

	// // 声明整数指针
	// var p *int
	// fmt.Println("p的值:", p) // 没有初始化,默认值是nil
	// p = &a
	// fmt.Println("p的值:", p)
	// fmt.Println("p的内存地址:", &p)

	// *p = 666 //*p操作的不是p的内存，是p所指向的内存(就是a)
	// fmt.Println("p的值:", *p)
	updateInt(a)
	fmt.Println("updateInt后a的值:", a)
	updateIntByPointer(&a)
	fmt.Println("真正修改后a的值:", a)
}
package main

import "fmt"

func updateInt(a int) {
	a = 100
}

func updateIntByPointer(a *int) {
	*a = 100
}

func main() {
	a := 10
	// 每个变量有2层含义，变量的内存和变量的地址

	fmt.Println("a的值:", a)     // a,变量的内存，也就是存在内存当中的内容
	fmt.Println("a的内存地址:", &a) //&a,变量的地址，也就是内存所在内存当中的位置，也叫指针

	// 语法糖声明
	// sp 是一个指针变量，存储的是a的内存地址
	sp := &a
	fmt.Println("sp的值:", sp)
	fmt.Println("sp的内存地址:", &sp)

	// // 声明整数指针
	// var p *int
	// fmt.Println("p的值:", p) // 没有初始化,默认值是nil
	// p = &a
	// fmt.Println("p的值:", p)
	// fmt.Println("p的内存地址:", &p)

	// *p = 666 //*p操作的不是p的内存，是p所指向的内存(就是a)
	// fmt.Println("p的值:", *p)
	updateInt(a)
	fmt.Println("updateInt后a的值:", a)
	updateIntByPointer(&a)
	fmt.Println("真正修改后a的值:", a)
}