可信C語言：讓C語言達到和RUST一樣的安全性

1. 所有權

所有運行的程序都必須管理其使用計算機內存的方式。一些語言中具有GC（Garbage Collection）機制，在程序運行時不斷地尋找不再使用的內存（典型代表Java）；在另一些語言中，程序員必須親自分配和釋放內存（典型代表C/C++），容易出錯，不安全，經常被人詬病，一旦出現問題，調試工作巨大，讓人沮喪；還有一些語言采用了ARC（Automatic Reference Counting）的機制（典型代表Object C和C++智能指針），據說ARC比傳統GC機制性能好。Rust 則選擇了另外一種方式：通過所有權系統管理內存，編譯器在編譯時會根據一系列的規則進行檢查。在運行時，所有權系統的任何功能都不會減慢程序。Rust號稱是安全語言，其核心功能就是“所有權（ownership）”。

C語言作為系統開發語言，不太可能全部遷移至C++或OC，在可以預期的時間遷移到Rust更加不可能，Rust特別有意設計的和C不一樣的表達式語法，對廣大系統軟件工程師來說，學習成本就非常大，更別提實際遷移工作量了。

因此，吸收Rust的所有權思想并引入到C語言中提升C語言的安全性是一件非常有意義的事，在工具鏈上需要通過開發簡單的插件來達到和RUST編譯器一樣的檢查功能，我們姑且把這個插件叫做檢查器。

我們也姑且把這種C語言稱為TC（可信的C？隨便取的，主要為了方便區分和后文描述）。

1.1. 棧（Stack）與堆（Heap）

在很多語言（比如Java和OC）中，你并不需要經常考慮到棧與堆。不過在像 C/Rust 這樣的系統編程語言中，值是位于棧上還是堆上在更大程度上影響了語言的行為以及為何必須做出這樣的抉擇。

棧和堆都是代碼在運行時可供使用的內存，但是它們的結構不同。棧以放入值的順序存儲值并以相反順序取出值。這也被稱作后進先出（last in, first out）。想象一下一疊盤子：當增加更多盤子時，把它們放在盤子堆的頂部，當需要盤子時，也從頂部拿走。不能從中間也不能從底部增加或拿走盤子！增加數據叫做進棧（pushing onto the stack），而移出數據叫做出棧（popping off the stack）。

棧的操作是十分快速的，這主要是得益于它存取數據的方式：因為數據存取的位置總是在棧頂而不需要尋找一個位置存放或讀取數據。另一個讓操作棧快速的屬性是，棧中的所有數據都必須占用已知且固定的大小。

在編譯時大小未知或大小可能變化的數據，要改為存儲在堆上。堆是缺乏組織的：當向堆放入數據時，你要請求一定大小的空間。操作系統在堆的某處找到一塊足夠大的空位，把它標記為已使用，并返回一個表示該位置地址的指針（pointer）。這個過程稱作在堆上分配內存（allocating on the heap），有時簡稱為 “分配”（allocating）。將數據推入棧中并不被認為是分配。因為指針的大小是已知并且固定的，你可以將指針存儲在棧上，不過當需要實際數據時，必須訪問指針。

想象一下去餐館就座吃飯。當進入時，你說明有幾個人，餐館員工會找到一個夠大的空桌子并領你們過去。如果有人來遲了，他們也可以通過詢問來找到你們坐在哪。

當你的代碼調用一個函數時，傳遞給函數的值（包括可能指向堆上數據的指針）如果超出允許的寄存器用量時會被壓入棧中，函數的局部變量也會被壓入棧中。當函數結束時，這些值被移出棧，這是由操作系統自動管理的，程序員并不需要關心。但操作系統對堆上數據并不會自動清理，因此，跟蹤哪部分代碼正在使用堆上的哪些數據，最大限度的減少堆上的重復數據的數量，以及清理堆上不再使用的數據確保不會耗盡空間，這些問題正是所有權系統要處理的。一旦理解了所有權，你就不需要經常考慮棧和堆了，不過明白了所有權的存在就是為了管理堆數據，能夠幫助解釋為什么所有權要以這種方式工作。

1.2. 所有權規則

首先，讓我們看一下所有權的規則。當我們通過舉例說明時，請謹記這些規則：

1）TC中的每一個值都有一個被稱為其所有者（owner）的變量。

2）值有且只有一個所有者。

3）當所有者（變量）離開作用域，這個值將被丟棄。

1.3. 變量作用域

變量的作用域（scope）是一個項（item）在程序中有效的范圍。假設有這樣一個變量：

int i = 0;

跟其他編程語言類似，C和TC一樣，作用域由該變量最近的一組{}來圈定。

{

// i 在這里無效, 它尚未聲明

int i = 0;// 從此處起，i 是有效的

// 使用 i

}// 此作用域已結束，i 不再有效

換句話說，這里有兩個重要的時間點：

1) 當i進入作用域時，它就是有效的；

2) 一直持續到它離開作用域為止。

1.4. 復雜類型

前面介紹的基本數據類型是存儲在棧上的并且當離開作用域時被移出棧，這是很容易理解的已有機制，不是所有權要解決的核心問題。現在我們需要尋找一個存儲在堆上的復雜數據來探索TC是如何知道該在何時清理數據的。在C語言中，數據類型比較簡單，所謂復雜類型就是指字符串、結構體和聯合體。

1.5. 內存與分配

就字符串常量來說，我們在編譯時就知道其內容，所以文本被直接硬編碼進最終的可執行文件中。這使得字符串并不占用棧或堆的空間。不過這些特性都只得益于字符串字面值的不可變性。不幸的是，我們不能為了每一個在編譯時大小未知的文本而將一塊內存放入二進制文件中，并且它的大小還可能隨著程序運行而改變，用放在棧上的局部數組來存放也是不安全的，可能會導致棧空間的耗盡。

