标签：name int fmt day04 Println Go age 指针

Go基础语法

指针

指针式存储另一个变量内存地址的变量

&a 取出a的内存地址
*b 若指针b存放的式a的地址 那么 *b就直接指向a的内存 可以直接操作其中的值

指针的使用

func main() {
   //声明一个变量
   var a int = 8
   fmt.Println("a的值=", a)
   fmt.Println("a的地址=", &a)
   //声明一个指针的变量
   var p *int
   p = &a //变量a的地址赋予指针p
   fmt.Printf("p本身的地址：%p\n", &p)
   fmt.Printf("p存储的地址：%p\n", p)
   fmt.Println("*p变量的值：", *p)

   //因为指针p存储的是变量a的地址 所以操作*p就是操作变量a的自动hi
   *p += 2
   fmt.Println(a, *p)

   a++
   fmt.Println(a, *p)

   //再定义一个指针 指向p
   var p2 **int
   p2 = &p
   fmt.Printf("p2自己的地址：%p\n", &p2)
   fmt.Printf("p2存放的地址：%p\n", p2) //是指针p本身的地址
   fmt.Println(*p2)                    //是指针变量p存放的值
   fmt.Println(**p2)                   //是指针变量p存放的值的指向 即变量a的值

}

数组与指针

数组指针：一个指针变量，存放一个数组的地址

指针数组：一个数组，存放的是变量的地址

func main() {
   //数组指针
   arr := [3]int{1, 2, 3}

   var p *[3]int
   p = &arr
   fmt.Printf("p的地址:%p\n", &p)
   fmt.Printf("p指向的地址:%p\n", p)
   fmt.Printf("arr的地址:%p\n", &arr)
   fmt.Println("*p的值:", *p)

   (*p)[0] = 100 //(*p)就相当于arr了
   fmt.Println(arr)
   fmt.Println(*p)
   //*p可以之间简化为p
   p[0] = 200
   fmt.Println(arr)
   fmt.Println(*p)

   fmt.Println("=====================")
   //指针数组
   a := 1
   b := 2
   c := 3
   var arr2 = [3]*int{&a, &b, &c}
   fmt.Println(arr2)

   //可以通过指针数组直接修改原变量了
   *arr2[0] = 100
   fmt.Println(arr2)
   fmt.Println(a)

   b = 200
   fmt.Println(*arr2[1])

}

指针函数

func main() {
   p := test()
   fmt.Printf("p的类型是：%T\n", p)
   fmt.Println("p的地址：", &p)
   fmt.Println("p指针指向的值：", *p)

   fmt.Println(p[0])

   a := 10
   fmt.Println("a=", a)
   test2(&a)
   fmt.Println("a=", a)

}

// 可以返回一个指针从而操作函数中的变量
func test() *[4]int {
   arr := [4]int{1, 2, 3, 4}
   return &arr
}

// 指针可以作为参数传入函数 进而进行操作
func test2(p *int) {
   fmt.Println("p", p)
   fmt.Println("p=", *p)
   *p = 100
}

结构体

结构体是由一系列具有相同类型或不同类型变量数据构成的数据集合

语法：

type name struct{}
name的大小写与权限有关

name首字母小写结构体不会被导出，只能自己使用
name首字母大写可以被导出，但只能被使用大写首字母的属性
嵌套结构体无论怎么样都可以被访问大写首字母的属性

/*
   结构体
      一般哟用来封装一类事物的变量，比如一个人的相关信息
*/
//结构体名字大小写与权限有关
type User struct {
   name string
   age  int
   sex  string
}

func main() {
   //创建结构体对象
   var u1 User
   fmt.Println(u1) //{0}
   u1.name = "zhangsan"
   u1.age = 18
   u1.sex = "男"

   fmt.Println(u1)
   fmt.Println(u1.name)
   fmt.Println(u1.age)
   fmt.Println(u1.sex)

   //创建空对象再复制
   u2 := User{}
   u2.name = "lisi"
   u2.age = 16
   u2.sex = "男"
   fmt.Println(u2)

   u3 := User{
      name: "wangwu",
      age:  12,
      sex:  "男",
   }
   fmt.Println(u3)

   //这样赋值需要和定于的属性顺序一致
   u4 := User{"zhaoliu", 18, "女"}
   fmt.Println(u4)
}

结构体是值类型的

type Stu struct {
   name string
   age  int
   sex  int
}

func main() {
   s1 := Stu{"xue", 18, 0}
   fmt.Println(s1)

   s2 := s1
   s2.name = "evan"
   fmt.Println(s1)
   fmt.Println(s2)
   //结构体是值传递

   //可以通过指针用s3操作s1
   var s3 *Stu
   s3 = &s1
   //s3.name = "lisi"
   (*s3).name = "lisi"
   //*可以省略 因为s3就代表着s1，不过要记得看清楚代表的是谁
   fmt.Println(s1)

   //使用new也可以创建一个指针对象
   //这样s4就是一个引用类型的了
   s4 := new(Stu)
   fmt.Printf("%T\n", s4)
   s4.name = "nihao"
   s4.age = 8
   s4.sex = 1
   fmt.Println(s4)

}

匿名结构体

type Stud struct {
   name string
   age  int
}

//匿名字段的结构体
type Tea struct {
   string
   int
}

func main() {
   s1 := Stud{"xue", 18}
   fmt.Println(s1.name)

   //匿名结构体
   s2 := struct {
      name string
      age  int
   }{"xiaoming",
      14}
   fmt.Println(s2.name)

   //慎用 不好分辨对象的意义，多个匿名字段怎么分别
   t1 := Tea{"tt", 35}
   fmt.Println(t1.int)
}

结构体嵌套

type Person struct {
   name string
   age  int
   //结构体嵌套
   addr Address
}

type Address struct {
   city, state string
}

func main() {
   p1 := Person{}
   p1.name = "yellow"
   p1.age = 5000
   p1.addr = Address{
      city:  "zhonghua",
      state: "huaxia",
   }

   fmt.Println(p1)
   fmt.Println(p1.addr)
   fmt.Println(p1.addr.city)

}

标签：name,int,fmt,day04,Println,Go,age,指针
From： https://www.cnblogs.com/onlyxue/p/16878039.html

Go_day04