go語言學習--基礎篇（3）

標籤：64位   make   size   結果   語言   不能   記憶體   fun   style   

一，go語言數組

     1，數組的特點

　         a. 數組在初始化完成之後，數組的長度是固定的

             b. 只儲存同一類型的資料

             c. 數組中的元素與元素之間的記憶體空間是連續的

      2，數組的定義

             var a [5]int     其中a 表示數組的名稱，[5]表示數組的長度，int 表示數組中的元素類型

      3，數組中元素的訪問

              使用下標訪問 a[0],a[1],a[2]

      4，迴圈擷取數組每個元素的地址

package mainimport (       "fmt")func main() {       var a [10]int       for i :=0;i <10; i++{             fmt.Printf("%p\n", &a[i]}    }}輸出結果：                                        #明顯每個元素佔8個位元組，而且是連續的0xc04206e050                                    #int 類型所佔的記憶體空間和作業系統有關 64位作業系統，int 佔64位，即8個位元組0xc04206e058                                     0xc04206e0600xc04206e0680xc04206e0700xc04206e0780xc04206e0800xc04206e0880xc04206e0900xc04206e098

        5，數組長度

             var  a[10]int   length := len(a)

         6，數組存在越界問題

              var  a[10]int 長度為10，下標範圍為0到9。訪問0到9之外的小標會報錯

         7，數組的遍曆

/* range 遍曆數組 */package mainimport ("fmt")func main() {var a [10]intfor index,val := range a{fmt.Printf("a[%d] = %d\n",index,val)}}

 

           8， 實值型別

func test() {     var a [5]int = [5]int {1,2,3,4,5}     var b [5]int     b = a     fmt.Printf("b=%v\n",b)     b[0] = 200          fmt.Printf("b=%v\n",b)     fmt.Printf("a=%v\n",a)}#輸出結果為#b=[1 2 3 4 5]#b=[200 2 3 4 5]#a=[1 2 3 4 5]#從中可以看出改變數組b中的元素，並不會改變數組a中的元素，這就是實值型別

        9，數組的初始化

              a. var a[5] int = [5]int {1,2,3,4,5}

              b. var a = [5]int{1,2,3,4,5}

              c. var a = [...]int{1,2,3,4,5}  其中[...]表示不確定長度

              d. var a = [5]string{1:"abc",2"eft"}  表示給數組a的前兩個元素賦值為a[0]=abc,a[1]=eft

      10，二維數組定義

              var a[8][2]int   定義一個8行2列的數組

 

二，切片

     切片的長度是動態,任何切片底層都為數組

      1，切片的定義, 與數組的定義唯一的區別就是沒有長度，並且預設長度為0

            var  變數名 [ ] type

           a. var  a [] string

           b. var  a [] float32

      2，切片的初始化（切片為參考型別）

           var  a [5] int

           var  b []int = a [0:2]

           var  b []int = a [2:]

           var  b []int = []int{1,2,3,4,5}

     3，樣本思考

         可以看出a 的值改變，相應的切片b的值也會變，說明切片為指標類型或者參考型別

package mainimport("fmt")func main(){var a [5]intb :=a[1:3]a[0] =100a[1] =200fmt.Printf("b:%#v\n",b)                         }

輸出為：
b:[]int{200,0}

          4，切片的記憶體布局

               x 為一個切片，切片的形式包含三個內容，指向底層數組的指標，定義切片的長度和切片的容量

           5，傳數組與傳切片

package mainimport ("fmt")func Sum(b []int){b[0] = 100}func SumArry(b [100]int){b[0] = 100}func main(){var a [100]inta[0] = 1a[1] = 2a[2] = 3Sum(a[:])fmt.Printf("a:%d\n",a[0])a[0] = 1                                                #重設a[0]的值SumArry(a)fmt.Printf("a:%d\n",a[0])}#輸出為                                  #a:100#a:1#從輸出結果可以看出 傳入參數為切片時，底層數組的值可以被改變，當傳入是數組時，數組的值不能改變，#再次說明切片為指標類型或者參考型別，而數組為數實值型別

           6，切片的建立

            var  b []int

            b = make([]int,5,10)

            a. 指定切片容量 make([]type，len，cap)

            b. 不指定切片容量，容量就等於長度 make([]type,len),

            注意：

                  以make 方式建立一個數組，其底層也一個數組，有make 建立

           

            7，切片的記憶體操作copy 和 append 操作，append 會對切片進行擴容，增加記憶體

            將一個切片append 到另一個切片 

func testAppend(){         var a []int         a = make([]int,5)         var b[]int = []int{10,11,12,14}         a =append(a,b...)                       #b... 展開切片b的所有元素         ftm.Printf("a:%#v\n",a)}

 

          8，字串的記憶體布局

           在go 語言中，字串也是一個切片，記憶體布局如

            a，ptr 為指標

            b，len為長度，

            c，容量也就是長度

            d，類型為byte

  

          9，修改字串中某個字元

func testStrSlice() {          var str = ‘hello world"          var b []byte = []byte(str)                   #請字串轉化成切片          b[0] = ‘a‘                                         #修改切片第一個值          str1 :=string(b)                                 #將切片轉化成string          fmt.Printf("str1:%s\n",str1}

 

 

 

           

go語言學習--基礎篇（3）