對于字符串類型，為了支持一個可變，可增長的文本片段，如在需要容納一個不確定的外部輸入時，一般需要在堆上分配一塊在編譯時未知大小的內存來存放內容。這意味著：

必須在運行時向操作系統請求堆內存。需要一個當我們處理完字符串時將內存返回給操作系統的方法。

C語言調用malloc庫函數來申請堆空間，然后要識別出不再使用的內存并調用free庫函數顯式釋放，這是程序員的責任，跟請求內存的時候一樣。從歷史的角度上說正確處理內存回收曾經是一個困難的編程問題。如果忘記回收了會浪費內存。如果過早回收了，將會出現無效變量。如果重復回收，一樣會引發異常。這些都可能會引起嚴重的安全問題。

TC采取了一個不同的策略：內存在擁有它的變量離開作用域后就被自動釋放。下面是作用域的例子，例子中計劃使用一個堆空間來存放字符串，而不是一個基本變量：

{

// str 在這里無效, 它尚未聲明

char *str = (char *)malloc（XXX）;

// 如申請空間成功，從此處起，str是有效的

// 使用str

}// 此作用域已結束，str被檢查器自動釋放

這是一個將str需要的內存返回給操作系統的很自然的位置：當 str 離開作用域的時候。TC的檢查器為我們調用一個特殊的函數，這個函數就是free，在結尾的 } 處自動添加free調用。如果程序員已經手工調用free函數，檢查器會給出提示，不會再重復釋放。不建議程序員手工調用free函數。

注意：在 C++ 中，這種 item 在生命周期結束時釋放資源的模式有時被稱作資源獲取即初始化（Resource Acquisition Is Initialization (RAII)）。如果你使用過 RAII 模式的話，應該對此做法并不陌生。

這個模式對編寫TC代碼的方式有著深遠的影響。現在它看起來很簡單，不過在更復雜的場景下代碼的行為可能是不可預測的，比如當有多個變量使用在堆上分配的內存時。現在讓我們探索一些這樣的場景。

1.6. 所有權轉移

先讓我們看一個使用基本類型的例子：

int x = 5;

int y = x;

將變量 x 的整數值賦給 y，我們都很清楚這是在干什么：“將x初始化為 5，接著將 x 的值拷貝到 y”。現在有了兩個變量，x 和 y，都等于 5。這也正是事實上發生了的，因為整數是有已知固定大小的簡單值，所以這兩個 5 被放入了棧中。

現在來看這個例子的字符串版本：

char *s1 = (char *)malloc(XXX);

char *s2 = s1;

這看起來與上面的代碼非常類似，如果不了解C語言，我們可能會假設他們的運行方式也是類似的：也就是說，第二行可能會生成一個 s1 的拷貝，并將其地址賦值給 s2 。C程序員都知道，事實上并不是這樣，而是s2和s1都指向了同一個堆空間。如下圖所示：

這種“一房多賣”的情況在C語言中是一件讓人非常頭痛的事，比如出現多次釋放，或者釋放后使用的問題。

TC語言并不會改成上述假想的那樣，為S2重新申請一塊空間，并將數據從S1指向的空間拷貝過來。程序員都知道內存的拷貝是一件很影響性能的事。TC語言為了確保內存安全，這種場景下，TC會認為 s1 不再有效，檢查器會自動添加s1=NULL這樣的語句。看看在 s2 被創建之后嘗試使用 s1 會發生什么。這段代碼不能運行：

char *s1 = (char *)malloc(XXX);

char *s2 = s1;

……

printf( "s1=%s!", s1 );

檢查器會強烈提示錯誤，并拒絕進行下一步編譯運行動作，否則你的程序可能會奔潰，因為 s1 已經是一個空指針。

如果你在其他語言中聽說過術語淺拷貝（shallow copy）和深拷貝（deep copy），那么拷貝指針、長度和容量而不拷貝數據可能聽起來像淺拷貝。不過因為 TC 同時使第一個變量無效了，這個操作被稱為移動（move），而不是任何一種拷貝。上面的例子可以解讀為 s1 被移動到了 s2 中。如下圖所示：

這樣就解決了我們前面講的“一房多賣”的問題！因為只有 s2 是有效的，當s2離開作用域，檢查器會添加自動釋放的語句，完畢。

C程序員都知道如果需要復制一個副本，需要再次另外申請空間，并用memcpy此類的函數來進行數據復制。安全專家們都知道memcpy是一個非常危險的操作，但它的安全性并不是“所有權”要解決問題的范疇。

1.7. 所有權遺棄

轉移接收了其它所有權，原先的所有權自動遺棄，畢竟我們是不允許腳踏兩只船的。從空間被釋放的時間點來看，這一做法和ARC機制非常類似。

char *s1 = (char *)malloc(XXX);

char *s2 = (char *)malloc(XXX);

s2 = s1;

//s2原有空間被遺棄，檢查器會去釋放它，s1的空間轉給s2，s1置空

程序運行情況如下圖所示：

1.8. 永久所有權

前面已經講到所有權是為了解決堆上分配問題而做的優化，但這并不意味著所有權概念僅用于堆上空間。比如位于棧上、位于代碼段和數據段的基本數據類型（含數組），這些空間的所有權就是其變量，但和堆空間不同的是，這些變量對該空間擁有永久所有權，永久所有權不能轉移給其它變量，也不能丟棄。

char *str = "Hello, TC!";// 錯誤語法，檢查器會報錯

char str[] = "Hello, TC!";// 正確語法，永久所有權

char str[XXX];// 正確語法，永久所有權

char *str1 = str;// 錯誤，永久所有權不能轉移

