数组,结构体

数组

package main

import "fmt"

func main() {
   var n [10]int /* n 是一个长度为 10 的数组 */
   var i,j int

   /* 为数组 n 初始化元素 */         
   for i = 0; i < 10; i++ {
      n[i] = i + 100 /* 设置元素为 i + 100 */
   }

   /* 输出每个数组元素的值 */
   for j = 0; j < 10; j++ {
      fmt.Printf("Element[%d] = %d\n", j, n[j] )
   }
}

　　使用数组打印杨辉三角

package main
import "fmt"
func GetYangHuiTriangleNextLine(inArr []int) []int {
    var out []int    //不写数组长度，Go 语言会根据元素的个数来设置数组的大小
    var i int
    arrLen := len(inArr)
    out = append(out, 1)
    if 0 == arrLen {
        return out
    }
    for i = 0; i < arrLen-1; i++ {
        out = append(out, inArr[i]+inArr[i+1])
    }
    out = append(out, 1)
    return out
}
func main() {
    nums := []int{}
    var i int
    for i = 0; i < 10; i++ {
        nums = GetYangHuiTriangleNextLine(nums)
        fmt.Println(nums)
    }
}

　　数组作为参数,传递给函数

package main

import "fmt"

func main() {
   /* 数组长度为 5 */
   var  balance = []int {1000, 2, 3, 17, 50}
   var avg float32

   /* 数组作为参数传递给函数 */
   avg = getAverage( balance, 5 ) ;

   /* 输出返回的平均值 */
   fmt.Printf( "平均值为: %f ", avg );
}
func getAverage(arr []int, size int) float32 {
   var i,sum int
   var avg float32  

   for i = 0; i < size;i++ {
      sum += arr[i]
   }

   avg = float32(sum) / float32(size)

   return avg;
}

　　二维数组

package main

import "fmt"

func main() {
   /* 数组 - 5 行 2 列*/
   var a = [5][2]int{ {0,0}, {1,2}, {2,4}, {3,6},{4,8}}
   var i, j int

   /* 输出数组元素 */
   for  i = 0; i < 5; i++ {
      for j = 0; j < 2; j++ {
         fmt.Printf("a[%d][%d] = %d\n", i,j, a[i][j] )
      }
   }
}

　　指针

package main

import "fmt"

func main() {
   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */

   fmt.Printf("a 变量的地址是: %x\n", &a  )

   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量储存的指针地址: %x\n", ip )

   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )
}

　　指向指针的指针

package main

import "fmt"

func main() {

   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)
}

　　向函数中传递指针

package main

import "fmt"

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

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

/* 交换函数这样写更加简洁，也是 go 语言的特性，可以用下，c++ 和 c# 是不能这么干的 */
 
func swap(x *int, y *int){
    *x, *y = *y, *x
}

　　结构体(Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型)

结构体作为函数参数

package main

import "fmt"

type Books struct {
   title string
   author string
   subject string
   book_id int
}

func main() {
   var Book1 Books        /* 声明 Book1 为 Books 类型 */
   var Book2 Books        /* 声明 Book2 为 Books 类型 */

   /* book 1 描述 */
   Book1.title = "Go 语言"
   Book1.author = "www.runoob.com"
   Book1.subject = "Go 语言教程"
   Book1.book_id = 6495407

   /* book 2 描述 */
   Book2.title = "Python 教程"
   Book2.author = "www.runoob.com"
   Book2.subject = "Python 语言教程"
   Book2.book_id = 6495700

   /* 打印 Book1 信息 */
   printBook(Book1)

   /* 打印 Book2 信息 */
   printBook(Book2)
}

func printBook( book Books ) {
   fmt.Printf( "Book title : %s\n", book.title);
   fmt.Printf( "Book author : %s\n", book.author);
   fmt.Printf( "Book subject : %s\n", book.subject);
   fmt.Printf( "Book book_id : %d\n", book.book_id);
}

　　

结构体指针

package main

import "fmt"

type Books struct {	//定义结构体
	title string
	author string
	subject string
	book_id int
}

