1.函数

1.1go函数定义格式：

func function_name( [parameter list] ) [return_types]
{
   函数体
}

func：函数由 func 开始声明
function_name：函数名称，函数名和参数列表一起构成了函数签名。
parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
函数体：函数定义的代码集合。

1.2 函数调用

package main

import "fmt"

func main() {
   
   var a int = 100
   var b int = 200
   var ret int

   
   ret = max(a, b)

   fmt.Printf( "最大值是 : %d\n", ret )  // 最大值是 : 200
}

// max函数  注意：如果max与main不在同一个文件中，命名需大驼峰 Max
func max(num1, num2 int) int {
   
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

1.3 函数参数

调用函数，有两种方式传传递参数。

1.3.1 值传递

实例：

package main

import "fmt"

func main() {
   
   var a int = 100
   var b int = 200

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

   
   swap(a, b)

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


func swap(x, y int) int {
   var temp int

   temp = x 
   x = y    
   y = temp 

   return temp;
}

/*
交换前 a 的值为 : 100
交换前 b 的值为 : 200
交换后 a 的值 : 100
交换后 b 的值 : 200
*/ 说明值传递没有影响实际参数。

1.3.2 引用传递

package main

import "fmt"

func main() {
   
   var a int = 100
   var b int= 200

   fmt.Printf("交换前，a 的值 : %d\n", a )
   fmt.Printf("交换前，b 的值 : %d\n", 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 = *y      
   *y = temp    
}
/*
交换前，a 的值 : 100
交换前，b 的值 : 200
交换后，a 的值 : 200
交换后，b 的值 : 100
*/ 说明引用传递影响实际参数。

1.4.函数方法

实例：

package main

import (
   "fmt"  
)


type Circle struct {
  radius float64
}

func main() {
  var c1 Circle
  c1.radius = 10.00
  fmt.Println("Area of Circle(c1) = ", c1.getArea())  // Area of Circle(c1) =  314
}

//该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
  //c.radius 即为 Circle 类型对象中的属性
  return 3.14 * c.radius * c.radius
}

#

2.数组

2.1 初始化数组

var balance [10] float32 // 定义了数组 balance 长度为 10 类型为 float32
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0} // {}中元素个数不能大于[]中的数字。

2.2 访问数组元素

func Arr() {
    var n [10]int
    //var i,j int
    var i int

    for i = 0; i < 10; i++ {
       n[i] = i + 100
       fmt.Printf("Element[%d] = %d\n", i, n[i])
    }

    //for j = 0; j < 10; j++ {
    // fmt.Printf("Element[%d] = %d\n", j, n[j])
    //}
}

2.3 向函数传递数组

package main

import "fmt"

func main() {
   
   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 / size)

   return avg;
}

3. 指针

Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。

package main

import "fmt"

func main() {
   var a int = 10   

   fmt.Printf("变量的地址: %x\n", &a  ) // 变量的地址: 20818a220
}

一个指针变量可以指向任何一个值的内存地址。

3.1 声明指针

var var_name *var-type
var ip *int        
var fp *float32

3.2 指针变量赋值与访问

在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。

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 )
}
/*
a 变量的地址是: 20818a220
ip 变量的存储地址: 20818a220
*ip 变量的值: 20
*/

3.3 go空指针

当一个指针被定义后没有分配到任何变量时，它的值为 nil。 nil 指针也称为空指针。

nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。

一个指针变量通常缩写为 ptr。

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("ptr 的值为 : %x\n", ptr  ) // ptr 的值为 : 0
}

3.4 指针的指针

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

当定义一个指向指针的指针变量时，第一个指针存放第二个指针的地址，第二个指针存放变量的地址。声明：

var ptr **int;

访问指向指针的指针变量值需要使用两个 * 号

package main

import "fmt"

func main() {

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

   a = 3000

   
   ptr = &a

   
   pptr = &ptr

   
   fmt.Printf("变量 a = %d\n", a )
   fmt.Printf("指针变量 *ptr = %d\n", *ptr )
   fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
}
/*
变量 a = 3000
指针变量 *ptr = 3000
指向指针的指针变量 **pptr = 3000
*/

4.结构体

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

结构体表示一项记录，比如保存图书馆的书籍记录，每本书有以下属性：

Title ：标题
Author ：作者
Subject：学科
ID：书籍ID

实例：

package main

import "fmt"

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

func main() {
   var Book1 Books        
   var Book2 Books        

   
   Book1.title = "Go 语言"
   Book1.author = "www.shouce.ren"
   Book1.subject = "Go 语言教程"
   Book1.book_id = 6495407

   
   Book2.title = "Python 教程"
   Book2.author = "www.shouce.ren"
   Book2.subject = "Python 语言教程"
   Book2.book_id = 6495700

   
   fmt.Printf( "Book 1 title : %s\n", Book1.title)
   fmt.Printf( "Book 1 author : %s\n", Book1.author)
   fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
   fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)

   
   fmt.Printf( "Book 2 title : %s\n", Book2.title)
   fmt.Printf( "Book 2 author : %s\n", Book2.author)
   fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
   fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
}
/*
Book 1 title : Go 语言
Book 1 author : www.shouce.ren
Book 1 subject : Go 语言教程
Book 1 book_id : 6495407
Book 2 title : Python 教程
Book 2 author : www.shouce.ren
Book 2 subject : Python 语言教程
Book 2 book_id : 6495700
*/

go语言学习系列（三）：函数、数组、指针、结构体