C程序員可能會對最后一句提出嚴重的抗議，但這確實是TC語言所不同的地方，永久所有權不能被轉移，但在后面章節可以看到，它可以被借用。因此，需要完成正常的功能是沒有問題的，只是更安全而已。

1.9. 所有權與函數

將基本類型的形參傳遞給函數實參時，在語義上與給變量賦值相似，是一種值的傳遞。但對于復雜類型指針向函數傳遞時可能會產生所有權移動，就像賦值語句一樣。下面例子使用注釋展示變量何時進入和離開作用域：

void main( )

{

int i1 = 5;// i1 進入作用域

char *s1 = (char *)malloc(xxx);// s1 進入作用域

takes_ownership( i1, s1 );// i1 的值復制給函數里

// s1 的值移動到函數里 ...

// 所以到這里,s1不再有效

// 但可繼續使用 i1

}// s1的空間已被移走，檢查器會自動置空，程序員無需關心釋放問題。

void takes_ownership( int i2, char *s2 )

{

// i2,s2 進入作用域

} //s2移出作用域,檢查器自動釋放s2空間。i2在棧上，無需任何操作。

當嘗試在調用 takes_ownership 后使用 s1 時，檢查器會強烈提示錯誤，并拒絕進行下一步編譯運行動作，否則運行起來系統可能會奔潰。

1.10. 返回值與作用域

在某些場景下，調用一個函數對s1進行處理后，我還需要繼續處理s1，但s1已經失去空間所有權，這怎么辦呢？方法是讓函數再將所有權返回。

void main()

{

char *s1 = (char *)malloc(xxx);// s1 進入作用域

……

s1 = takes_and_gives_back(s1);// s1 被移動到

// takes_and_gives_back 中,

// 它也將返回值移給 s1

……繼續使用s1……

} // 這里, s1 移出作用域并被檢查器釋放

char * takes_and_gives_back( char *s2 )

{

// s2 進入作用域

……

return s2;// 返回所有權給調用者

}// s2所有權已經轉移，檢查器在這里不需要做特殊處理

每次都傳進去再返回來就有點煩人，除此之外，我們也可能想返回函數體中產生的一些數據，就無法返回所有權了，C語言只允許返回一個值的。

我們不想這么啰嗦和形式化，那能否要函數使用一個值但不獲取所有權呢？請參見下一章“所有權借用”。

1.11. 結構體的所有權

1.11.1. 所有權的包含關系

前面大部分內容都是以字符串為例介紹的，但在復雜數據類型中，還有結構體struct和聯合體union兩種，以struct為例來介紹其所有權問題。先看一個例子：

typedef struct staff

{

char name[10];

int age;

}STAFF_T;

我們定義了一個新的struct型的數據類型STAFF_T，然后實例化一個staff數據：

STAFF_T *staff_a = (STAFF_T *)malloc(sizeof(STAFF_T));

staff_a擁有該示例的所有權，遵循上述所有權的相關規定，可以遺棄、轉移和出借。這個例子比較簡單，因為struct的成員全部是基本數據類型，如果struct含有復雜數據類型情況會如何呢？繼續看復雜一點的例子,加入addr成員長短差異較大，程序員采用動態分配內存的方法：

typedef struct staff

{

char name[10];

int age;

char *addr;

}STAFF_T;

實例化（所有舉例代碼僅為說明問題，不考慮異常問題）：

STAFF_T *staff_a = (STAFF_T *)malloc(sizeof(STAFF_T));

staff_a->addr = (char *)malloc(100);

這個時候再內存中存在兩塊內存，示意圖如下：

這個時候新的情況出現了，前面說第一塊內存的所有權是staff_a的，那第二塊內存的所有權屬于誰呢？我們認為第二塊內存的所有權屬于staff_a的成員addr，并不屬于staff_a，雖然他們存在緊密關系，這是特別要注意的地方。

當staff_a被釋放或遺棄時，如果addr也有空間存在，會被一并自動釋放，無需程序員手工處理。但能夠釋放的前提條件是其所有權（第二章介紹）沒有被借用。

總之，理解了所有權的本質是空間被一個變量所關聯，就不難理解結構體相關的所有權知識了。

1.11.2. 復雜數據成員所有權的轉移

在結構體含有復雜數據類型成員時，所有權轉移會比較復雜一點，主要是需要考慮其包含的下一級所有權是否存在。下面還是以STAFF_T結構體為例來解釋。

typedef struct staff

{

char name[10];

int age;

char *addr;

}STAFF_T;

實例化staff_a：

STAFF_T *staff_a = (STAFF_T *)malloc(sizeof(STAFF_T));

staff_a->addr = (char *)malloc(100);

定義一個staff_b，并將staff_a的所有權轉移過來：

STAFF_T *staff_b = staff_a；

這種從根struct轉移所有權的行為是一種整體轉移。注意，在整體轉移過程中，其復雜數據類型成員的所有權并沒有轉移，其所有權還在原先的地址上。下面示意圖可以清晰看出，紅圈所在的地址（所有權）并沒有發生改變。

除此之外，還可以部分轉移，即只轉移其復雜數據類型成員的所有權。實例化staff_a：

STAFF_T *staff_a = (STAFF_T *)malloc(sizeof(STAFF_T));

staff_a->addr = (char *)malloc(100);

定義一個addr1，并將staff_a->addr的所有權轉移過來：

char *addr1 = staff_a->addr；

如果有多層次的復雜數據的嵌套，原理也是一樣。

2. 所有權借用

2.1 借用

前面代碼中提到過這樣一個問題：我們必須將s2返回給調用函數交還所有權，以便在調用函數能繼續s1。下面演示如何定義并使用一個（新的）borrow函數，它可以使用s1的內容但不獲取其所有權：

