av激情亚洲男人的天堂国语,日韩欧美精品一中文字幕,无码av一区二区三区无码,国产又色又爽又刺激的a片,国产又色又爽又刺激的a片

淺析Go與C的指針

運(yùn)算符

C 和 Go 都相同：

  • & 運(yùn)算符取出變量所在的內(nèi)存地址
  • * 運(yùn)算符取出指針變量所指向的內(nèi)存地址里面的值，也叫 “ 解引用 ”

C 語言版示例：

 
 
 
 
    
  
  
  
  
  1. #include  
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. int main() 
    4. 
  
  
  
  
  4. { 
    5. 
  
  
  
  
  5.     int bar = 1; 
    6. 
  
  
  
  
  6.     // 聲明一個指向 int 類型的值的指針 
    7. 
  
  
  
  
  7.     int *ptr; 
    8. 
  
  
  
  
  8.     // 通過 & 取出 bar 變量所在的內(nèi)存地址并賦值給 ptr 指針 
    9. 
  
  
  
  
  9.     ptr = &bar; 
    10. 
  
  
  
  
  10.     // 打印 ptr 的值（為地址），*prt 表示取出指針變量所指向的內(nèi)存地址里面的值 
    11. 
  
  
  
  
  11.     printf("%p %d\n", ptr, *ptr); 
    12. 
  
  
  
  
  12.     return (0); 
    13. 
  
  
  
  
  13. } 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. // 輸出結(jié)果： 
    16. 
  
  
  
  
  16. // 0x7ffd5471ee54 1 
    17.

Go 語言版示例：

 
 
 
 
    
  
  
  
  
  1. package main 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. import "fmt" 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. func main() { 
    6. 
  
  
  
  
  6.  bar := 1 
    7. 
  
  
  
  
  7.  // 聲明一個指向 int 類型的值的指針 
    8. 
  
  
  
  
  8.  var ptr *int 
    9. 
  
  
  
  
  9.  // 通過 & 取出 bar 變量所在的內(nèi)存地址并賦值給 ptr 指針 
    10. 
  
  
  
  
  10.  ptr = &bar 
    11. 
  
  
  
  
  11.  // 打印 ptr 變量儲存的指針地址，*prt 表示取出指針變量所指向的內(nèi)存地址里面的值 
    12. 
  
  
  
  
  12.  fmt.Printf("%p %d\n", ptr, *ptr) 
    13. 
  
  
  
  
  13. } 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. // 輸出結(jié)果： 
    16. 
  
  
  
  
  16. // 0xc000086020 1 
    17.

Go 還可以使用 new 關(guān)鍵字來分配內(nèi)存創(chuàng)建指定類型的指針。

 
 
 
 
    
  
  
  
  
  1. // 聲明一個指向 int 類型的值的指針 
    2. 
  
  
  
  
  2. // var ptr *int 
    3. 
  
  
  
  
  3. ptr := new(int) 
    4. 
  
  
  
  
  4. // 通過 & 取出 bar 變量所在的內(nèi)存地址并賦值給 ptr 指針 
    5. 
  
  
  
  
  5. ptr = &bar 
    6.

數(shù)組名和數(shù)組首地址

對于一個數(shù)組

 
 
 
 
    
  
  
  
  
  1. // C 
    2. 
  
  
  
  
  2. int arr[5] = {1, 2, 3, 4, 5}; 
    3. 
  
  
  
  
  3. // Go 
    4. 
  
  
  
  
  4. // 需要指定長度，否則類型為切片 
    5. 
  
  
  
  
  5. arr := [5]int{1, 2, 3, 4, 5} 
    6.

在 C 中，數(shù)組名 arr 代表的是數(shù)組首元素的地址，相當(dāng)于 &arr[0]

而 &arr 代表的是整個數(shù)組 arr 的首地址

 
 
 
 
    
  
  
  
  
  1. // C 
    2. 
  
  
  
  
  2. // arr 數(shù)組名代表數(shù)組首元素的地址 
    3. 
  
  
  
  
  3. printf("arr -> %p\n", arr); 
    4. 
  
  
  
  
  4. // &arr[0] 代表數(shù)組首元素的地址 
    5. 
  
  
  
  
  5. printf("&arr[0] -> %p\n", &arr[0]); 
    6. 
  
  
  
  
  6. // &arr 代表整個數(shù)組 arr 的首地址 
    7. 
  
  
  
  
  7. printf("&arr -> %p\n", &arr); 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. // 輸出結(jié)果： 
    10. 
  
  
  
  
  10. // arr -> 0061FF0C 
    11. 
  
  
  
  
  11. // &arr[0] -> 0061FF0C 
    12. 
  
  
  
  
  12. // &arr -> 0061FF0C 
    13.

