GO-指针与函数

一、指针类型

1、普通类型,变量存的就是值,也叫值类型。指针类型存的是地址

2、获取变量的地址,用&,比如:var a int, 获取a的地址 &a

3、指针类型,变量存的是一个地址,这个地址存的才是值

4、获取指针类型所指向的值,使用:* ,比如:var p *int,使用*p获取p指向的变量的值

var a int = 5 

var p *int = &a   0xefefefe 指向变量a的值是 5

5、指针类型的变量初始话有两种:

5.1、直接给指针赋值其他变量的地址

func test3(){
    var p *int  //默认初始化nil
    var a int
    p = &a
    *p = 200
    fmt.Println(a)
}

5.2、使用new分配

func test4(){
    var p *int
    p = new(int)
    *p = 2000
    fmt.Println(*p)
}

6、练习题

6.1、练习1:写一个程序,获取一个变量的地址,并打印到终端

package main
import (
    "fmt"
)
func test1(){
    var a int = 5
    var p *int = &a
    fmt.Printf("a的地址是:%p\n",p)
    fmt.Printf("a的值是:%d",*p)
}
func main(){
    test1()
}
运行打印的结果如下:

6.2、练习2:写一个函数,传入一个int类型的指针,并在函数中修改所指向的值

 

func modify(x *int){         //传入的变量x类型是指针 *int代表指针是整形的指针
    *x = 200                      //给x指针指向的值重新赋值为200
}
func test2(){
    var a int = 5             //定义一个整形的变量a,初始值是5
    var p *int = &a           //定义一个指针p,指向的是a
    fmt.Println("变量a的初始值是",a)   //打印a的初始值
    modify(p)                  //修改p指针指向的a的值
    fmt.Println("p指针指向的a变量的改变值是",a)   //打印a的值改变的结果

}
func main(){
    test2()
}
 
执行打印的结果如下:

 

二、内置函数

1、close:主要用来关闭channel

2、len:用来求长度,比如string、array、slice、map、channel

3、new:用来分配内存,主要用来分配值类型,比如int、struct。返回的是指针。示例可以看上面一的5.2,

4、make:用来分配内存,主要用来分配引用类型,比如channel、map、slice

5、append:用来追加元素到数组、slice中

6、panic和recover:用来做错误处理

7、new和make的区别

7.1、内建函数 new 用来分配内存,它的第一个参数是一个类型,不是一个值,它的返回值是一个指向新分配类型零值的指针

7.2、内建函数 make 用来为 slice,map 或 chan 类型分配内存和初始化一个对象(注意:只能用在这三种类型上),跟 new 类似,第一个参数也是一个类型而不是一个值,跟 new 不同的是,make 返回类型的引用而不是指针,而返回值也依赖于具体传入的类型,具体说明如下:

   Slice: 第二个参数 size 指定了它的长度,它的容量和长度相同。
你可以传入第三个参数来指定不同的容量值,但必须不能比长度值小。
比如 make([]int, 0, 10)

  Map: 根据 size 大小来初始化分配内存,不过分配后的 map 长度为 0,如果 size 被忽略了,那么会在初始化分配内存时分配一个小尺寸的内存

  Channel: 管道缓冲区依据缓冲区容量被初始化。如果容量为 0 或者忽略容量,管道是没有缓冲区的

7.3、总结:

  new 的作用是初始化一个指向类型的指针(*T),make 的作用是为 slice,map 或 chan 初始化并返回引用(T)。

三、函数

1、声明语法:func 函数名(参数列表)[(返回值列表)]{}

  func add(){

  }

  func add(a int,b int){

  }

  func add(a int, b int) int {

  }

  func add(a int, b int) (int , int){

  }

  func add(a , b int) (int , int){

  }

2、golang函数的特点:

  a、不支持重载,一个包不能有两个名字一样的函数;

  b、函数是一等公民,函数也是一种类型,函数也可以赋值给变量

  c、匿名函数

  d、多返回值

  示例: 

  type add_func func(int, int)int

  func oprator(op add_func,a int,b int)int {
      //使用传进来的函数op,进行操作
      return op(a,b)
  }
  func add(a,b int) int {
      return a + b
  }  
  func main(){
      c:=add
      fmt.Println(c)
      sum := oprator(c,100,200)
      fmt.Println(sum)
 
  }
3、函数参数传递方式:
  3.1、值传递
  3.2、引用传递
  注意1:无论是值传递,还是引用传递,传递给函数的都是变量的副本。值传递是值的拷贝,一般来说地址拷贝更高效。值拷贝取决于拷贝的对象的大小,对象越大,性能越低。
  注意2:map、slice、channel、指针、interface默认以引用的方式传递