void main( )

{

int i1 = 5;// i1 進入作用域

char *s1 = (char *)malloc(xxx); // s1 進入作用域

borrow( i1, s1 );// i1 是值復制，不涉及所有權

// s1 的值借用到函數里 ...

……// s1繼續有效，可繼續使用

}// s1 離開作用域，檢查器會自動釋放，程序員無需處理。

void borrow( int i2, char const * volatiles2 )

{

// i2進入作用域

// s2僅僅是一個借用，在作用域范圍內可以使用其內容值。

}

沿用C語言的volatile修飾符來表示一個借用（是否對編譯器有其它影響？）。另外在C語言中，const *表示常量指針，指針指向內容為只讀，在此表示為只讀借用。用虛線表示借用關系，如下圖所示：

很顯然，如果在borrow函數中，嘗試給s2申請新的空間，或者嘗試調用free函數釋放s2，檢查器都會強烈提示錯誤。當然，檢查器自己也不會在s2的作用域結束時去釋放s2。因為s2并沒有內存空間的所有權。借用（borrowing），正如現實生活中，如果一個人擁有房產，你可以從他那里租借來住，但你并不擁有所有權。

void borrow( int i2, char const * volatile s2 )

{

// i2進入作用域

// s2僅僅是一個借用，在作用域范圍內可以使用其內容值。

s2 = (char *)malloc(xxx); // 錯誤，借用不能申請自己的空間

free( s2 ); // 錯誤，借用沒有自己的空間可釋放

}// 作用域結束自動歸還。

2.2. 歸還

作用域結束，自動歸還是很容易理解的事。除此之外，程序員還可以主動歸還：

void borrow( int i2, char const * volatile s2 )

{

// i2進入作用域

s2 = NULL; // 主動歸還

}

通過賦值到NULL是一種主動歸還方式，可以成為顯式歸還。還有另外一種隱式主動歸還：

void borrow( int i2, char const * volatile s2 )

{

// i2進入作用域

char *s4 = (char *)malloc(xxx);

s2 = s4; // s2向s4發起了借用，隱式的歸還了原先的借用。

}

2.3. 可寫借用

進一步，如果在borrow函數中，改變s2所指向的內容，檢查器和編譯器也會提示錯誤：

void borrow( int i2, char const * volatile s2 )

{

// i2進入作用域

// s2僅僅是一個借用，在作用域范圍內可以使用其內容值。

s2[0] = 'a'; // 檢查器提示錯誤，s2指向的內容不能改變。

}

C程序員很容易發現問題，是因為我們在借用時加了const修飾符，如果想修改s2指向空間的值。只要去掉這個const就可以了。我們把這種借用方式叫做可寫借用。

void borrow( int i2, char * volatile s2 )

{

// i2進入作用域

// s2僅僅是一個借用，在作用域范圍內可以使用其內容值。

s2[0] = 'a'; // 可寫借用，寫成功。

}

2.4. 可寫借用限制

不過對于可寫借用，有一個很大的限制：在特定作用域中的特定數據有且只有一個可寫借用。這些代碼會失敗：

char *s1 = (char *)malloc(xxx);// s1 具有所有權

char * volatile s2 = s1;// 可寫借用

char * volatile s3 = s1;// 再次可寫借用，檢查器報錯

進一步講，有了可寫借用后，也不允許同時存在其它只讀借用：

char *s1 = (char *)malloc(xxx); // s1 具有所有權

char const * volatile s2 = s1;// 只讀借用，OK

char * volatile s3 = s1;// 可寫借用，檢查器報錯

char const * volatile s4 = s1;// 再次只讀借用，OK

不過，這個限制可考慮通過配置關閉，因為大部分語言中變量任何時候都是可變的。意思是說在檢查器可以有選項可以選擇：允許多次可寫出借或者同時允許一個可寫和多個只讀出借。但這個限制的好處是讓TC和Rust一樣可以在編譯前/時就避免數據競爭。數據競爭（data race）類似于競態條件，它可由這三個行為造成：

兩個或更多指針同時訪問同一數據。至少有一個指針被用來寫入數據。沒有同步數據訪問的機制。

數據競爭會導致未定義行為，難以在運行時追蹤，并且難以診斷和修復；TC和 Rust避免了這種情況的發生，因為它們甚至不會編譯存在數據競爭的代碼！

一如既往，可以使用大括號來創建一個新的作用域，以允許擁有多個可變借用，只要不是同時擁有：

char *s1 = (char *)malloc(xxx); // s1 具有所有權

{

char * volatile s2 = s1;// 可寫借用

}

char * volatile s3 = s1;// 再次可寫借用，因為s2已經失效

另外，需要特別注意的是，默認情況下，有了可寫借用后，擁有所有權的變量自身也變得不可訪問，既不能寫也不能讀。如果只是只讀借用，原變量還可以讀，只是不能寫。

char *s1 = (char *)malloc(xxx);// s1 具有所有權

char * volatile s4 = s1;// 可寫借用

s1[0] = 'a';// 檢查器報錯，s1不可寫訪問

printf( "s1=%s", s1 );// 檢查器報錯，s1不可讀訪問

這僅僅是一個為了說明問題的示例，如果實際情況中出現這種代碼，也不用太擔心，檢查器會在s4離開作用域后恢復s1的可訪問性，然后在s1離開作用域后釋放空間。

總之，在默認限制規則下，我們也不能在擁有只讀借用的同時擁有可寫借用。只讀借用的用戶可不希望在他們的眼皮底下值就被意外的改變了！然而，多個只讀借用是可以的，因為沒有哪個只能讀取數據的人有能力影響其他人讀取到的數據。