運(yùn)行程序可以發(fā)現(xiàn) arr 和 &arr 的輸出值是相同的，但是它們的意義完全不同。

首先數(shù)組名 arr 作為一個標(biāo)識符，是 arr[0] 的地址，從 &arr[0] 的角度去看就是一個指向 int 類型的值的指針。

而 &arr 是一個指向 int[5] 類型的值的指針。

可以進(jìn)一步對其進(jìn)行指針偏移驗證

 
 
 
 
    
  
  
  
  
  1. // C 
    2. 
  
  
  
  
  2. // 指針偏移 
    3. 
  
  
  
  
  3. printf("arr+1 -> %p\n", arr + 1); 
    4. 
  
  
  
  
  4. printf("&arr+1 -> %p\n", &arr + 1); 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. // 輸出結(jié)果： 
    7. 
  
  
  
  
  7. // arr+1 -> 0061FF10 
    8. 
  
  
  
  
  8. // &arr+1 -> 0061FF20 
    9.

這里涉及到偏移量的知識：一個類型為 T 的指針的移動，是以 sizeof(T) 為移動單位的。

  • arr+1 : arr 是一個指向 int 類型的值的指針，因此偏移量為 1*sizeof(int)
  • &arr+1 : &arr 是一個指向 int[5] 的指針，它的偏移量為 1*sizeof(int)*5

到這里相信你應(yīng)該可以理解 C 語言中的 arr 和 &arr 的區(qū)別了吧，接下來看看 Go 語言

 
 
 
 
    
  
  
  
  
  1. // 嘗試將數(shù)組名 arr 作為地址輸出 
    2. 
  
  
  
  
  2. fmt.Printf("arr -> %p\n", arr) 
    3. 
  
  
  
  
  3. fmt.Printf("&arr[0] -> %p\n", &arr[0]) 
    4. 
  
  
  
  
  4. fmt.Printf("&arr -> %p\n", &arr) 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. // 輸出結(jié)果： 
    7. 
  
  
  
  
  7. // arr -> %!p([5]int=[1 2 3 4 5]) 
    8. 
  
  
  
  
  8. // &arr[0] -> 0xc00000c300 
    9. 
  
  
  
  
  9. // &arr -> 0xc00000c300 
    10.

&arr[0] 和 &arr 與 C 語言一致。

但是數(shù)組名 arr 在 Go 中已經(jīng)不是數(shù)組首元素的地址了，代表的是整個數(shù)組的值，所以輸出時會提示 %!p([5]int=[1 2 3 4 5])

指針運(yùn)算

指針本質(zhì)上就是一個無符號整數(shù)，代表了內(nèi)存地址。

指針和整數(shù)值可以進(jìn)行加減法運(yùn)算，比如上文的指針偏移例子：

  • 加n : 一個類型為 T 的指針，以 n*sizeof(T) 為單位向高位移動。
  • 減n : 一個類型為 T 的指針，以 n*sizeof(T) 為單位向低位移動。

其中 sizeof(T) 代表的是數(shù)據(jù)類型占據(jù)的字節(jié)，比如 int 在 32 位環(huán)境下為 4 字節(jié)，64 位環(huán)境下為 8 字節(jié)

C 語言示例：

 
 
 
 
    
  
  
  
  
  1. #include  
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. int main() 
    4. 
  
  
  
  
  4. { 
    5. 
  
  
  
  
  5.     int arr[] = {1, 2, 3, 4, 5}; 
    6. 
  
  
  
  
  6.     // ptr 是一個指針，為 arr 數(shù)組的第一個元素地址 
    7. 
  
  
  
  
  7.     int *ptr = arr; 
    8. 
  
  
  
  
  8.     printf("%p %d\n", ptr, *ptr); 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.     // ptr 指針向高位移動一個單位，移向到 arr 數(shù)組第二個元素地址 
    11. 
  
  
  
  
  11.     ptr++; 
    12. 
  
  
  
  
  12.     printf("%p %d\n", ptr, *ptr); 
    13. 
  
  
  
  
  13.     return (0); 
    14. 
  
  
  
  
  14. } 
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16. // 輸出結(jié)果： 
    17. 
  
  
  
  
  17. // 0061FF08 1 
    18. 
  
  
  
  
  18. // 0061FF0C 2 
    19.

在這里 ptr++ 從 0061FF08 移動了 sizeof(int) = 4 個字節(jié)到 0061FF0C ，指向了下一個數(shù)組元素的地址

