Golang学习day4 变量数组指针的学习

局部全局变量引用顺序
如果同时有局部变量和全局变量而且名称相同，函数内的局部变量会被优先考虑
形式参数会作为函数的局部变量来使用，即一个函数结果返回的参数值
默认值
数据类型初始化默认值
int 0
float32 0
pointer nil
形式参数不改变原有属性的值
数组
1.声明数组 var name [size] type
var arr2 [10] float32
数组初始化
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
数组可以不指定大小

var balance = […]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
数组取值 var salary float32 = balance[9]
多维数组 var name [1][2][3][4] type
二维数组初始化

a = [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11},   /* 第三行索引为 2 */
}

指针
var var_name *var-type

   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */
 /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )

GO空指针
当一个指针被定义后没有分配到任何变量时，它的值为 nil。
nil 指针也称为空指针。
nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。
一个指针变量通常缩写为 ptr

空指针判断if(ptr != nil) /* ptr 不是空指针 */ if(ptr == nil) /* ptr 是空指针 */

指针数组var ptr [MAX]*int;

 a := []int{10,100,200}
   var i int
   var ptr [MAX]*int;

   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] )
   }
输出：   a[0] = 10
        a[1] = 100
        a[2] = 200

GO指向指针的指针
如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。

当定义一个指向指针的指针变量时，第一个指针存放第二个指针的地址，第二个指针存放变量的地址：
声明 var ptr **int;

var a int
   var ptr *int
   var pptr **int

   a = 3000

   /* 指针 ptr 地址 */
   ptr = &a

   /* 指向指针 ptr 地址 */
   pptr = &ptr

   /* 获取 pptr 的值 */
   fmt.Printf("变量 a = %d\n", a )
   fmt.Printf("指针变量 *ptr = %d\n", *ptr )
   fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
   输出结果都是3000

go语言指针作为函数参数

func main() {
   /* 定义局部变量 */
   var a int = 100
   var b int= 200

   fmt.Printf("交换前 a 的值 : %d\n", a )
   fmt.Printf("交换前 b 的值 : %d\n", b )

   /* 调用函数用于交换值
   * &a 指向 a 变量的地址
   * &b 指向 b 变量的地址
   */
   swap(&a, &b);

   fmt.Printf("交换后 a 的值 : %d\n", a )
   fmt.Printf("交换后 b 的值 : %d\n", b )
}

func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保存 x 地址的值 */
   *x = *y      /* 将 y 赋值给 x */
   *y = temp    /* 将 temp 赋值给 y */
}
更简洁的交换函数

func swap(x *int, y *int){
    *x, *y = *y, *x
}

Golang学习day4 变量 数组 指针 的学习

猜你喜欢

Golang学习day4 变量数组指针的学习