数组
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]] 得到新的二维数组
}