Go 語言示例：

 
 
 
 
    
  
  
  
  
  1. package main 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. import "fmt" 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. func main() { 
    6. 
  
  
  
  
  6.  arr := [5]uint32{1, 2, 3, 4, 5} 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.  // ptr 是一個指針，為 arr 數(shù)組的第一個元素地址 
    9. 
  
  
  
  
  9.  ptr := &arr[0] 
    10. 
  
  
  
  
  10.  fmt.Println(ptr, *ptr) 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12.  // ptr 指針向高位移動一個單位，移向到 arr 數(shù)組第二個元素地址 
    13. 
  
  
  
  
  13.  ptr++ 
    14. 
  
  
  
  
  14.  fmt.Println(ptr, *ptr) 
    15. 
  
  
  
  
  15. } 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17. // 輸出結(jié)果： 
    18. 
  
  
  
  
  18. // 編譯報錯： 
    19. 
  
  
  
  
  19. // .\main.go:13:5: invalid operation: ptr++ (non-numeric type *uint32) 
    20.

編譯報錯 *uint32 非數(shù)字類型，不支持運(yùn)算，說明 Go 是不支持指針運(yùn)算的。

這個其實(shí)在 Go Wiki[1] 中的 Go 從 C++ 過渡文檔中有提到過：Go has pointers but not pointer arithmetic.

Go 有指針但不支持指針運(yùn)算。

另辟蹊徑

那還有其他辦法嗎?答案當(dāng)然是有的。

在 Go 標(biāo)準(zhǔn)庫中提供了一個 unsafe 包用于編譯階段繞過 Go 語言的類型系統(tǒng)，直接操作內(nèi)存。

我們可以利用 unsafe 包來實(shí)現(xiàn)指針運(yùn)算。

 
 
 
 
    
  
  
  
  
  1. func Alignof(x ArbitraryType) uintptr 
    2. 
  
  
  
  
  2. func Offsetof(x ArbitraryType) uintptr 
    3. 
  
  
  
  
  3. func Sizeof(x ArbitraryType) uintptr 
    4. 
  
  
  
  
  4. type ArbitraryType 
    5. 
  
  
  
  
  5. func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType 
    6. 
  
  
  
  
  6. type IntegerType 
    7. 
  
  
  
  
  7. type Pointer 
    8. 
  
  
  
  
  8. func Add(ptr Pointer, len IntegerType) Pointer 
    9.

核心介紹：

  • uintptr : Go 的內(nèi)置類型。是一個無符號整數(shù)，用來存儲地址，支持?jǐn)?shù)學(xué)運(yùn)算。常與 unsafe.Pointer 配合做指針運(yùn)算
  • unsafe.Pointer : 表示指向任意類型的指針，可以和任何類型的指針互相轉(zhuǎn)換(類似 C 語言中的 void* 類型的指針)，也可以和 uintptr 互相轉(zhuǎn)換
  • unsafe.Sizeof : 返回操作數(shù)在內(nèi)存中的字節(jié)大小，參數(shù)可以是任意類型的表達(dá)式，例如 fmt.Println(unsafe.Sizeof(uint32(0))) 的結(jié)果為 4
  • unsafe.Offsetof : 函數(shù)的參數(shù)必須是一個字段 x.f，然后返回 f 字段相對于 x 起始地址的偏移量，用于計算結(jié)構(gòu)體成員的偏移量

原理：

Go 的 uintptr 類型存儲的是地址，且支持?jǐn)?shù)學(xué)運(yùn)算

*T (任意指針類型) 和 unsafe.Pointer 不能運(yùn)算，但是 unsafe.Pointer 可以和 *T 、 uintptr 互相轉(zhuǎn)換

因此，將 *T 轉(zhuǎn)換為 unsafe.Pointer 后再轉(zhuǎn)換為 uintptr ，uintptr 進(jìn)行運(yùn)算之后重新轉(zhuǎn)換為 unsafe.Pointer => *T 即可