func main() {
	var Book1 Books        /* Declare Book1 of type Book,声明Book变量 */


	/* book 1 描述 */
	Book1.title = "Go 语言"
	Book1.author = "www.runoob.com"
	Book1.subject = "Go 语言教程"
	Book1.book_id = 6495407

	//或者直接这样写
	var Book2=Books{title: "Go 语言", author: "www.runoob.com", subject: "linux语言教程", book_id: 6495407}

	printBook(&Book1)  //这里给printBook函数传递的参数是结构体对象Book1的地址,函数接收的参数应该是个指针

	printBook(&Book2)

}
func printBook( book *Books ) {  //这里*Books规定这里的参数类型是指针
	fmt.Printf( "Book title : %s\n", book.title);     //使用结构体指针访问结构体成员，使用 "." 操作符,即和结构体变量访问结构体成员方法一致
	fmt.Printf( "Book author : %s\n", book.author);
	fmt.Printf( "Book subject : %s\n", book.subject);
	fmt.Printf( "Book book_id : %d\n", book.book_id);
}

　切片

切片 slice
定义切片
var identifier []type	声明一个未指定大小的数组来定义切片
var slice1 []type = make([]type, len)	使用make()函数来创建切片:
slice1 := make([]type, len)  
make([]T, length, capacity)		可以指定容量，其中capacity为可选参数
切片初始化
s :=[] int {1,2,3 } 	直接初始化切片，[]表示是切片类型，{1,2,3}初始化值依次是1,2,3.其cap=len=3
s := arr[:] 			初始化切片s,是数组arr的引用
s := arr[startIndex:endIndex] 	将arr中从下标startIndex到endIndex-1 下的元素创建为一个新的切片,这里和Python列表的索引一样,顾头不顾尾
s := arr[startIndex:] 	缺省endIndex时将表示一直到arr的最后一个元素
s := arr[:endIndex] 	缺省startIndex时将表示从arr的第一个元素开始
s1 := s[startIndex:endIndex] 	通过切片s初始化切片s1
s :=make([]int,len,cap) 通过内置函数make()初始化切片s,[]int 标识为其元素类型为int的切片
append() 和 copy() 函数
如果想增加切片的容量，我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来
var numbers []int
numbers = append(numbers, 1)   向切片添加一个元素
numbers = append(numbers, 2,3,4)  同时添加多个元素
numbers1 := make([]int, len(numbers), (cap(numbers))*2)    创建切片 numbers1 是之前切片的两倍容量
copy(numbers1,numbers)    拷贝 numbers 的内容到 numbers1

　　

　

package main

import "fmt"

func main() {
	sliceTest()
	twoDimensionArray()
}

//切片，实际的是获取数组的某一部分，len切片<=cap切片<=len数组，切片由三部分组成：指向底层数组的指针、len、cap
func sliceTest() {
	arr := []int{1, 2, 3, 4, 5}
	s := arr[:]
	for e := range s {
		fmt.Println(s[e]) //1 2 3 4 5
	}
	s1 := make([]int, 3)
	for e := range s1 {
		fmt.Println(s1[e]) //0 0 0
	}

}

func twoDimensionArray() {
	var a = [][]int{{0, 0}, {1, 2}, {2,}, {3, 6}, {4, 8}}
	var i, j int
	for i = 0; i < len(a); i++ {
		for j = 0; j < len(a[i]); j++ {
			fmt.Printf("a[%d][%d]=%d\n", i, j, a[i][j])
		}
	}
	s1 := a[:3]
	fmt.Println(s1) //[[0 0] [1 2] [2]]
	s2 := a[:3][:2]
	fmt.Println(s2) //[[0 0] [1 2]] 这是在[:3]切片的基础上再进行切片
	var new_s = [][]int{}
	for _, arry := range s1 { //go语言中定义或者接受的变量必须使用,否则会报错,我们使用下划线_接收不想使用的变量,这样就可以不使用这个变量了
		fmt.Println(arry[:1]) // [0] [1] [2]
		new_s = append(new_s, arry[:1])

	}
	fmt.Println(new_s)	//[[0] [1] [2]] 得到新的二维数组

}