mirror of
https://github.com/gopl-zh/gopl-zh.github.com.git
synced 2025-12-17 11:14:20 +08:00
rebuild
This commit is contained in:
chai2010
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="13.1" data-chapter-title="unsafe.Sizeof, Alignof 和 Offsetof" data-filepath="ch13/ch13-01.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="13.1" data-chapter-title="unsafe.Sizeof, Alignof 和 Offsetof" data-filepath="ch13/ch13-01.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2024,15 +2024,13 @@
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h2 id="131-unsafesizeof-alignof-和-offsetof">13.1. unsafe.Sizeof, Alignof 和 Offsetof</h2>
|
||||
<p><code>unsafe.Sizeof</code> 函數返迴操作數在內存的字節大小, 可以是任意類型的表達式, 但是併不會對表達式進行求值. <code>Sizeof</code> 是一個 uintptr 類型的常量表達式, 因此返迴的結果可以用着數據的大小, 或者用作計算其他的常量.</p>
|
||||
<p>unsafe.Sizeof函數返迴操作數在內存中的字節大小，參數可以是任意類型的表達式，但是它併不會對表達式進行求值。一個Sizeof函數調用是一個對應uintptr類型的常量表達式，因此返迴的結果可以用作數組類型的長度大小，或者用作計算其他的常量。</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-keyword">import</span> <span class="hljs-string">"unsafe"</span>
|
||||
fmt.Println(unsafe.Sizeof(<span class="hljs-typename">float64</span>(<span class="hljs-number">0</span>))) <span class="hljs-comment">// "8"</span>
|
||||
</code></pre>
|
||||
<p><code>Sizeof</code> 隻返迴數據結構中固定的部分, 例如字符串中指針和字符串長度部分, 但是併不包含字符串的內容. Go中非聚合類型通常有一個固定的尺寸, 盡管不同工具鏈的具體大小可能會有所不同. 考慮到可移植性, 引用類型或包含引用類型的大小在32位平颱上是4個字節, 在64位平颱上是8個字節.</p>
|
||||
<p>計算機加載和保存數據時, 如果內存地址合理地對齊的將會更有效率.
|
||||
例如 2 字節大小的 int16 類型應該是偶數, 一個4 字節大小的 rune 類型地址應該是 4 的倍數, 一個 8 字節大小的 float64, uint64 或 64-bit 指針 的地址應該是 8 字節對齊的. 但是對於再大的地址對齊倍數則是不需要的,
|
||||
卽使是 complex128 等較大的數據類型.</p>
|
||||
<p>由於這個因素,一個聚合類型(結構體或數組)的大小至少是所有字段或元素大小的總和, 或者更大因爲可能存在空洞. 空洞是編譯器自動添加的沒有被使用的空間, 用於保證後面每個字段或元素的地址相對於結構或數組的開始地址能夠合理地對齊.</p>
|
||||
<p>Sizeof函數返迴的大小隻包括數據結構中固定的部分，例如字符串對應結構體中的指針和字符串長度部分，但是併不包含指針指向的字符串的內容。Go語言中非聚合類型通常有一個固定的大小，盡管在不同工具鏈下生成的實際大小可能會有所不同。考慮到可移植性，引用類型或包含引用類型的大小在32位平颱上是4個字節，在64位平颱上是8個字節。</p>
|
||||
<p>計算機在加載和保存數據時，如果內存地址合理地對齊的將會更有效率。例如2字節大小的int16類型的變量地址應該是偶數，一個4字節大小的rune類型變量的地址應該是4的倍數，一個8字節大小的float64、uint64或64-bit指針類型變量的地址應該是8字節對齊的。但是對於再大的地址對齊倍數則是不需要的，卽使是complex128等較大的數據類型最多也隻是8字節對齊。</p>
|
||||
<p>由於地址對齊這個因素，一個聚合類型（結構體或數組）的大小至少是所有字段或元素大小的總和，或者更大因爲可能存在內存空洞。內存空洞是編譯器自動添加的沒有被使用的內存空間，用於保證後面每個字段或元素的地址相對於結構或數組的開始地址能夠合理地對齊（譯註：內存空洞可能會存在一些隨機數據，可能會對用unsafe包直接操作內存的處理産生影響）。</p>
|
||||
<table>
|
||||
<thead>
|
||||
<tr>
|
||||
@@ -2043,11 +2041,11 @@ fmt.Println(unsafe.Sizeof(<span class="hljs-typename">float64</span>(<span class
|
||||
<tbody>
|
||||
<tr>
|
||||
<td>bool</td>
|
||||
<td>1字節</td>
|
||||
<td>1個字節</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>intN, uintN, floatN, complexN</td>
|
||||
<td>N/8字節 (例如 float64 是 8字節)</td>
|
||||
<td>N/8個字節(例如float64是8個字節)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>int, uint, uintptr</td>
|
||||
@@ -2063,7 +2061,7 @@ fmt.Println(unsafe.Sizeof(<span class="hljs-typename">float64</span>(<span class
|
||||
</tr>
|
||||
<tr>
|
||||
<td>[]T</td>
|
||||
<td>3個機器字(data,len, cap)</td>
|
||||
<td>3個機器字(data,len,cap)</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>map</td>
|
||||
@@ -2083,13 +2081,13 @@ fmt.Println(unsafe.Sizeof(<span class="hljs-typename">float64</span>(<span class
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
<p>Go的語言規范併沒有保證一個字段的聲明順序和內存中的順序是一致的, 所以理論上一個編譯器可以隨意地重新排列每個字段的內存布局, 隨着在寫作本書的時候編譯器還沒有這麽做. 下面的三個結構體有着相同的字段, 但是第一個比另外的兩個需要多 50% 的內存.</p>
|
||||
<pre><code class="lang-Go"> <span class="hljs-comment">// 64-bit 32-bit</span>
|
||||
<p>Go語言的規范併沒有要求一個字段的聲明順序和內存中的順序是一致的，所以理論上一個編譯器可以隨意地重新排列每個字段的內存位置，隨然在寫作本書的時候編譯器還沒有這麽做。下面的三個結構體雖然有着相同的字段，但是第一種寫法比另外的兩個需要多50%的內存。</p>
|
||||
<pre><code class="lang-Go"> <span class="hljs-comment">// 64-bit 32-bit</span>
|
||||
<span class="hljs-keyword">struct</span>{ <span class="hljs-typename">bool</span>; <span class="hljs-typename">float64</span>; <span class="hljs-typename">int16</span> } <span class="hljs-comment">// 3 words 4words</span>
|
||||
<span class="hljs-keyword">struct</span>{ <span class="hljs-typename">float64</span>; <span class="hljs-typename">int16</span>; <span class="hljs-typename">bool</span> } <span class="hljs-comment">// 2 words 3words</span>
|
||||
<span class="hljs-keyword">struct</span>{ <span class="hljs-typename">bool</span>; <span class="hljs-typename">int16</span>; <span class="hljs-typename">float64</span> } <span class="hljs-comment">// 2 words 3words</span>
|
||||
</code></pre>
|
||||
<p>雖然關於對齊算法的細節超齣了本書的范圍, 也不是每一個結構體都需要擔心這個問題, 不過有效的包裝可以使數據結構更加緊湊, 內存使用率和性能都可能受益.</p>
|
||||
<p>關於內存地址對齊算法的細節超齣了本書的范圍，也不是每一個結構體都需要擔心這個問題，不過有效的包裝可以使數據結構更加緊湊（譯註：未來的Go語言編譯器應該會默認優化結構體的順序，當然用於應該也能夠指定具體的內存布局，相同討論請參考 <a href="https://github.com/golang/go/issues/10014" target="_blank">Issue10014</a> ），內存使用率和性能都可能會受益。</p>
|
||||
<p><code>unsafe.Alignof</code> 函數返迴對應參數的類型需要對齊的倍數. 和 Sizeof 類似, Alignof 也是返迴一個常量表達式, 對應一個常量. 通常情況下布爾和數字類型需要對齊到它們本身的大小(最多8個字節), 其它的類型對齊到機器字大小.</p>
|
||||
<p><code>unsafe.Offsetof</code> 函數的參數必鬚是一個字段 <code>x.f</code>, 然後返迴 <code>f</code> 字段相對於 <code>x</code> 起始地址的偏移量, 包括可能的空洞.</p>
|
||||
<p>圖 13.1 顯示了一個結構體變量 x 以及其在32位和64位機器上的典型的內存. 灰色區域是空洞.</p>
|
||||
@@ -2099,21 +2097,19 @@ fmt.Println(unsafe.Sizeof(<span class="hljs-typename">float64</span>(<span class
|
||||
c []<span class="hljs-typename">int</span>
|
||||
}
|
||||
</code></pre>
|
||||
<p>The table below shows the results of applying the three unsafe functions to x itself and to each of its three fields:</p>
|
||||
<p>下面顯示了應用三個函數對 x 和它的三個字段計算的結果:</p>
|
||||
<p>下面顯示了對x和它的三個字段調用unsafe包相關函數的計算結果：</p>
|
||||
<p><img src="../images/ch13-01.png" alt=""></p>
|
||||
<p>32位繫統:</p>
|
||||
<p>32位繫統：</p>
|
||||
<pre><code>Sizeof(x) = 16 Alignof(x) = 4
|
||||
Sizeof(x.a) = 1 Alignof(x.a) = 1 Offsetof(x.a) = 0
|
||||
Sizeof(x.b) = 2 Alignof(x.b) = 2 Offsetof(x.b) = 2
|
||||
Sizeof(x.c) = 12 Alignof(x.c) = 4 Offsetof(x.c) = 4
|
||||
</code></pre><p>64位繫統:</p>
|
||||
</code></pre><p>64位繫統：</p>
|
||||
<pre><code>Sizeof(x) = 32 Alignof(x) = 8
|
||||
Sizeof(x.a) = 1 Alignof(x.a) = 1 Offsetof(x.a) = 0
|
||||
Sizeof(x.b) = 2 Alignof(x.b) = 2 Offsetof(x.b) = 2
|
||||
Sizeof(x.c) = 24 Alignof(x.c) = 8 Offsetof(x.c) = 8
|
||||
</code></pre><p>雖然它們在不安全的 unsafe 包, 但是這幾個函數併不是眞的不安全,
|
||||
特别在需要優化內存空間時它們對於理解原生的內存布局很有幫助.</p>
|
||||
</code></pre><p>雖然這幾個函數在不安全的unsafe包，但是這幾個函數調用併不是眞的不安全，特别在需要優化內存空間時它們返迴的結果對於理解原生的內存布局很有幫助。</p>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="13.2" data-chapter-title="unsafe.Pointer" data-filepath="ch13/ch13-02.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="13.2" data-chapter-title="unsafe.Pointer" data-filepath="ch13/ch13-02.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2024,19 +2024,17 @@
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h2 id="132-unsafepointer">13.2. unsafe.Pointer</h2>
|
||||
<p>大多數指針類型寫成 <em>T, 含義是 "一個指向T類型變量的指針". <code>unsafe.Pointer</code> 是特别定義的一種指針類型, 它可以包含任意類型變量的地址. 當然, 我們不可以直接使用 </em>p 穫取 <code>unsafe.Pointer</code> 指針指向的眞實變量, 因爲我們併不知道變量的類型. 和普通指針一樣, <code>unsafe.Pointer</code> 指針是可以比較的, 支持和 nil 比較判斷是否爲空指針.</p>
|
||||
<p>一個普通的 <em>T 類型指針可以被轉化爲 <code>unsafe.Pointer</code> 類型指針, 併且一個 <code>unsafe.Pointer</code> 類型指針也可以被轉迴普通指針, 也可以是和 </em>T 不同類型的指針. 通過將 <code>*float64</code> 類型指針 轉化爲 <code>*uint64</code> 類型指針, 我們可以檢査一個浮點數變量的位模式.</p>
|
||||
<p>大多數指針類型會寫成<code>*T</code>，表示是“一個指向T類型變量的指針”。unsafe.Pointer是特别定義的一種指針類型（譯註：類似C語言中的<code>void*</code>類型的指針），它可以包含任意類型變量的地址。當然，我們不可以直接通過<code>*p</code>來穫取unsafe.Pointer指針指向的眞實變量的值，因爲我們併不知道變量的具體類型。和普通指針一樣，unsafe.Pointer指針也是可以比較的，併且支持和nil常量比較判斷是否爲空指針。</p>
|
||||
<p>一個普通的<code>*T</code>類型指針可以被轉化爲unsafe.Pointer類型指針，併且一個unsafe.Pointer類型指針也可以被轉迴普通的指針，被轉迴普通的指針類型併不需要和原始的<code>*T</code>類型相同。通過將<code>*float64</code>類型指針轉化爲<code>*uint64</code>類型指針，我們可以査看一個浮點數變量的位模式。</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-keyword">package</span> math
|
||||
|
||||
<span class="hljs-keyword">func</span> Float64bits(f <span class="hljs-typename">float64</span>) <span class="hljs-typename">uint64</span> { <span class="hljs-keyword">return</span> *(*<span class="hljs-typename">uint64</span>)(unsafe.Pointer(&f)) }
|
||||
|
||||
fmt.Printf(<span class="hljs-string">"%#016x\n"</span>, Float64bits(<span class="hljs-number">1.0</span>)) <span class="hljs-comment">// "0x3ff0000000000000"</span>
|
||||
</code></pre>
|
||||
<p>通過新指針, 我們可以更新浮點數的位模式. 通過位模式操作浮點數是可以的, 但是更重要的意義是指針轉換讓我們可以在不破壞類型繫統的前提下向內存寫入任意的值.</p>
|
||||
<p>一個 <code>unsafe.Pointer</code> 指針也可以被轉化爲 uintptr 類似, 然後保存到指針型數值變量中, 用以做必要的指針運算.
|
||||
(第三章內容, uintptr是一個無符號的整型數, 足有保存一個地址.)
|
||||
這種轉換也是可逆的, 但是, 將 uintptr 轉爲 <code>unsafe.Pointer</code> 指針可能破壞類型繫統, 因爲併不是所有的數字都是有效的內存地址.</p>
|
||||
<p>許多將 <code>unsafe.Pointer</code> 指針 轉爲原生數字, 然後再轉爲 <code>unsafe.Pointer</code> 指針的操作是不安全的. 下面的例子需要將變量 x 的地址加上 b 字段的偏移轉化爲 *int16 類型指針, 然後通過該指針更新 <code>x.b</code>:</p>
|
||||
<p>通過轉爲新類型指針，我們可以更新浮點數的位模式。通過位模式操作浮點數是可以的，但是更重要的意義是指針轉換語法讓我們可以在不破壞類型繫統的前提下向內存寫入任意的值。</p>
|
||||
<p>一個unsafe.Pointer指針也可以被轉化爲uintptr類型，然後保存到指針型數值變量中（譯註：這隻是和當前指針相同的一個數字值，併不是一個指針），然後用以做必要的指針數值運算。（第三章內容，uintptr是一個無符號的整型數，足以保存一個地址）這種轉換雖然也是可逆的，但是將uintptr轉爲unsafe.Pointer指針可能會破壞類型繫統，因爲併不是所有的數字都是有效的內存地址。</p>
|
||||
<p>許多將unsafe.Pointer指針轉爲原生數字，然後再轉迴爲unsafe.Pointer類型指針的操作也是不安全的。比如下面的例子需要將變量x的地址加上b字段地址偏移量轉化爲<code>*int16</code>類型指針，然後通過該指針更新x.b：</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-comment">//gopl.io/ch13/unsafeptr</span>
|
||||
|
||||
<span class="hljs-keyword">var</span> x <span class="hljs-keyword">struct</span> {
|
||||
@@ -2051,16 +2049,20 @@ pb := (*<span class="hljs-typename">int16</span>)(unsafe.Pointer(
|
||||
*pb = <span class="hljs-number">42</span>
|
||||
fmt.Println(x.b) <span class="hljs-comment">// "42"</span>
|
||||
</code></pre>
|
||||
<p>盡管寫法很繁瑣, 但在這里併不是一件壞事, 因爲這些功能應該很謹慎地使用. 不要試圖將引入可能而破壞代碼的正確性的 uintptr 臨時變量. 下面段代碼是不正確的:</p>
|
||||
<p>錯誤的原因很微妙. 有時候垃圾迴收器會移動一些變量以降低內存碎片的問題.這類垃圾迴收器被稱爲移動GC. 當一個變量被移動, 所有的保存改變量舊地址的指針必鬚同時被更新爲變量移動後的新地址. 從垃圾收集器的視角來看, 一個 <code>unsafe.Pointer</code> 是一個指針, 因此當變量被移動是對應的指針必鬚被更新, 但是 <code>uintptr</code> 隻是一個普通的數字, 所以其值不應該被改變. 上面錯誤的代碼因爲一個非指針的臨時變量 <code>tmp</code>, 導致垃圾收集器無法正確識别這個是一個指向變量 <code>x</code> 的指針. 第二個語句執行時, 變量 <code>x</code> 可能已經被轉移, 臨時變量 <code>tmp</code> 也就不在對應現在的 <code>&x.b</code>. 第三個賦值語句將徹底摧譭那個之前的那部分內存空間.</p>
|
||||
<p>有很多類似原因導致的錯誤. 例如這條語句:</p>
|
||||
<p>上面的寫法盡管很繁瑣，但在這里併不是一件壞事，因爲這些功能應該很謹慎地使用。不要試圖引入一個uintptr類型的臨時變量，因爲它可能會破壞代碼的安全性（譯註：這是眞正可以體會unsafe包爲何不安全的例子）。下面段代碼是錯誤的：</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-comment">// <span class="hljs-doctag">NOTE:</span> subtly incorrect! </span>
|
||||
tmp := <span class="hljs-typename">uintptr</span>(unsafe.Pointer(&x)) + unsafe.Offsetof(x.b)
|
||||
pb := (*<span class="hljs-typename">int16</span>)(unsafe.Pointer(tmp))
|
||||
*pb = <span class="hljs-number">42</span>
|
||||
</code></pre>
|
||||
<p>産生錯誤的原因很微妙。有時候垃圾迴收器會移動一些變量以降低內存碎片等問題。這類垃圾迴收器被稱爲移動GC。當一個變量被移動，所有的保存改變量舊地址的指針必鬚同時被更新爲變量移動後的新地址。從垃圾收集器的視角來看，一個unsafe.Pointer是一個指向變量的指針，因此當變量被移動是對應的指針也必鬚被更新；但是uintptr類型的臨時變量隻是一個普通的數字，所以其值不應該被改變。上面錯誤的代碼因爲引入一個非指針的臨時變量tmp，導致垃圾收集器無法正確識别這個是一個指向變量x的指針。當第二個語句執行時，變量x可能已經被轉移，這時候臨時變量tmp也就不再是現在的<code>&x.b</code>地址。第三個向之前無效地址空間的賦值語句將徹底摧譭整個程序！</p>
|
||||
<p>還有很多類似原因導致的錯誤。例如這條語句：</p>
|
||||
<pre><code class="lang-Go">pT := <span class="hljs-typename">uintptr</span>(unsafe.Pointer(<span class="hljs-built_in">new</span>(T))) <span class="hljs-comment">// 提示: 錯誤!</span>
|
||||
</code></pre>
|
||||
<p>這里併沒有指針引用 <code>new</code> 新創建的變量, 因此語句執行完成之後, 垃圾收集器有權迴收其內存空間, 所以返迴的 <code>pT</code> 保存將是無效的地址.</p>
|
||||
<p>目前的Go語言實現還沒有使用移動GC(未來可能實現), 但這不該是僥幸的理由: 當前的Go實現已經有移動變量的場景. 在5.2節我們提到goroutine的棧是根據需要動態增長的. 當這個時候, 原來棧中的所以變量可能需要被移動到新的更大的棧中, 所以我們無法確保變量的地址在整個使用週期內保持不變.</p>
|
||||
<p>在編寫本文時, 還沒有清晰的原則就指引Go程序員, 什麽樣 <code>unsafe.Pointer</code> 和 <code>uintptr</code> 的轉換是不安全的(參考 <a href="https://github.com/golang/go/issues/7192" target="_blank">Go issue7192</a>. 譯註: 該問題已經脩複.), 因此我們強烈建議按照最壞的方式處理. 將所有包含變量 <code>y</code> 地址的 <code>uintptr</code> 類型變量當作 BUG 處理, 同時減少不必要的 <code>unsafe.Pointer</code> 到 <code>uintptr</code> 的轉換. 在第一個例子中, 有三個到 <code>uintptr</code> 的轉換, 字段偏移量的運算, 所有的轉換全在一個表達式完成.</p>
|
||||
<p>當調用一個庫函數, 併且返迴的是 <code>uintptr</code> 類型是, 比如下面反射包中的相關函數,
|
||||
返迴的結果應該立卽轉換爲 <code>unsafe.Pointer</code> 以確保指針指向的是相同的變量.</p>
|
||||
<p>這里併沒有指針引用<code>new</code>新創建的變量，因此該語句執行完成之後，垃圾收集器有權馬上迴收其內存空間，所以返迴的pT將是無效的地址。</p>
|
||||
<p>雖然目前的Go語言實現還沒有使用移動GC（譯註：未來可能實現），但這不該是編寫錯誤代碼僥幸的理由：當前的Go語言實現已經有移動變量的場景。在5.2節我們提到goroutine的棧是根據需要動態增長的。當發送棧動態增長的時候，原來棧中的所以變量可能需要被移動到新的更大的棧中，所以我們併不能確保變量的地址在整個使用週期內是不變的。</p>
|
||||
<p>在編寫本文時，還沒有清晰的原則來指引Go程序員，什麽樣的unsafe.Pointer和uintptr的轉換是不安全的（參考 [Go issue7192](<a href="https://github.com/golang/go/issues/7192" target="_blank">https://github.com/golang/go/issues/7192</a> ）. 譯註: 該問題已經關閉），因此我們強烈建議按照最壞的方式處理。將所有包含變量地址的uintptr類型變量當作BUG處理，同時減少不必要的unsafe.Pointer類型到uintptr類型的轉換。在第一個例子中，有三個轉換——字段偏移量到uintptr的轉換和轉迴unsafe.Pointer類型的操作——所有的轉換全在一個表達式完成。</p>
|
||||
<p>當調用一個庫函數，併且返迴的是uintptr類型地址時（譯註：普通方法實現的函數不盡量不要返迴該類型。下面例子是reflect包的函數，reflect包和unsafe包一樣都是采用特殊技術實現的，編譯器可能給它們開了後門），比如下面反射包中的相關函數，返迴的結果應該立卽轉換爲unsafe.Pointer以確保指針指向的是相同的變量。</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-keyword">package</span> reflect
|
||||
|
||||
<span class="hljs-keyword">func</span> (Value) Pointer() <span class="hljs-typename">uintptr</span>
|
||||
|
||||
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="13.3" data-chapter-title="示例: 深度相等判斷" data-filepath="ch13/ch13-03.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="13.3" data-chapter-title="示例: 深度相等判斷" data-filepath="ch13/ch13-03.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2024,23 +2024,21 @@
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h2 id="133-示例-深度相等判斷">13.3. 示例: 深度相等判斷</h2>
|
||||
<p>來自 reflect 包的 DeepEqual 對兩個值進行深度相等判斷. DeepEqual 使用內建的 <code>==</code> 操作符對基礎類型進行相等判斷, 對於複合類型則遞歸變量每個基礎類型然後做類似的比較判斷. 因爲它工作在任意的類型上, 甚至對一些不支持 <code>==</code> 操作符的類型也可以工作, 因此在一些測試代碼中被廣泛地使用. 比如下面的代碼是用 DeepEqual 比較兩個字符串數組是否等價.</p>
|
||||
<p>來自reflect包的DeepEqual函數可以對兩個值進行深度相等判斷。DeepEqual函數使用內建的==比較操作符對基礎類型進行相等判斷，對於複合類型則遞歸該變量的每個基礎類型然後做類似的比較判斷。因爲它可以工作在任意的類型上，甚至對於一些不支持==操作運算符的類型也可以工作，因此在一些測試代碼中廣泛地使用該函數。比如下面的代碼是用DeepEqual函數比較兩個字符串數組是否相等。</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-keyword">func</span> TestSplit(t *testing.T) {
|
||||
got := strings.Split(<span class="hljs-string">"a:b:c"</span>, <span class="hljs-string">":"</span>)
|
||||
want := []<span class="hljs-typename">string</span>{<span class="hljs-string">"a"</span>, <span class="hljs-string">"b"</span>, <span class="hljs-string">"c"</span>};
|
||||
<span class="hljs-keyword">if</span> !reflect.DeepEqual(got, want) { <span class="hljs-comment">/* ... */</span> }
|
||||
}
|
||||
</code></pre>
|
||||
<p>盡管 DeepEqual 很方便, 而且可以支持任意的類型, 但是也有不足之處.
|
||||
例如, 它將一個 nil map 和 非 nil 的空的 map 視作不相等,
|
||||
同樣 nil slice 和 非 nil 的空的 slice 也不相等.</p>
|
||||
<p>盡管DeepEqual函數很方便，而且可以支持任意的數據類型，但是它也有不足之處。例如，它將一個nil值的map和非nil值但是空的map視作不相等，同樣nil值的slice 和非nil但是空的slice也視作不相等。</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-keyword">var</span> a, b []<span class="hljs-typename">string</span> = <span class="hljs-constant">nil</span>, []<span class="hljs-typename">string</span>{}
|
||||
fmt.Println(reflect.DeepEqual(a, b)) <span class="hljs-comment">// "false"</span>
|
||||
|
||||
<span class="hljs-keyword">var</span> c, d <span class="hljs-keyword">map</span>[<span class="hljs-typename">string</span>]<span class="hljs-typename">int</span> = <span class="hljs-constant">nil</span>, <span class="hljs-built_in">make</span>(<span class="hljs-keyword">map</span>[<span class="hljs-typename">string</span>]<span class="hljs-typename">int</span>)
|
||||
fmt.Println(reflect.DeepEqual(c, d)) <span class="hljs-comment">// "false"</span>
|
||||
</code></pre>
|
||||
<p>在這里定義一個自己的 Equal 函數用於比較人員的值. 和 DeepEqual 類似的是它也是基於 slice 和 map 的元素進行遞歸比較, 不同之處是它將 nil slice(map類似) 和非 nil 的空 slice 視作相等的值. 基礎部分的比較可以基於反射完成, 和 12.3 章的 Display 實現方法類似. 同樣, 我們頂一個一個內部函數 equal, 用於內部的遞歸比較. 目前不用關心 seen 參數. 對於每一對需要比較的 x 和 y, equal 函數 首先檢測它們是否都有效(或都無效), 然後檢測它們是否是相同的類型. 剩下的部分是一個大的 switch 分支, 用於擁有相同基礎類型的比較. 因爲頁面空間的限製, 我們省略了一些類似的分支.</p>
|
||||
<p>我們希望在這里實現一個自己的Equal函數，用於比較類型的值。和DeepEqual函數類似的地方是它也是基於slice和map的每個元素進行遞歸比較，不同之處是它將nil值的slice（map類似）和非nil值但是空的slice視作相等的值。基礎部分的比較可以基於reflect包完成，和12.3章的Display函數的實現方法類似。同樣，我們也定義了一個內部函數equal，用於內部的遞歸比較。讀者目前不用關心seen參數的具體含義。對於每一對需要比較的x和y，equal函數首先檢測它們是否都有效（或都無效），然後檢測它們是否是相同的類型。剩下的部分是一個鉅大的switch分支，用於相同基礎類型的元素比較。因爲頁面空間的限製，我們省略了一些相似的分支。</p>
|
||||
<pre><code class="lang-Go">gopl.io/ch13/equal
|
||||
<span class="hljs-keyword">func</span> equal(x, y reflect.Value, seen <span class="hljs-keyword">map</span>[comparison]<span class="hljs-typename">bool</span>) <span class="hljs-typename">bool</span> {
|
||||
<span class="hljs-keyword">if</span> !x.IsValid() || !y.IsValid() {
|
||||
@@ -2080,8 +2078,7 @@ fmt.Println(reflect.DeepEqual(c, d)) <span class="hljs-comment">// "false&q
|
||||
<span class="hljs-built_in">panic</span>(<span class="hljs-string">"unreachable"</span>)
|
||||
}
|
||||
</code></pre>
|
||||
<p>和前面的建議一樣, 我們不公開使用反射相關的接口,
|
||||
所以導齣的函數需要在內部自己將變量轉爲 reflect.Value 類型.</p>
|
||||
<p>和前面的建議一樣，我們併不公開reflect包相關的接口，所以導齣的函數需要在內部自己將變量轉爲reflect.Value類型。</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-comment">// Equal reports whether x and y are deeply equal.</span>
|
||||
<span class="hljs-keyword">func</span> Equal(x, y <span class="hljs-keyword">interface</span>{}) <span class="hljs-typename">bool</span> {
|
||||
seen := <span class="hljs-built_in">make</span>(<span class="hljs-keyword">map</span>[comparison]<span class="hljs-typename">bool</span>)
|
||||
@@ -2093,7 +2090,7 @@ fmt.Println(reflect.DeepEqual(c, d)) <span class="hljs-comment">// "false&q
|
||||
treflect.Type
|
||||
}
|
||||
</code></pre>
|
||||
<p>爲了確保算法對於循環數據結構也能正常退齣, 我們必鬚記録每次已經比較的變量, 從而避免進入第二次的比較. Equal 函數分配了一組用於比較的結構體, 包含每對比較對象的地址(unsafe.Pointer形式保存)和類型. 我們記録類型的原因是, 有些不同的變量可能對應相同的地址. 例如, 如果 x 和 y 都是數組類型, 那麽 x 和 <code>x[0]</code> 將對應相同的地址, y 和 <code>y[0]</code> 也是對應相同的地址, 這可以用於判斷 對x 和 y 比較 或 x[0] 和 y[0] 的是否進行過了.</p>
|
||||
<p>爲了確保算法對於有環的數據結構也能正常退齣，我們必鬚記録每次已經比較的變量，從而避免進入第二次的比較。Equal函數分配了一組用於比較的結構體，包含每對比較對象的地址（unsafe.Pointer形式保存）和類型。我們要記録類型的原因是，有些不同的變量可能對應相同的地址。例如，如果x和y都是數組類型，那麽x和x[0]將對應相同的地址，y和y[0]也是對應相同的地址，這可以用於區分x與y之間的比較或x[0]與y[0]之間的比較是否進行過了。</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-comment">// cycle check</span>
|
||||
<span class="hljs-keyword">if</span> x.CanAddr() && y.CanAddr() {
|
||||
xptr := unsafe.Pointer(x.UnsafeAddr())
|
||||
@@ -2108,13 +2105,13 @@ fmt.Println(reflect.DeepEqual(c, d)) <span class="hljs-comment">// "false&q
|
||||
seen[c] = <span class="hljs-constant">true</span>
|
||||
}
|
||||
</code></pre>
|
||||
<p>這是 Equal 函數的使用的例子:</p>
|
||||
<p>這是Equal函數用法的例子:</p>
|
||||
<pre><code class="lang-Go">fmt.Println(Equal([]<span class="hljs-typename">int</span>{<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>}, []<span class="hljs-typename">int</span>{<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>})) <span class="hljs-comment">// "true"</span>
|
||||
fmt.Println(Equal([]<span class="hljs-typename">string</span>{<span class="hljs-string">"foo"</span>}, []<span class="hljs-typename">string</span>{<span class="hljs-string">"bar"</span>})) <span class="hljs-comment">// "false"</span>
|
||||
fmt.Println(Equal([]<span class="hljs-typename">string</span>(<span class="hljs-constant">nil</span>), []<span class="hljs-typename">string</span>{})) <span class="hljs-comment">// "true"</span>
|
||||
fmt.Println(Equal(<span class="hljs-keyword">map</span>[<span class="hljs-typename">string</span>]<span class="hljs-typename">int</span>(<span class="hljs-constant">nil</span>), <span class="hljs-keyword">map</span>[<span class="hljs-typename">string</span>]<span class="hljs-typename">int</span>{})) <span class="hljs-comment">// "true"</span>
|
||||
</code></pre>
|
||||
<p>它甚至可以處理類似12.3章中導致Display陷入死循環的數據.</p>
|
||||
<p>Equal函數甚至可以處理類似12.3章中導致Display陷入陷入死循環的帶有環的數據。</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-comment">// Circular linked lists a -> b -> a and c -> c.</span>
|
||||
<span class="hljs-keyword">type</span> link <span class="hljs-keyword">struct</span> {
|
||||
value <span class="hljs-typename">string</span>
|
||||
@@ -2128,9 +2125,9 @@ fmt.Println(Equal(c, c)) <span class="hljs-comment">// "true"</span>
|
||||
fmt.Println(Equal(a, b)) <span class="hljs-comment">// "false"</span>
|
||||
fmt.Println(Equal(a, c)) <span class="hljs-comment">// "false"</span>
|
||||
</code></pre>
|
||||
<pre><code>練習 13.1: 定義一個深比較函數, 對於十億以內的數字比較, 忽略類型差異.
|
||||
練習 13.2: 編寫一個函數, 報告其參數是否循環數據結構.
|
||||
</code></pre>
|
||||
<p><strong>練習 13.1：</strong> 定義一個深比較函數，對於十億以內的數字比較，忽略類型差異。</p>
|
||||
<p><strong>練習 13.2：</strong> 編寫一個函數，報告其參數是否循環數據結構。</p>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
|
||||
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="13.4" data-chapter-title="通過cgo調用C代碼" data-filepath="ch13/ch13-04.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="13.4" data-chapter-title="通過cgo調用C代碼" data-filepath="ch13/ch13-04.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2024,19 +2024,35 @@
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h2 id="134-通過cgo調用c代碼">13.4. 通過cgo調用C代碼</h2>
|
||||
<p>Go程序可能會遇到要訪問C語言的某些硬件驅動的場景, 或者是從一個C++實現的嵌入式數據庫査詢記録的場景, 或者是使用Fortran實現的一些線性代數庫的場景. C作爲一個通用語言, 很多庫會選擇提供一個C兼容的API, 然後用其他語言實現.</p>
|
||||
<p>在本節中, 我們將構建一個簡易的數據壓縮程序, 通過使用一個Go語言自帶的叫cgo的用於支援C語言函數調用的工具. 這類工具被稱爲外圍函數接口(ffi), 併且cgo也不是Go中唯一的類似工具. SWIG(swig.org) 是類似的另一個被廣泛使用的工具, 它提供了很多複雜特性以支援C++的集成, 但 SWIG 不是這里要討論的主題.</p>
|
||||
<p>在標準庫的 <code>compress/...</code> 子目録有很多流行的壓縮算法的編碼和解碼實現, 包括LZW壓縮算法(Unix的compress命令用的算法)和DEFLATE壓縮算法(GNU gzip命令用的算法). 這些包的API的細節有些差異, 但是它們都提供了針對 <code>io.Writer</code> 的壓縮接口, 和提供了針對 <code>io.Reader</code> 的解壓縮接口. 例如:</p>
|
||||
<p>Go程序可能會遇到要訪問C語言的某些硬件驅動函數的場景，或者是從一個C++語言實現的嵌入式數據庫査詢記録的場景，或者是使用Fortran語言實現的一些線性代數庫的場景。C語言作爲一個通用語言，很多庫會選擇提供一個C兼容的API，然後用其他不同的編程語言實現（譯者：Go語言需要也應該擁抱這些鉅大的代碼遺産）。</p>
|
||||
<p>在本節中，我們將構建一個簡易的數據壓縮程序，使用了一個Go語言自帶的叫cgo的用於支援C語言函數調用的工具。這類工具一般被稱爲 <em>foreign-function interfaces</em> （簡稱ffi）, 併且在類似工具中cgo也不是唯一的。SWIG（ <a href="http://swig.org" target="_blank">http://swig.org</a> ）是另一個類似的且被廣泛使用的工具，SWIG提供了很多複雜特性以支援C++的特性，但SWIG併不是我們要討論的主題。</p>
|
||||
<p>在標準庫的<code>compress/...</code>子包有很多流行的壓縮算法的編碼和解碼實現，包括流行的LZW壓縮算法（Unix的compress命令用的算法）和DEFLATE壓縮算法（GNU gzip命令用的算法）。這些包的API的細節雖然有些差異，但是它們都提供了針對 io.Writer類型輸齣的壓縮接口和提供了針對io.Reader類型輸入的解壓縮接口。例如：</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-keyword">package</span> gzip <span class="hljs-comment">// compress/gzip</span>
|
||||
<span class="hljs-keyword">func</span> NewWriter(w io.Writer) io.WriteCloser
|
||||
<span class="hljs-keyword">func</span> NewReader(r io.Reader) (io.ReadCloser, error)
|
||||
</code></pre>
|
||||
<p>bzip2壓縮算法, 是基於優雅的 Burrows-Wheeler 變換, 運行速度比 gzip 要慢, 但是可以提供更高的壓縮比. 標準庫的 <code>compress/bzip2</code> 包目前還沒有提供 bzip2 算法的壓縮實現. 完全從頭實現是一個繁瑣的工作, 而且 bzip.org 有現成的 libbzip2 開源實現, 文檔齊全而且性能較好,</p>
|
||||
<p>如果C庫比較小, 我們可以用純Go重新實現一遍. 如果我們對性能沒有特殊要求, 我們可以用 <code>os/exec</code> 包的方法將C編寫的應用程序作爲一個子進行運行. 隻有當你需要使用複雜但是性能更高的底層C接口時, 就是使用cgo的場景了. 下面我們將通過一個例子講述cgo的用法.</p>
|
||||
<p>要使用 libbzip2, 我們需要一個 <code>bz_stream</code> 結構體, 用於保持輸入和輸齣緩存.
|
||||
然後有三個函數: BZ2_bzCompressInit 用於初始化緩存, BZ2_bzCompress 用於將輸入緩存的數據壓縮到輸齣緩存, BZ2_bzCompressEnd 用於釋放不需要的緩存.
|
||||
(目前不要擔心包的具體結構, 這個例子的目的就是演示各個部分如何組合在一起的)</p>
|
||||
<p>我們可以在Go代碼中直接調用 BZ2_bzCompressInit 和 BZ2_bzCompressEnd, 但是對於 BZ2_bzCompress, 我們將定義一個C語言的包裝函數, 爲了顯示他是如何完成的. 下面是C代碼, 對應一個獨立的文件.</p>
|
||||
<p>bzip2壓縮算法，是基於優雅的Burrows-Wheeler變換算法，運行速度比gzip要慢，但是可以提供更高的壓縮比。標準庫的compress/bzip2包目前還沒有提供bzip2壓縮算法的實現。完全從頭開始實現是一個壓縮算法是一件繁瑣的工作，而且 <a href="http://bzip.org" target="_blank">http://bzip.org</a> 已經有現成的libbzip2的開源實現，不僅文檔齊全而且性能又好。</p>
|
||||
<p>如果是比較小的C語言庫，我們完全可以用純Go語言重新實現一遍。如果我們對性能也沒有特殊要求的話，我們還可以用os/exec包的方法將C編寫的應用程序作爲一個子進程運行。隻有當你需要使用複雜而且性能更高的底層C接口時，就是使用cgo的場景了（譯註：用os/exec包調用子進程的方法會導致程序運行時依賴那個應用程序）。下面我們將通過一個例子講述cgo的具體用法。</p>
|
||||
<p>譯註：本章采用的代碼都是最新的。因爲之前已經齣版的書中包含的代碼隻能在Go1.5之前使用。從Go1.6開始，Go語言已經明確規定了哪些Go語言指針可以之間傳入C語言函數。新代碼重點是增加了bz2alloc和bz2free的兩個函數，用於bz_stream對象空間的申請和釋放操作。下面是新代碼中增加的註釋，説明這個問題：</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-comment">// The version of this program that appeared in the first and second</span>
|
||||
<span class="hljs-comment">// printings did not comply with the proposed rules for passing</span>
|
||||
<span class="hljs-comment">// pointers between Go and C, described here:</span>
|
||||
<span class="hljs-comment">// https://github.com/golang/proposal/blob/master/design/12416-cgo-pointers.md</span>
|
||||
<span class="hljs-comment">//</span>
|
||||
<span class="hljs-comment">// The rules forbid a C function like bz2compress from storing 'in'</span>
|
||||
<span class="hljs-comment">// and 'out' (pointers to variables allocated by Go) into the Go</span>
|
||||
<span class="hljs-comment">// variable 's', even temporarily.</span>
|
||||
<span class="hljs-comment">//</span>
|
||||
<span class="hljs-comment">// The version below, which appears in the third printing, has been</span>
|
||||
<span class="hljs-comment">// corrected. To comply with the rules, the bz_stream variable must</span>
|
||||
<span class="hljs-comment">// be allocated by C code. We have introduced two C functions,</span>
|
||||
<span class="hljs-comment">// bz2alloc and bz2free, to allocate and free instances of the</span>
|
||||
<span class="hljs-comment">// bz_stream type. Also, we have changed bz2compress so that before</span>
|
||||
<span class="hljs-comment">// it returns, it clears the fields of the bz_stream that contain</span>
|
||||
<span class="hljs-comment">// pointers to Go variables.</span>
|
||||
</code></pre>
|
||||
<p>要使用libbzip2，我們需要先構建一個bz_stream結構體，用於保持輸入和輸齣緩存。然後有三個函數：BZ2_bzCompressInit用於初始化緩存，BZ2_bzCompress用於將輸入緩存的數據壓縮到輸齣緩存，BZ2_bzCompressEnd用於釋放不需要的緩存。（目前不要擔心包的具體結構, 這個例子的目的就是演示各個部分如何組合在一起的。）</p>
|
||||
<p>我們可以在Go代碼中直接調用BZ2_bzCompressInit和BZ2_bzCompressEnd，但是對於BZ2_bzCompress，我們將定義一個C語言的包裝函數，用它完成眞正的工作。下面是C代碼，對應一個獨立的文件。</p>
|
||||
<pre><code class="lang-C">gopl.io/ch13/bzip
|
||||
|
||||
<span class="hljs-comment">/* This file is gopl.io/ch13/bzip/bzip2.c, */</span>
|
||||
@@ -2052,10 +2068,11 @@
|
||||
<span class="hljs-keyword">int</span> r = BZ2_bzCompress(s, action);
|
||||
*inlen -= s->avail_in;
|
||||
*outlen -= s->avail_out;
|
||||
s->next_in = s->next_out = <span class="hljs-literal">NULL</span>;
|
||||
<span class="hljs-keyword">return</span> r;
|
||||
}
|
||||
</code></pre>
|
||||
<p>現在讓我們轉到Go部分, 第一部分如下所示. 其中 <code>import "C"</code> 的語句是比較特别的. 其實併沒有一個叫 <code>C</code> 的包, 但是這行語句會讓Go構建在編譯之前先運行cgo工具.</p>
|
||||
<p>現在讓我們轉到Go語言部分，第一部分如下所示。其中<code>import "C"</code>的語句是比較特别的。其實併沒有一個叫C的包，但是這行語句會讓Go編譯程序在編譯之前先運行cgo工具。</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-comment">// Package bzip provides a writer that uses bzip2 compression (bzip.org).</span>
|
||||
<span class="hljs-keyword">package</span> bzip
|
||||
|
||||
@@ -2063,8 +2080,11 @@
|
||||
#cgo CFLAGS: -I/usr/include
|
||||
#cgo LDFLAGS: -L/usr/lib -lbz2
|
||||
#include <bzlib.h>
|
||||
#include <stdlib.h>
|
||||
bz_stream* bz2alloc() { return calloc(1, sizeof(bz_stream)); }
|
||||
int bz2compress(bz_stream *s, int action,
|
||||
char *in, unsigned *inlen, char *out, unsigned *outlen);
|
||||
void bz2free(bz_stream* s) { free(s); }
|
||||
*/</span>
|
||||
<span class="hljs-keyword">import</span> <span class="hljs-string">"C"</span>
|
||||
|
||||
@@ -2081,18 +2101,40 @@ int bz2compress(bz_stream *s, int action,
|
||||
|
||||
<span class="hljs-comment">// NewWriter returns a writer for bzip2-compressed streams.</span>
|
||||
<span class="hljs-keyword">func</span> NewWriter(out io.Writer) io.WriteCloser {
|
||||
<span class="hljs-keyword">const</span> (
|
||||
blockSize = <span class="hljs-number">9</span>
|
||||
verbosity = <span class="hljs-number">0</span>
|
||||
workFactor = <span class="hljs-number">30</span>
|
||||
)
|
||||
w := &writer{w: out, stream: <span class="hljs-built_in">new</span>(C.bz_stream)}
|
||||
<span class="hljs-keyword">const</span> blockSize = <span class="hljs-number">9</span>
|
||||
<span class="hljs-keyword">const</span> verbosity = <span class="hljs-number">0</span>
|
||||
<span class="hljs-keyword">const</span> workFactor = <span class="hljs-number">30</span>
|
||||
w := &writer{w: out, stream: C.bz2alloc()}
|
||||
C.BZ2_bzCompressInit(w.stream, blockSize, verbosity, workFactor)
|
||||
<span class="hljs-keyword">return</span> w
|
||||
}
|
||||
</code></pre>
|
||||
<p>在循環的每次迭代中, 向bz2compress傳入數據的地址和剩餘部分的長度, 還有輸齣緩存 w.outbuf 的地址和容量. 這兩個長度信息通過它們的地址傳入而不是值傳入, 因爲bz2compress函數可能會根據已經壓縮的數據和壓縮後數據的大小來更新這兩個值(譯註: 這里的用法有問題, 勘誤已經提到. 具體脩複的方法稍後再補充). 每個塊壓縮後的數據被寫入到底層的 io.Writer.</p>
|
||||
<p>Close 方法和 Write 方法有着類似的結構, 通過一個循環將剩餘的壓縮數據刷新到輸齣緩存.</p>
|
||||
<p>在預處理過程中，cgo工具爲生成一個臨時包用於包含所有在Go語言中訪問的C語言的函數或類型。例如C.bz_stream和C.BZ2_bzCompressInit。cgo工具通過以某種特殊的方式調用本地的C編譯器來發現在Go源文件導入聲明前的註釋中包含的C頭文件中的內容（譯註：<code>import "C"語句前僅捱着的註釋是對應cgo的特殊語法，對應必要的構建參數選項和C語言代碼</code>）。</p>
|
||||
<p>在cgo註釋中還可以包含#cgo指令，用於給C語言工具鏈指定特殊的參數。例如CFLAGS和LDFLAGS分别對應傳給C語言編譯器的編譯參數和鏈接器參數，使它們可以特定目録找到bzlib.h頭文件和libbz2.a庫文件。這個例子假設你已經在/usr目録成功安裝了bzip2庫。如果bzip2庫是安裝在不同的位置，你需要更新這些參數。</p>
|
||||
<p>NewWriter函數通過調用C語言的BZ2_bzCompressInit函數來初始化stream中的緩存。在writer結構中還包括了另一個buffer，用於輸齣緩存。</p>
|
||||
<p>下面是Write方法的實現，返迴成功壓縮數據的大小，主體是一個循環中調用C語言的bz2compress函數實現的。從代碼可以看到，Go程序可以訪問C語言的bz_stream、char和uint類型，還可以訪問bz2compress等函數，甚至可以訪問C語言中像BZ_RUN那樣的宏定義，全部都是以C.x語法訪問。其中C.uint類型和Go語言的uint類型併不相同，卽使它們具有相同的大小也是不同的類型。</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-keyword">func</span> (w *writer) Write(data []<span class="hljs-typename">byte</span>) (<span class="hljs-typename">int</span>, error) {
|
||||
<span class="hljs-keyword">if</span> w.stream == <span class="hljs-constant">nil</span> {
|
||||
<span class="hljs-built_in">panic</span>(<span class="hljs-string">"closed"</span>)
|
||||
}
|
||||
<span class="hljs-keyword">var</span> total <span class="hljs-typename">int</span> <span class="hljs-comment">// uncompressed bytes written</span>
|
||||
|
||||
<span class="hljs-keyword">for</span> <span class="hljs-built_in">len</span>(data) > <span class="hljs-number">0</span> {
|
||||
inlen, outlen := C.<span class="hljs-typename">uint</span>(<span class="hljs-built_in">len</span>(data)), C.<span class="hljs-typename">uint</span>(<span class="hljs-built_in">cap</span>(w.outbuf))
|
||||
C.bz2compress(w.stream, C.BZ_RUN,
|
||||
(*C.char)(unsafe.Pointer(&data[<span class="hljs-number">0</span>])), &inlen,
|
||||
(*C.char)(unsafe.Pointer(&w.outbuf)), &outlen)
|
||||
total += <span class="hljs-typename">int</span>(inlen)
|
||||
data = data[inlen:]
|
||||
<span class="hljs-keyword">if</span> _, err := w.w.Write(w.outbuf[:outlen]); err != <span class="hljs-constant">nil</span> {
|
||||
<span class="hljs-keyword">return</span> total, err
|
||||
}
|
||||
}
|
||||
<span class="hljs-keyword">return</span> total, <span class="hljs-constant">nil</span>
|
||||
}
|
||||
</code></pre>
|
||||
<p>在循環的每次迭代中，向bz2compress傳入數據的地址和剩餘部分的長度，還有輸齣緩存w.outbuf的地址和容量。這兩個長度信息通過它們的地址傳入而不是值傳入，因爲bz2compress函數可能會根據已經壓縮的數據和壓縮後數據的大小來更新這兩個值。每個塊壓縮後的數據被寫入到底層的io.Writer。</p>
|
||||
<p>Close方法和Write方法有着類似的結構，通過一個循環將剩餘的壓縮數據刷新到輸齣緩存。</p>
|
||||
<pre><code class="lang-Go"><span class="hljs-comment">// Close flushes the compressed data and closes the stream.</span>
|
||||
<span class="hljs-comment">// It does not close the underlying io.Writer.</span>
|
||||
<span class="hljs-keyword">func</span> (w *writer) Close() error {
|
||||
@@ -2101,6 +2143,7 @@ int bz2compress(bz_stream *s, int action,
|
||||
}
|
||||
<span class="hljs-keyword">defer</span> <span class="hljs-keyword">func</span>() {
|
||||
C.BZ2_bzCompressEnd(w.stream)
|
||||
C.bz2free(w.stream)
|
||||
w.stream = <span class="hljs-constant">nil</span>
|
||||
}()
|
||||
<span class="hljs-keyword">for</span> {
|
||||
@@ -2116,9 +2159,9 @@ int bz2compress(bz_stream *s, int action,
|
||||
}
|
||||
}
|
||||
</code></pre>
|
||||
<p>壓縮完成後, Close 用了 defer 確保函數退齣前調用 C.BZ2_bzCompressEnd 釋放輸入和輸齣流的緩存. 此刻 <code>w.stream</code> 指針將不在有效, 我們將它設置爲 nil 以保證安全, 然後在每個方法中增加 nil 檢測, 以防止用戶在關閉後依然錯誤使用相關方法.</p>
|
||||
<p>不僅僅寫是非併發安全的, 甚至併發調用 Close 和 Write 也可能導致C代碼的崩潰. 脩複這個問題是 練習13.3 的內容.</p>
|
||||
<p>下面的bzipper程序是使用我們自己包實現的bzip2壓縮命令. 它的行爲和許多Unix繫統的 bzip2 命令類似.</p>
|
||||
<p>壓縮完成後，Close方法用了defer函數確保函數退齣前調用C.BZ2_bzCompressEnd和C.bz2free釋放相關的C資源。此刻w.stream指針將不在有效，我們將它設置爲nil以保證安全，然後在每個方法中增加了nil檢測，以防止用戶在關閉後依然錯誤使用相關方法。</p>
|
||||
<p>上面的實現中，不僅僅寫是非併發安全的，甚至併發調用Close和Write方法也可能導致程序的的崩潰。脩複這個問題是練習13.3的內容。</p>
|
||||
<p>下面的bzipper程序，使用我們自己包實現的bzip2壓縮命令。它的行爲和許多Unix繫統的bzip2命令類似。</p>
|
||||
<pre><code class="lang-Go">gopl.io/ch13/bzipper
|
||||
|
||||
<span class="hljs-comment">// Bzipper reads input, bzip2-compresses it, and writes it out.</span>
|
||||
@@ -2141,7 +2184,7 @@ int bz2compress(bz_stream *s, int action,
|
||||
}
|
||||
}
|
||||
</code></pre>
|
||||
<p>在上面的場景中, 我們使用 bzipper 壓縮了 /usr/share/dict/words 繫統自帶的詞典, 從 938,848 字節壓縮到 335,405 字節, 大於是原始大小的三分之一. 然後使用繫統自帶的bunzip2命令進行解壓. 壓縮前後文件的SHA256哈希碼是相同了, 這也説明了我們的壓縮工具是可用的. (如果你的繫統沒有sha256sum命令, 那麽請先按照 練習4.2 實現一個類似的工具)</p>
|
||||
<p>在上面的場景中，我們使用bzipper壓縮了/usr/share/dict/words繫統自帶的詞典，從938,848字節壓縮到335,405字節。大約是原始數據大小的三分之一。然後使用繫統自帶的bunzip2命令進行解壓。壓縮前後文件的SHA256哈希碼是相同了，這也説明了我們的壓縮工具是正確的。（如果你的繫統沒有sha256sum命令，那麽請先按照練習4.2實現一個類似的工具）</p>
|
||||
<pre><code>$ go build gopl.io/ch13/bzipper
|
||||
$ wc -c < /usr/share/dict/words
|
||||
938848
|
||||
@@ -2151,9 +2194,9 @@ $ ./bzipper < /usr/share/dict/words | wc -c
|
||||
335405
|
||||
$ ./bzipper < /usr/share/dict/words | bunzip2 | sha256sum
|
||||
126a4ef38493313edc50b86f90dfdaf7c59ec6c948451eac228f2f3a8ab1a6ed -
|
||||
</code></pre><p>我們演示了將一個C庫鏈接到Go程序. 相反, 將Go編譯爲靜態庫然後鏈接到C程序, 或者將Go編譯爲動態庫然後在C程序中動態加載也都是可行的. 這里我們隻展示的cgo很小的一些方面, 更多的關於內存管理, 指針, 迴調函數, 信號處理, 字符串, errno處理, 終結器, 以及 goroutines 和繫統線程的關繫等, 有很多細節可以討論. 特别是如何將Go的指針傳入C函數的規則也是異常複雜的, 部分的原因在 13.2節 有討論到, 但是在Go1.5中還沒有被明確. 如果要進一步閲讀, 可以從 <a href="https://golang.org/cmd/cgo" target="_blank">https://golang.org/cmd/cgo</a> 開始.</p>
|
||||
<p><strong>練習13.3:</strong> 使用 sync.Mutex 以保證 bzip2.writer 在多個 goroutines 中被併發調用是安全的.</p>
|
||||
<p><strong>練習13.4:</strong> 因爲C庫依賴的限製. 使用 <code>os/exec</code> 包啟動 <code>/bin/bzip2</code> 命令作爲一個子進程, 提供一個純Go的 bzip.NewWriter 的替代實現.</p>
|
||||
</code></pre><p>我們演示了如何將一個C語言庫鏈接到Go語言程序。相反, 將Go編譯爲靜態庫然後鏈接到C程序，或者將Go程序編譯爲動態庫然後在C程序中動態加載也都是可行的（譯註：在Go1.5中，Windows繫統的Go語言實現併不支持生成C語言動態庫或靜態庫的特性。不過好消息是，目前已經有人在嚐試解決這個問題，具體請訪問 <a href="https://github.com/golang/go/issues/11058" target="_blank">Issue11058</a> ）。這里我們隻展示的cgo很小的一些方面，更多的關於內存管理、指針、迴調函數、中斷信號處理、字符串、errno處理、終結器，以及goroutines和繫統線程的關繫等，有很多細節可以討論。特别是如何將Go語言的指針傳入C函數的規則也是異常複雜的（譯註：簡單來説，要傳入C函數的Go指針指向的數據本身不能包含指針或其他引用類型；併且C函數在返迴後不能繼續持有Go指針；併且在C函數返迴之前，Go指針是被鎖定的，不能導致對應指針數據被移動或棧的調整），部分的原因在13.2節有討論到，但是在Go1.5中還沒有被明確（譯註：Go1.6將會明確cgo中的指針使用規則）。如果要進一步閲讀，可以從 <a href="https://golang.org/cmd/cgo" target="_blank">https://golang.org/cmd/cgo</a> 開始。</p>
|
||||
<p><strong>練習 13.3：</strong> 使用sync.Mutex以保證bzip2.writer在多個goroutines中被併發調用是安全的。</p>
|
||||
<p><strong>練習 13.4：</strong> 因爲C庫依賴的限製。 使用os/exec包啟動/bin/bzip2命令作爲一個子進程，提供一個純Go的bzip.NewWriter的替代實現（譯註：雖然是純Go實現，但是運行時將依賴/bin/bzip2目録，其他操作繫統可能無法運行）。</p>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
@@ -37,7 +37,7 @@
|
||||
|
||||
|
||||
|
||||
<link rel="next" href="../errata.html" />
|
||||
<link rel="next" href="../CONTRIBUTORS.html" />
|
||||
|
||||
|
||||
<link rel="prev" href="../ch13/ch13-04.html" />
|
||||
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="13.5" data-chapter-title="幾點忠告" data-filepath="ch13/ch13-05.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="13.5" data-chapter-title="幾點忠告" data-filepath="ch13/ch13-05.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2024,11 +2024,11 @@
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h2 id="135-幾點忠告">13.5. 幾點忠告</h2>
|
||||
<p>我們在前一章結尾的時候, 我們警告要謹慎使用反射. 那些警告同樣適用於本章的 unsafe 包.</p>
|
||||
<p>高級語言使得程序員不用在關繫眞正運行程序的指令細節, 同時也不再需要關註許多如內部布局之類的無關實現細節. 因爲這個絶緣的抽象層, 我們可以編寫安全健壯的, 併且可以運行在不同操作繫統上的具有高度可移植性的程序.</p>
|
||||
<p>但是 unsafe 包, 讓程序員可以透過這個絶緣的抽象層使用使用一些必要的功能, 或者是爲了更高的性能. 代價就是犧牲了可移植性和程序安全, 因此使用 unsafe 是一個危險的行爲. 我們對何時以及如何使用unsafe包的建議和我們在11.5節提到的Knuth對過早優化的建議類似. 大多數Go程序員可能永遠不會需要直接使用unsafe包. 當然, 永遠都會有一些用 unsafe 包實現會更簡單的場景. 如果確實認爲使用 unsafe 包是最理想的方式, 那麽應該盡可能將它限製較小的范圍, 那樣其他代碼忽略unsafe的影響.</p>
|
||||
<p>現在, 把最後兩章拋入腦後吧. 編寫一些實在的應用. 遠離reflect的unsafe包, 除非你確實需要它們.</p>
|
||||
<p>用Go快樂地編程. 我們希望你能像我們一樣喜歡Go語言.</p>
|
||||
<p>我們在前一章結尾的時候，我們警告要謹慎使用reflect包。那些警告同樣適用於本章的unsafe包。</p>
|
||||
<p>高級語言使得程序員不用在關心眞正運行程序的指令細節，同時也不再需要關註許多如內存布局之類的實現細節。因爲高級語言這個絶緣的抽象層，我們可以編寫安全健壯的，併且可以運行在不同操作繫統上的具有高度可移植性的程序。</p>
|
||||
<p>但是unsafe包，它讓程序員可以透過這個絶緣的抽象層直接使用一些必要的功能，雖然可能是爲了穫得更好的性能。但是代價就是犧牲了可移植性和程序安全，因此使用unsafe包是一個危險的行爲。我們對何時以及如何使用unsafe包的建議和我們在11.5節提到的Knuth對過早優化的建議類似。大多數Go程序員可能永遠不會需要直接使用unsafe包。當然，也永遠都會有一些需要使用unsafe包實現會更簡單的場景。如果確實認爲使用unsafe包是最理想的方式，那麽應該盡可能將它限製在較小的范圍，那樣其它代碼就忽略unsafe的影響。</p>
|
||||
<p>現在，趕緊將最後兩章拋入腦後吧。編寫一些實實在在的應用是眞理。請遠離reflect的unsafe包，除非你確實需要它們。</p>
|
||||
<p>最後，用Go快樂地編程。我們希望你能像我們一樣喜歡Go語言。</p>
|
||||
|
||||
|
||||
</section>
|
||||
@@ -2042,7 +2042,7 @@
|
||||
<a href="../ch13/ch13-04.html" class="navigation navigation-prev " aria-label="Previous page: 通過cgo調用C代碼"><i class="fa fa-angle-left"></i></a>
|
||||
|
||||
|
||||
<a href="../errata.html" class="navigation navigation-next " aria-label="Next page: 勘誤"><i class="fa fa-angle-right"></i></a>
|
||||
<a href="../CONTRIBUTORS.html" class="navigation navigation-next " aria-label="Next page: 附録"><i class="fa fa-angle-right"></i></a>
|
||||
|
||||
</div>
|
||||
</div>
|
||||
|
||||
@@ -48,7 +48,7 @@
|
||||
<body>
|
||||
|
||||
|
||||
<div class="book" data-level="13" data-chapter-title="底層編程" data-filepath="ch13/ch13.md" data-basepath=".." data-revision="Mon Dec 21 2015 12:51:02 GMT+0800 (中国标准时间)">
|
||||
<div class="book" data-level="13" data-chapter-title="底層編程" data-filepath="ch13/ch13.md" data-basepath=".." data-revision="Thu Dec 24 2015 14:42:02 GMT+0800 (中国标准时间)">
|
||||
|
||||
|
||||
<div class="book-summary">
|
||||
@@ -1975,16 +1975,16 @@
|
||||
|
||||
</li>
|
||||
|
||||
<li class="chapter " data-level="14" data-path="errata.html">
|
||||
<li class="chapter " data-level="14" data-path="CONTRIBUTORS.html">
|
||||
|
||||
|
||||
<a href="../errata.html">
|
||||
<a href="../CONTRIBUTORS.html">
|
||||
|
||||
<i class="fa fa-check"></i>
|
||||
|
||||
<b>14.</b>
|
||||
|
||||
勘誤
|
||||
附録
|
||||
</a>
|
||||
|
||||
|
||||
@@ -2024,16 +2024,15 @@
|
||||
<section class="normal" id="section-">
|
||||
|
||||
<h1 id="第13章-底層編程">第13章 底層編程</h1>
|
||||
<p>Go的設計包含了諸多安全策略, 限製了可能導致程序錯誤的用法. 編譯時類型檢査檢測可以發現大多數類型不匹配的變量操作, 例如兩個字符串做減法的錯誤. 字符串, 字典, 切片 和管道等所有的內置類型, 都有嚴格的類型轉換規則.</p>
|
||||
<p>對於無法靜態檢測到的錯誤, 例如數組訪問越界或使用空指針, 動態檢測可以保證程序在遇到問題的時候立卽終止併打印相關的錯誤信息. 自動內存管理(垃圾迴收)消除了大部分野指針和內存洩漏的問題.</p>
|
||||
<p>Go的實現刻意隱藏了很多底層細節. 我們無法知道一個結構體的內存布局, 也無法穫取一個運行函數的機器碼, 也無法知道當前的 goroutine 是運行在哪個操作繫統線程上. 事實上, Go的調度器會自己決定是否需要將 goroutine 從一個操作繫統線程轉移到另一個操作繫統線程. 一個指向變量的指針也併沒有展示變量眞實的地址. 因爲垃圾迴收器會根據需要移動變量的位置, 當然對應的也會被自動更新.</p>
|
||||
<p>總的來説, Go語言的這些特殊使得Go程序相比較低級的C語言來説, 更容易預測, 更容易理解, 也不容易崩潰. 通過隱藏底層的細節, 也使得Go程序具有高度的可移植性, 因爲語言的語義在很大程度上是獨立於任何編譯器, 操作繫統和CPU繫統結構的(當然也不完全絶對獨立: 例如CPU字的大小, 某些表達式求值的順序, 還有編譯器實現的一些限製).</p>
|
||||
<p>有時候我們可能會放棄部分語言特性而優先選擇更好的性能優化, 與其他語言編寫的庫互操作, 或者不用純Go語言來實現某些函數.</p>
|
||||
<p>在本章, 我們將展示如何使用 unsafe 包來襬脫通常的規則限製, 如何創建C函數庫的綁定, 以及如何進行繫統調用.</p>
|
||||
<p>本章描述的方法不應該輕易使用. 如果沒有處理好細節, 它們可能導致各種不可預測的隱晦的錯誤, 甚至連本地的C程序員也無法理解. 使用 unsafe 包同時也無法保證與未來版本的兼容性, 因爲在有意無意中會使用很多實現的細節, 而這些實現的細節在未來很可能會改變.</p>
|
||||
<p>unsafe 包的實現比較特殊. 雖然它可以和普通包一樣的導入和使用, 但它實際上是由編譯器實現的. 它提供了一些訪問語言內部特性的方法, 特别是內存布局相關的細節.
|
||||
將這些特别封裝到一個獨立的包中, 是爲在極少數情況下需要使用的時候, 引起人們的註意(它們是不安全的). 此外, 有一些環境因爲安全的因素可能限製這個包的使用.</p>
|
||||
<p>unsafe 包被廣泛地用於比較低級的包, 例如 runtime, os, syscall 還有 net 等, 因爲它們需要和操作繫統密切配合的, 但是普通的程序一般是不需要的.</p>
|
||||
<p>Go語言的設計包含了諸多安全策略，限製了可能導致程序運行齣現錯誤的用法。編譯時類型檢査檢査可以發現大多數類型不匹配的操作，例如兩個字符串做減法的錯誤。字符串、map、slice和chan等所有的內置類型，都有嚴格的類型轉換規則。</p>
|
||||
<p>對於無法靜態檢測到的錯誤，例如數組訪問越界或使用空指針，運行時動態檢測可以保證程序在遇到問題的時候立卽終止併打印相關的錯誤信息。自動內存管理（垃圾內存自動迴收）可以消除大部分野指針和內存洩漏相關的問題。</p>
|
||||
<p>Go語言的實現刻意隱藏了很多底層細節。我們無法知道一個結構體眞實的內存布局，也無法穫取一個運行時函數對應的機器碼，也無法知道當前的goroutine是運行在哪個操作繫統線程之上。事實上，Go語言的調度器會自己決定是否需要將某個goroutine從一個操作繫統線程轉移到另一個操作繫統線程。一個指向變量的指針也併沒有展示變量眞實的地址。因爲垃圾迴收器可能會根據需要移動變量的內存位置，當然變量對應的地址也會被自動更新。</p>
|
||||
<p>總的來説，Go語言的這些特性使得Go程序相比較低級的C語言來説更容易預測和理解，程序也不容易崩潰。通過隱藏底層的實現細節，也使得Go語言編寫的程序具有高度的可移植性，因爲語言的語義在很大程度上是獨立於任何編譯器實現、操作繫統和CPU繫統結構的（當然也不是完全絶對獨立：例如int等類型就依賴於CPU機器字的大小，某些表達式求值的具體順序，還有編譯器實現的一些額外的限製等）。</p>
|
||||
<p>有時候我們可能會放棄使用部分語言特性而優先選擇更好具有更好性能的方法，例如需要與其他語言編寫的庫互操作，或者用純Go語言無法實現的某些函數。</p>
|
||||
<p>在本章，我們將展示如何使用unsafe包來襬脫Go語言規則帶來的限製，講述如何創建C語言函數庫的綁定，以及如何進行繫統調用。</p>
|
||||
<p>本章提供的方法不應該輕易使用（譯註：屬於黑魔法，雖然可能功能很強大，但是也容易誤傷到自己）。如果沒有處理好細節，它們可能導致各種不可預測的併且隱晦的錯誤，甚至連有經驗的的C語言程序員也無法理解這些錯誤。使用unsafe包的同時也放棄了Go語言保證與未來版本的兼容性的承諾，因爲它必然會在有意無意中會使用很多實現的細節，而這些實現的細節在未來的Go語言中很可能會被改變。</p>
|
||||
<p>要註意的是，unsafe包是一個采用特殊方式實現的包。雖然它可以和普通包一樣的導入和使用，但它實際上是由編譯器實現的。它提供了一些訪問語言內部特性的方法，特别是內存布局相關的細節。將這些特性封裝到一個獨立的包中，是爲在極少數情況下需要使用的時候，同時引起人們的註意（譯註：因爲看包的名字就知道使用unsafe包是不安全的）。此外，有一些環境因爲安全的因素可能限製這個包的使用。</p>
|
||||
<p>不過unsafe包被廣泛地用於比較低級的包, 例如runtime、os、syscall還有net包等，因爲它們需要和操作繫統密切配合，但是對於普通的程序一般是不需要使用unsafe包的。</p>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
Reference in New Issue
Block a user