盡管這些限制有時使人沮喪，但請牢記這是TC檢查器和Rust編譯器在提前指出一個潛在的bug（在編譯前/時而不是在運行時）并精準顯示問題所在。這樣你就不必去跟蹤為何數據并不是你想象中的那樣。

2.5. 懸垂指針（Dangling pointer）

在C這樣具有指針的語言中，很容易通過釋放內存時保留指向它的指針而錯誤地生成一個懸垂指針（dangling pointer），所謂懸垂指針是其指向的內存可能已經被分配給其它持有者。相比之下，TC檢查器和Rust中編譯器確保永遠也不會變成懸垂狀態：情況一：對于擁有所有權的變量來說，檢查器會嚴格按照作用域來確保數據絕對有效性；情況二：對于借用者來說，檢查器會確保出借者不會在其歸還數據之前離開作用域，不離開作用域，就不會被釋放，也保證了數據的絕對有效。

情況二描述的這種機制實際上是一個我們還未介紹的新功能，叫：生命周期（lifetimes）。后面章節會詳細介紹生命周期。現在，我們先來看一個例子，檢查器如何檢查這種錯誤：

char * volatile dangle( )

{

char *s1 = (char *)malloc(xxx);// s1 具有所有權

char * volatile s2 = s1;// s2 借用s1

return s2;

// s1離開作用域后釋放，S2成為懸垂指針，檢查報錯并拒絕編譯。

}

因為 s1 是在被調用函數內創建的，當該函數的代碼執行完畢后，s1將被釋放。我們嘗試返回它的借用，指向一個無效的空間，這可不對！TC檢查器不會允許我們這么做。當然，C語言是可以的，這些C語言的不安全性正是TC要優化的地方。

這里的解決方法是直接返回s1：

char * no_dangle( )

{

char *s1 = (char *)malloc(xxx);// s1 具有所有權

return s1;// s1 所有權返回，運行正常。

}

這樣就沒有任何錯誤了。所有權被移動出去，所以沒有空間會被釋放。

2.6. 借用的默認規則

1) 讓我們概括一下之前對借用的討論：

2) 同一時刻，可有0個或多個只讀借用，但不能同時有任何可寫借用；

3) 同一時刻，在沒有只讀借用時，允許有一個可寫借用；

4) 在只讀借用歸還前不可寫訪問擁有所有權的源變量；

5) 在可寫借用歸還前不可寫或讀訪問擁有所有權的源變量；

6) 借用在離開作用域后歸還，也可以主動歸還；

7) 在借用期內，所有者保證不會釋放/轉移這塊內存。

2.7. 永久所有權的借用

對于具有永久產權的基本數據類型的借用，也遵循上述默認的借用規則。先看一下整形數據的例子：

int i = 0;

int j = i;// 值復制

int *k = &i; // 錯誤，嘗試轉移永久產權

int * volatile l = &i; // 正確，可寫借用

int const* volatile l = &i; // 正確，不可寫借用

下面，繼續看一下永久所有權數組的例子

int i[10];

int *j = i;// 錯誤，嘗試轉移永久產權

int * volatile k = i;// 正確，可寫借用

int const* volatile k = i; // 正確，不可寫借用

在函數調用時也是一樣的規則，但函數返回時有些不一樣。前面在講非永久所有權借用時也沒有提及函數返回一個借用時的情況，因為這涉及到下面一個技術點。

2.8. 轉借

Alice給Bob借了一筆錢，Bob轉身把這筆錢又借給了Carol，這就產生了轉借行為。把借來的東西再轉借出去，這會產生讓人非常頭痛的三角債問題。按我們生活中的智慧，我們需要避免這種轉借行為。但在TC和RUST語言中，必須允許轉借行為存在。為了避免三角債務帶來的煩惱，我們把轉借在邏輯上可以理解是一種代理行為。因此，雖然Carol向Bob借用，但Carol的債主并不是Bob，還是Alice，是最終的所有權擁有者。這也很容易理解，因為Bob并不擁有所有權，所以他沒有東西可供借出，他只能是一個代理人，幫助Alice做借出動作。

下面看一個例子：

char *Alice = (char *)malloc(xxx); // s1 具有所有權

char const *volatile Bob = Alice;// 只讀借用，此時Alice無法寫了

char const *volatile Carol = Bob;// 轉借，相當于A同時出借給B和C

根據前面所述規則，一個變量可以同時有多個只讀借用，所以上面操作沒有問題。現在問題來了，如果Bob是一個可寫借用呢？按照規則，如果存在可寫借用，那有且只能有一個，其它不論是否可寫，都不能再借出。但在這里的轉借場景中，情況有所不同，即便Bob是可寫借用，它仍然可以繼續轉借。但只能是可寫轉借，不能只讀轉借，看一個例子：

char *Alice = (char *)malloc(xxx); // s1 具有所有權

char * volatile Bob = Alice;// 可寫借用，此時Alice無法讀寫

char const *volatile Carol = Bob;// 只讀轉借，錯誤操作

char * volatile Carol = Bob;// 可寫轉借，此時Bob也無法讀寫

可寫借用來的東西為什么不能只讀轉借？這也很容易理解，如果允許只讀轉借，那Bob就變成了只讀訪問，這是沒問題的，問題是Alice前面已經變成了完全不可訪問，此處要不要變成只讀訪問呢？如果在繼續轉借下去，可能會引起連鎖反應，所以，我們規定這種情況下只允許可寫轉借，只影響轉借者本身的權限。

2.9. 轉借的應用

轉借在實際編碼中是必須的，比如在前面提到的函數返回時。來看一個例子：

void main( )

{

char *s1 = (char *)malloc(xxx); // s1 進入作用域

char *volatile s3 = borrow( s1 ); // s1 的值借用到函數里 ...

……// 得到一個新借用者s3

}