代碼實(shí)現(xiàn)：

 
 
 
 
    
  
  
  
  
  1. package main 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. import ( 
    4. 
  
  
  
  
  4.  "fmt" 
    5. 
  
  
  
  
  5.  "unsafe" 
    6. 
  
  
  
  
  6. ) 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8. func main() { 
    9. 
  
  
  
  
  9.  arr := [5]uint32{1, 2, 3, 4, 5} 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.  ptr := &arr[0] 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13.  // ptr(*uint32類型) => one(unsafe.Pointer類型) 
    14. 
  
  
  
  
  14.  one := unsafe.Pointer(ptr) 
    15. 
  
  
  
  
  15.  // one(unsafe.Pointer類型) => *uint32 
    16. 
  
  
  
  
  16.  fmt.Println(one, *(*uint32)(one)) 
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18.  // one(unsafe.Pointer類型) => one(uintptr類型) 后向高位移動 unsafe.Sizeof(arr[0]) = 4 字節(jié) 
    19. 
  
  
  
  
  19.  // twoUintptr := uintptr(one) + unsafe.Sizeof(arr[0]) 
    20. 
  
  
  
  
  20.  // ??！twoUintptr 不能作為臨時變量 
    21. 
  
  
  
  
  21.  // uintptr 類型的臨時變量只是一個無符號整數(shù)，并不知道它是一個指針地址，可能被 GC 
    22. 
  
  
  
  
  22.  // 運(yùn)算完成后應(yīng)該直接轉(zhuǎn)換回 unsafe.Pointer : 
    23. 
  
  
  
  
  23.  two := unsafe.Pointer(uintptr(one) + unsafe.Sizeof(arr[0])) 
    24. 
  
  
  
  
  24.  fmt.Println(two, *(*uint32)(two)) 
    25. 
  
  
  
  
  25. } 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27. // 輸出結(jié)果： 
    28. 
  
  
  
  
  28. // 0xc000012150 1 
    29. 
  
  
  
  
  29. // 0xc000012154 2 
    30.

甚至還可以更改結(jié)構(gòu)體的私有成員：

 
 
 
 
    
  
  
  
  
  1. // model/model.go 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. package model 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. import ( 
    6. 
  
  
  
  
  6.  "fmt" 
    7. 
  
  
  
  
  7. ) 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. type M struct { 
    10. 
  
  
  
  
  10.  foo uint32 
    11. 
  
  
  
  
  11.  bar uint32 
    12. 
  
  
  
  
  12. } 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14. func (m M) Print() { 
    15. 
  
  
  
  
  15.  fmt.Println(m.foo, m.bar) 
    16. 
  
  
  
  
  16. } 
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18. // main.go 
    19. 
  
  
  
  
  19.  
    20. 
  
  
  
  
  20. package main 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22. import ( 
    23. 
  
  
  
  
  23.  "example/model" 
    24. 
  
  
  
  
  24.  "unsafe" 
    25. 
  
  
  
  
  25. ) 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27. func main() { 
    28. 
  
  
  
  
  28.  m := model.M{} 
    29. 
  
  
  
  
  29.  m.Print() 
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31.  foo := unsafe.Pointer(&m) 
    32. 
  
  
  
  
  32.  *(*uint32)(foo) = 1 
    33. 
  
  
  
  
  33.  bar := unsafe.Pointer(uintptr(foo) + 4) 
    34. 
  
  
  
  
  34.  *(*uint32)(bar) = 2 
    35. 
  
  
  
  
  35.  
    36. 
  
  
  
  
  36.  m.Print() 
    37. 
  
  
  
  
  37. } 
    38. 
  
  
  
  
  38.  
    39. 
  
  
  
  
  39. // 輸出結(jié)果： 
    40. 
  
  
  
  
  40. // 0 0 
    41. 
  
  
  
  
  41. // 1 2 
    42.

小 Tips

Go 的底層 slice 切片源碼就使用了 unsafe 包

 
 
 
 
    
  
  
  
  
  1. // slice 切片的底層結(jié)構(gòu) 
    2. 
  
  
  
  
  2. type slice struct { 
    3. 
  
  
  
  
  3.  // 底層是一個數(shù)組指針 
    4. 
  
  
  
  
  4.  array unsafe.Pointer 
    5. 
  
  
  
  
  5.  // 長度 
    6. 
  
  
  
  
  6.  len int 
    7. 
  
  
  
  
  7.  // 容量 
    8. 
  
  
  
  
  8.  cap int 
    9. 
  
  
  
  
  9. } 
    10.

總結(jié)

  • Go 可以使用 & 運(yùn)算符取地址，也可以使用 new 創(chuàng)建指針
  • Go 的數(shù)組名不是首元素地址
  • Go 的指針不支持運(yùn)算
  • Go 可以使用 unsafe 包打破安全機(jī)制來操控指針，但對我們開發(fā)者而言，是 "unsafe" 不安全的

參考資料

[1]Go Wiki: https://github.com/golang/go/wiki/GoForCPPProgrammers

本文轉(zhuǎn)載自微信公眾號「尋尋覓覓的Gopher」，可以通過以下二維碼關(guān)注。轉(zhuǎn)載本文請聯(lián)系尋尋覓覓的Gopher公眾號。


網(wǎng)站名稱：淺析Go與C的指針
網(wǎng)頁URL：http://uogjgqi.cn/article/djhopgc.html
掃二維碼與項目經(jīng)理溝通

我們在微信上24小時期待你的聲音

解答本文疑問/技術(shù)咨詢/運(yùn)營咨詢/技術(shù)建議/互聯(lián)網(wǎng)交流