4、命名返回值的名字
//重命名一个返回值
func reduce(a , b int)(c int){
    c = a - b
    return
}
//重命名多个返回值
func calc(a,b int)(sum int,avg int){
    sum = a + b
    avg = sum/2
    return
}
// _ 忽略返回值
func main(){
    sum,_ := calc(100,200)
}
5、可变参数:
多个参数
func test11(arg...int) int{
}
一个或多个参数
func test11(a int ,arg...int) int{
}
二个或多个参数
func test11(a int,b int ,arg...int) int{
}

注意:其中arg是一个slice,我们可以通过arg[index]来获取多个参数

通过len(arg)来判断传递参数的个数

6、练习题示例

package main

import (
    "fmt"
)

//练习题一:写一个函数add,支持1个或多个int相加,并返回结果
func add(a int,arg...int)int{
    var sum int
    //当只有一个参数时
    if len(arg)==0{
        sum = a
    }
    //当参数大于一个时
    if len(arg)>0{
        for i:=0;i<len(arg);i++{
            //注意这里但arg里面只有一个参数时,i是等于0即arg[0]
            if i == 0 {
                sum = a + arg[0]
            }
            //当arg参数大于一个时
            if i >0 {
                sum+=arg[i]
            }
        }
    }
    return sum
}

//练习题二:写一个函数concat,支持1个或多个string相拼接,并返回结果
func concat(a string,arg...string)string{
    var str string
    if len(arg)==0{
        str = a
    }
    if len(arg)>0{
        for i:=0;i<len(arg);i++{
            if i == 0 {
                str = a + arg[0]
            }
            if i >0 {
                str+=arg[i]
            }
        }
    }
    return str
}


func main(){
    fmt.Println(add(-22,23,555))
    fmt.Println(concat("aaa","bbbbb","ccccccc"))
}
 
7、defer的特点和用途
7.1、当函数返回时,执行defer语句。因此可以用来做资源清理
7.2、多个defer语句,按先进后出的方式执行
示例:
func a(){
    fmt.Println("defer from a")
    i:=0
    defer fmt.Println(i)   //defer语句中的变量,在defer声明时就决定
    i++ 
}
func f(){
    fmt.Println("defer from f")
    for i:=0;i<5;i++{
        defer fmt.Println(i)
    }   
}

func main(){
    //练习三
    a()
    f()
}
打印的结果:
7.3、defer语句中的变量,在defer声明时就决定了
7.4、defer用途:关闭文件句柄,锁资源释放,数据库连接释放
 
四、递归函数
1、一个函数调用自己,就叫递归函数
2、斐波那契数
//斐波那契数列示例:
func fb( n int)int{
    if n <=1{
        return 1
    }
    return fb(n-1)+fb(n-2)
}
func main(){
    for i:=0;i<10;i++{
        n := fb(i)
        fmt.Println(n)
    }
}
3、递归的设计原则
3.1、一个大问题能够分解成相似的小问题
3.2、定义好出口条件(即结束递归循环的条件)
 
五、闭包
一个函数和与其相关的引用环境的组合成的实体
//示例一:
func Adder() func(int)int{
    var x int
    return func(delta int)int{
        x +=delta
        return x
    }
}
//示例2:
func makeSuffixFunc(suffix string) func(string)string{
    return func(name string)string{
        if !strings.HasSuffix(name ,suffix){
            return name + suffix
        }
        return name
    }
}
func main(){
    //练习五:闭包
    //示例1:
    // var f = Adder()
    // fmt.Println(f(1))
    // fmt.Println(f(10))
    // fmt.Println(f(100))
    //示例2:
    func1 := makeSuffixFunc(".jpg")
    func2 := makeSuffixFunc(".txt")
    fmt.Println(func1(func1("test")))
    fmt.Println(func2("test"))
}
 
六、数组和切片
1.1、排序和查找操作
  排序操作主要都在sort包中,导入就可以使用
  sort.Ints对整数进行排序, sort.Strings对字符串串进⾏行行排序, sort.Float64s对 浮点数进⾏行行排序.
  sort.SearchInts(a []int, b int) 从数组a中查找b,前提是a 必须有序
   sort.SearchFloats(a []float64, b float64) 从数组a中查找b,前提是a 必须有序
  sort.SearchStrings(a []string, b string) 从数组a中查找b,前提是a 必须有序

 

posted @ 2017-12-20 14:13 willpower-chen 阅读(...) 评论(...) 编辑 收藏