char * volatile borrow( char * volatile s2 )

{

……;// s2 處理中

return s2+10;// 返回一個s2的一個偏移值，例如+10。

}

另外一個常用場景是函數的多層調用：

void borrow1( char * volatile s2 )

{

……;// s2 處理中

borrow2( s2 );// 繼續轉借給borrow2處理。

}

void borrow2( char * volatile s3 )

{

……;// s3 處理中

}

需要說明下，在第一個例子中返回了一個偏移值，我們對這種部分借用有一個專用名字叫“Slice借用”。

2.10. 結構體的借用

對于沒有復雜數據類型成員的結構體，可以認為就是單塊空間借用，規則完全如前所述。對于有復雜數據成員的結構體，借用就會復雜很多，特別是有多層復雜數據成員堆疊嵌套時。但還是前面的話，理解了所有權的本質是和一個變量相關聯就不難理解結構體帶來的復雜性了。下面還是以STAFF_T結構體為例來解釋。

typedef struct staff

{

char name[10];

int age;

char *addr;

}STAFF_T;

2.10.1整體借用

實例化staff_a：

STAFF_T *staff_a = (STAFF_T *)malloc(sizeof(STAFF_T));

staff_a->addr = (char *)malloc(100);

定義一個整體借用：

STAFF_T * volatile staff_b = staff_a;

此時，staff_a已經可寫出借給了staff_b，按照出借規則，staff_a處于讀寫都不允許的狀態，也不能夠再出借給其它人。

這個時候新的問題來了，staff_b借用了staff_a，對staff_a的空間沒有所有權，無法去釋放，但這個借用是一個可寫借用，表示對staff_a的成員內容有可寫權限。也就是說，我們可以寫成員staff_a->addr，這相當于我們神奇的獲得了所有權。就是原本staff_a->addr所指向的空間的所有權轉移到了staff_b->addr上，確確實實是轉移行為，而不是借用關系。從下面示意圖中可以看出，指向該空間的箭頭是一個實箭頭：

這和我們的直覺可能有所不同，但這樣的設計確實不會影響安全性，此時staff_a處于無法訪問狀態，自然無法對addr行駛所有權，檢查器會自動完成檢查確認工作。在實際編程中，這樣的使用場景很多，比如處理一個鏈表上進進出出的節點，處理者只是借用了鏈表頭，但它需要對下層空間擁有所有權才能進行鏈表操作。

仔細思考起來也不難理解，所有權本質上是一個變量對內存空間的指向。變量本身地址沒變，那所有權就沒變。

2.10.2Slice借用

結構體除了整體出借外，可以可以只借出部分成員。可以把一個結構體看做一棵樹，葉子的借用就是slice借用。

實例化staff_a：

STAFF_T *staff_a = (STAFF_T *)malloc(sizeof(STAFF_T));

staff_a->addr = (char *)malloc(100);

定義一個slice借用：

char * volatile addr1 = staff_a->addr；

此時，staff_a的一個成員的空間可寫出借給了addr1，是一種slice借用，對這個葉子來說，往下又是一個整體，遵循整體借用規則。下圖為一個示意圖，r1被借用后，從r1指向內容r2往下又是一個整體，繼續遵循整體借用規則。

現在問題來了，r1北向和東西向情況如何呢？

先看東西向兄弟成員，因為兄弟成員和r1沒有任何包含關系，因此，r1的借用對兄弟成員的狀態沒有任何影響，兄弟成員可以繼續借出（所有）、轉移或釋放（非永久所有權的兄弟成員）。

再看r1的北向，因為r1被其北向r0所包含，所以當r1被借出后、歸還前，r0不允許被釋放，如果r0還有北向，也以此類推，一直到結構體根部。這實際上是后面章節要講的結構體的生命周期問題。但北向的借用和轉移都不影響。

2.10.3出借期增益

實例化staff_a：

STAFF_T *staff_a = (STAFF_T *)malloc(sizeof(STAFF_T));

定義一個整體借用：

STAFF_T * volatile staff_b = staff_a;

出借后，由借入方代理申請了新的空間：

staff_b->addr = (char *)malloc(100);

當staff_b歸還給staff_a后，staff_a的成員就多了一塊產權，這可以看做是staff_a在出借期間的增益。這并不難理解。

2.10.4借用者成員

結構體中含有借用者成員，修改一下STAFF_T的定義：

typedef struct staff

{

char name[10];

int age;

char * volatile addr;// 這是一個借用者

}STAFF_T;

實例化staff_a：

STAFF_T *staff_a = (STAFF_T *)malloc(sizeof(STAFF_T));

定義一個整體借用：

STAFF_T * volatile staff_b = staff_a;

出借后，由借入方代理進行了成員的借用：

staff_b->addr = addr1;

因為，staff_b是一個可寫借用，所以，上面代理為成員進行借用是允許的。反之，如果是只讀借用，上面的操作將會被檢查器報錯。

在staff_b歸還后，staff_a釋放時，會自動歸還借用來的成員空間。不過，如果不是十分必要這樣做，建議staff_b在歸還自身前先主動代理歸還成員空間，這有利于簡化生命周期管理。

2.11. 高維數據的借用

C語言最容易迷惑人的是高維指針，實際上前一節的結構體含有復雜數據類型成員時，也是一種高維指針。只是每一個維度都顯式靜態定義，更容易理解。在純粹的高維指針中，中間維度是動態關聯，中間關系就沒有那么直觀。先看一個例子：

char *s1 = (char *)malloc(xxx);

char **s2 = &s1；// 檢查器報錯，&s1是永久所有權，無法轉移

char ** volatile s2 = &s1；//借用成功

需要注意的是，這個借用是一個高維借用，用示意圖表示如下：

可見，s2借用的并不是s1所指向的空間，而是s1本身，即&s1指向的空間，只是沒有顯式定義&s1，實際地址中并不存在這個位置。根據前面所有權知識，我們知道&s1是一個永久所有權，所以，它只能被借用，但不能被轉移。

另外，和結構體借用類似，s2借用到s1后，可以擁有s1指向空間的所有權，因為s1的位置沒有發生任何改變，而且s2是一個可寫借用，所以s2可以主動去釋放、轉移、遺棄s1所指向的空間，例如：

*s2 = NULL； // s1指向空間被遺棄

但在s2歸還時，不會自動釋放s1指向空間，因為s1還存在著。

3. 生命周期（lifetimes）

3.1 函數返回的生命周期問題

在前面章節中已經提到生命周期的概念，為了確保借用的有效性，出借方的生命周期一定要長于借用方，出借方不能在借用方歸還前釋放或轉移，否則就會出現懸垂指針，造成諸如UAF之類的安全漏洞。

良好的編程風格有助于檢查器來檢查和推斷生命周期，比如在函數調用過程中保持借用的單調性是非常提倡和實用的編程做法。所謂單調，就是變量只借給被調用函數，而不會反過來由被調用函數反借給調用函數。單調編程舉例如下：

void fun_a( )

{

char *s1 = (char *)malloc(xxx);

fun_b( s1 );

}

void fun_b( char * volatile s2 )

{

fun_c( s2 )

}

void fun_c( char * volatile s3 )

{

……

}

當調用函數返回一個借用時，單調性就會被破壞，這對生命周期的自動化推斷和檢查會帶來很大麻煩，我們不提倡這樣的編程風格。在RUST語言中，采用手工注解的方法來解決。本來引入所有權問題，就是希望避免程序員對內存進行手工操作，對生命周期的手工注解顯然破壞了設想。在TC中，我們盡量避免手工操作，改由檢查器自動推斷產生注解。看一個非單調借用的例子：

void fun_a( )

{

char *s1 = (char *)malloc(xxx);

char * volatile s2 = fun_b( s1 );

}

Char * volatile fun_b( char * volatile s3 )

{

return s3;

}

在這個例子中，fun_b函數返回s3的含義是將s3轉借給s2（也可能是轉借一個slice，因原理相同，所以在描述具體問題時不再區分是整體轉借還是slice轉借），s3自己的作用域結束歸還，即函數返回后s1只存在一個s2的借用。按照借用規則，需要確保s1的生命周期比s2長。那么問題來了，在fun_a看來，如何知道s2是s1的一個借用呢？因為fun_a和fun_b無法確保總是在一個文件中，甚至fun_b是一個二進制庫提供的，源代碼都沒有。這個時候，就需要用到注解了，在fub_b的頭文件中聲明中進行注解，語法如下：

Char * volatile @1fun_b( char * volatile @1s3 );

在函數名和s3前面都標注有一個“@”的修飾符，后面跟一個數字，代表組別。對于非TC語言（C/C++）開發、且沒有源代碼的庫文件，需要手工添加注解，否則生命周期推測會失敗，產生不可預料的嚴重后果。TC語言開發或者有源代碼的其它語言（C/C++）開發的庫，檢查器會自動推斷生產帶注解的頭文件函數聲明。下面再看一個復雜點的例子：

void fun_a( )

{

char *s1 = (char *)malloc(xxx);

char *s2 = (char *)malloc(xxx);

char * volatile s5 = fun_b( s1，s2 );

}

Char * volatile fun_b( char * volatile s3，char * volatile s4 )

{

if( XXX )

return s3;

else

return s4;

}

在這個例子中，函數fun_b的返回值會受到運行時影響，無法在編譯時/前由檢查器確定。即s5最終是s1的借用還是s2的借用是沒法在運行前確定的，不論是人工還是檢查器都是無能為力的。這個時候，我們采用了RUST基本一樣的簡單粗暴的做法，如果不知道s3還是s4，那就要求s3和s4的出借方s1和s2的生命周期都要長于s5，注解方式如下：

Char *volatile @1fun_b( char *volatile @1s3，char *volatile @1s4 );

因為TC和C語言一樣，只有一個返回值，所以，對于函數調用過程中生命周期的問題處理上比RUST要簡單一些。

3.2. 結構體的生命周期問題

除了函數返回借用外，如果帶有結構體，也可能返回一個借用。仍然采用前面的結構體來說明問題。

typedef struct staff

{

char name[10];

int age;

char * volatile addr;// 這是一個借用者

}STAFF_T;

然后，改造一下調用函數的參數：

void fun_a( )

{

char *s1 = (char *)malloc(xxx);

char *s2 = (char *)malloc(xxx);

STAFF_T staff_a；

fun_b( s1，s2 );

}

void fun_b( char * volatile s3，char * volatile s4，STAFF_T * volatile staff_b )

{

if( XXX )

staff_b->addr = s3;

else

staff_b->addr = s4;

}

同樣的道理，我們需要在頭文件聲明中，為生命周期進行注解：

Char * volatile @1fun_b( char * volatile @1s3，char * volatile @1s4，STAFF_T * volatile @1staff_b );

需要注意的是，函數返回值只有一個，但結構體借用成員可以有多個，也可能有多個結構體借用參數，當多個“輸出”受不同輸入影響時，我們需要對注解進行分組：

Void fun_b( char * volatile @1s3，char * volatile @2s4，STAFF_T * volatile @1,2staff_b，STAFF_T volatile @2staff_c );

上面注解的含義很清楚，表示staff_b中可能有兩個借用成員，分別受s3和s4影響，但staff_c只受s4影響。

當然，結構體帶回和函數返回這兩種“輸出”也可能同時使用，注解原理是一樣的，不再贅述。

除此之外，結構體生命周期還有前面章節中提到的當南向有成員借出后，北向禁止釋放，否則就很會出現內存泄露的安全問題。檢查器會確保不會出現這種問題。

3.3. 高維借用的生命周期問題

提升指針維度也能輸出借用，這也是C語言中常用的方法。來看一個例子：

void fun_a( )

{

char *s1 = (char *)malloc(xxx);

char *s2 = (char *)malloc(xxx);

char *volatile s3 = NULL；// 定義一個借用，但尚未發生借用

fun_b( s1，s2，&s3 );

}

void fun_b( char * volatile s4，char * volatile s5，char ** volatile s6 )

{

if( XXX )

*s6 = s4;

else

*s6 = s5;

}

在這個例子中，s3是一個借用，但開始只有一個定義，并未進行實際借用動作，真正借用動作發生在被調用函數fun_b中。為了能在被調用函數中進行借用，需要將s3再提升一個維度，所以這里發生了第二個借用:

根據前面章節介紹規則可知，&s3是一個永久所有權，因為它存在于棧中的某個地址上，只是沒有顯式定義變量名，但它仍然可以借出，借用方就是s6。通過s6這個借用，是可寫借用，可以讓*s6寫為需要的值來完成s3的借用動作，比如借用s1：

可見，通過高維借用，也能讓函數調用產生借用“輸出”，如果這個輸出和輸入的借用有關，那就需要進行生命周期的注解，如下：

void fun_b( char * volatile @1s4，char * volatile @1s5，char ** volatile @1s6 )

4. 并發多任務

RUST對并發做了很多底層定制，但最后還是用上了ARC機制，這需要編譯器和運行時的支持。TC中并不希望做大改動，編譯前檢查和不用改動編譯器以及libc庫始終是要考慮的重要目標。我們傾向于認為多任務機制是系統本身的機制，而不是系統編程語言的機制。

4.1. 消息傳遞

消息傳遞是很多產品嵌入式開發的主要模式。原理上很清晰，通過消息傳遞和驅動，一個消息同時只有一個任務接收和處理（廣播消息一般為只讀借用，無需深入處理），可以將所有權隨消息包一起流動。因此，在消息傳遞模式中，可以很容易的遵守所有權規則。消息本身的實現則由系統提供機制，比如管道，隊列等機制。

4.2共享內存

除了消息傳遞外，在多任務并發環境中，總會遇到臨界區問題。而任務并發完全由系統進行實時調度，在編譯前無法確認各個任務的運行時間，更無法通過時分來給不同任務進行所有權轉移。因此在多任務并發環境中，我們前面制定的編譯前所有權規則會受到嚴重的挑戰。當然，如果所有任務對臨界區數據只讀，那是沒有問題的，因為可以同時只讀借用給所有任務。但現實情況是大部分情況下，需要對臨界區數據進行寫操作。

為了應對多任務并發環境下的寫操作，TC采用了和RUST不同的做法。TC利用系統已有的同步或互斥機制（后續簡稱為鎖）來對借用進行增強。規則如下：

1) 將臨界區數據只讀借用給各個任務；

2) 增加注解，將臨界區資源和系統鎖進行綁定聲明；

3) 在獲得鎖的作用域期間，允許對臨界區資源寫訪問。

相應的綁定注解語法如下：

@BINDING 借用者 TO 上鎖代碼;

下面來看個例子：

pthread_mutex_t mutex; //定義一把互斥鎖，注意：這把鎖本身是一個臨界區資源

char *share_date;//共享內存，臨界資源

void* thread(void *id)

{

int num = *(int *)id;

@BINGING &mutex TO pthread_mutex_lock(&mutex)//綁定注解

@BINDING share_date TO pthread_mutex_lock(&mutex)//綁定注解

char const *volatile borrow_data = share_date; /* 只讀借用，不要直接使用share_date，會降低安全性，在多個地方直接使用全局量，檢查器會告警。此處可寫借用也會報錯，哪怕只有一個任務，因為注解已經聲明這是一個臨界區資源。*/

pthread_mutex_lock(&mutex)// 加鎖

/* borrow_data此處自動轉變為可寫借用，可盡情進行處理了 */

/* 如果試圖釋放borrow_data，檢查器報錯，因為它只是個借用 */

pthread_mutex_unlock(&mutex); // 解鎖

return NULL;

}

void main( )

{

int num_thread = 3;

share_date = (char *)malloc(100);

pthread_t *pt = (pthread_t *)malloc(sizeof(pthread_t) * num_thread);

int * id = (int *)malloc(sizeof(int) * num_thread);

if (pthread_mutex_init(&mutex, NULL) != 0)

{

goto end;

}

for (int i = 0; i < num_thread; i++)

{

id[i] = i;

if (pthread_create(&pt[i], NULL, thread, &id[i]) != 0)

{

goto end;

}

}

for (int i = 0; i < num_thread; i++)

{

pthread_join(pt[i], NULL);

}

pthread_mutex_destroy(&mutex);

end:

free(share_date);

// 只需要釋放全局所有權，pt，id在作用域結束會自動釋放

return;

}

總的來說，TC采用了比RUST更加簡單、靈活和系統自適應的并發內存安全機制，達到了編譯前檢查，不改運行時的目標。當然，手工注解還是帶來了一點麻煩，這可能是整個方案中唯一需要程序員手工完成的事，比RUST要少很多。

—— 尚未開發出檢查器，所以未驗證最終是否可行，歡迎大家批評指正

總結

以上是生活随笔為你收集整理的取两个数较小值c语言_如何提升C语言安全性，达到RUST的安全性的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。