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

1. 所有權(quán)

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

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

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

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

1.1. 棧（Stack）與堆（Heap）

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

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

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

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

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

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

1.2. 所有權(quán)規(guī)則

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

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

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

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

1.3. 變量作用域

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

int i = 0;

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

{

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

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

// 使用 i

}// 此作用域已結(jié)束，i 不再有效

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

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

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

1.4. 復(fù)雜類型

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

1.5. 內(nèi)存與分配

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

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

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

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

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

{

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

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

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

// 使用str

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

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

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

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

1.6. 所有權(quán)轉(zhuǎn)移

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

int x = 5;

int y = x;

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

現(xiàn)在來看這個例子的字符串版本：

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

char *s2 = s1;

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

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

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

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

char *s2 = s1;

……

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

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

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

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

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

1.7. 所有權(quán)遺棄

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

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

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

s2 = s1;

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

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

1.8. 永久所有權(quán)

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

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

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

char str[XXX];// 正確語法，永久所有權(quán)

char *str1 = str;// 錯誤，永久所有權(quán)不能轉(zhuǎn)移

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

1.9. 所有權(quán)與函數(shù)

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

void main( )

{

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

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

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

// s1 的值移動到函數(shù)里 ...

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

// 但可繼續(xù)使用 i1

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

void takes_ownership( int i2, char *s2 )

{

// i2,s2 進入作用域

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

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

1.10. 返回值與作用域

在某些場景下，調(diào)用一個函數(shù)對s1進行處理后，我還需要繼續(xù)處理s1，但s1已經(jīng)失去空間所有權(quán)，這怎么辦呢？方法是讓函數(shù)再將所有權(quán)返回。

void main()

{

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

……

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

// takes_and_gives_back 中,

// 它也將返回值移給 s1

……繼續(xù)使用s1……

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

char * takes_and_gives_back( char *s2 )

{

// s2 進入作用域

……

return s2;// 返回所有權(quán)給調(diào)用者

}// s2所有權(quán)已經(jīng)轉(zhuǎn)移，檢查器在這里不需要做特殊處理

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

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

1.11. 結(jié)構(gòu)體的所有權(quán)

1.11.1. 所有權(quán)的包含關(guān)系

前面大部分內(nèi)容都是以字符串為例介紹的，但在復(fù)雜數(shù)據(jù)類型中，還有結(jié)構(gòu)體struct和聯(lián)合體union兩種，以struct為例來介紹其所有權(quán)問題。先看一個例子：

typedef struct staff

{

char name[10];

int age;

}STAFF_T;

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

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

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

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);

這個時候再內(nèi)存中存在兩塊內(nèi)存，示意圖如下：

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

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

總之，理解了所有權(quán)的本質(zhì)是空間被一個變量所關(guān)聯(lián)，就不難理解結(jié)構(gòu)體相關(guān)的所有權(quán)知識了。

1.11.2. 復(fù)雜數(shù)據(jù)成員所有權(quán)的轉(zhuǎn)移

在結(jié)構(gòu)體含有復(fù)雜數(shù)據(jù)類型成員時，所有權(quán)轉(zhuǎn)移會比較復(fù)雜一點，主要是需要考慮其包含的下一級所有權(quán)是否存在。下面還是以STAFF_T結(jié)構(gòu)體為例來解釋。

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的所有權(quán)轉(zhuǎn)移過來：

STAFF_T *staff_b = staff_a；

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

除此之外，還可以部分轉(zhuǎn)移，即只轉(zhuǎn)移其復(fù)雜數(shù)據(jù)類型成員的所有權(quán)。實例化staff_a：

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

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

定義一個addr1，并將staff_a->addr的所有權(quán)轉(zhuǎn)移過來：

char *addr1 = staff_a->addr；

如果有多層次的復(fù)雜數(shù)據(jù)的嵌套，原理也是一樣。

2. 所有權(quán)借用

2.1 借用

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

void main( )

{

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

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

borrow( i1, s1 );// i1 是值復(fù)制，不涉及所有權(quán)

// s1 的值借用到函數(shù)里 ...

……// s1繼續(xù)有效，可繼續(xù)使用

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

void borrow( int i2, char const * volatiles2 )

{

// i2進入作用域

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

}

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

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

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

{

// i2進入作用域

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

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

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

}// 作用域結(jié)束自動歸還。

2.2. 歸還

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

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發(fā)起了借用，隱式的歸還了原先的借用。

}

2.3. 可寫借用

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

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

{

// i2進入作用域

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

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

}

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

void borrow( int i2, char * volatile s2 )

{

// i2進入作用域

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

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

}

2.4. 可寫借用限制

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{

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

}

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

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

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

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

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

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

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

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

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

2.5. 懸垂指針（Dangling pointer）

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

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

char * volatile dangle( )

{

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

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

return s2;

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

}

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

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

char * no_dangle( )

{

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

return s1;// s1 所有權(quán)返回，運行正常。

}

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

2.6. 借用的默認規(guī)則

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

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

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

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

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

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

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

2.7. 永久所有權(quán)的借用

對于具有永久產(chǎn)權(quán)的基本數(shù)據(jù)類型的借用，也遵循上述默認的借用規(guī)則。先看一下整形數(shù)據(jù)的例子：

int i = 0;

int j = i;// 值復(fù)制

int *k = &i; // 錯誤，嘗試轉(zhuǎn)移永久產(chǎn)權(quán)

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

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

下面，繼續(xù)看一下永久所有權(quán)數(shù)組的例子

int i[10];

int *j = i;// 錯誤，嘗試轉(zhuǎn)移永久產(chǎn)權(quán)

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

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

在函數(shù)調(diào)用時也是一樣的規(guī)則，但函數(shù)返回時有些不一樣。前面在講非永久所有權(quán)借用時也沒有提及函數(shù)返回一個借用時的情況，因為這涉及到下面一個技術(shù)點。

2.8. 轉(zhuǎn)借

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

下面看一個例子：

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

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

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

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

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

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

char const *volatile Carol = Bob;// 只讀轉(zhuǎn)借，錯誤操作

char * volatile Carol = Bob;// 可寫轉(zhuǎn)借，此時Bob也無法讀寫

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

2.9. 轉(zhuǎn)借的應(yīng)用

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

void main( )

{

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

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

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

}

char * volatile borrow( char * volatile s2 )

{

……;// s2 處理中

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

}

另外一個常用場景是函數(shù)的多層調(diào)用：

void borrow1( char * volatile s2 )

{

……;// s2 處理中

borrow2( s2 );// 繼續(xù)轉(zhuǎn)借給borrow2處理。

}

void borrow2( char * volatile s3 )

{

……;// s3 處理中

}

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

2.10. 結(jié)構(gòu)體的借用

對于沒有復(fù)雜數(shù)據(jù)類型成員的結(jié)構(gòu)體，可以認為就是單塊空間借用，規(guī)則完全如前所述。對于有復(fù)雜數(shù)據(jù)成員的結(jié)構(gòu)體，借用就會復(fù)雜很多，特別是有多層復(fù)雜數(shù)據(jù)成員堆疊嵌套時。但還是前面的話，理解了所有權(quán)的本質(zhì)是和一個變量相關(guān)聯(lián)就不難理解結(jié)構(gòu)體帶來的復(fù)雜性了。下面還是以STAFF_T結(jié)構(gòu)體為例來解釋。

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已經(jīng)可寫出借給了staff_b，按照出借規(guī)則，staff_a處于讀寫都不允許的狀態(tài)，也不能夠再出借給其它人。

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

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

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

2.10.2Slice借用

結(jié)構(gòu)體除了整體出借外，可以可以只借出部分成員。可以把一個結(jié)構(gòu)體看做一棵樹，葉子的借用就是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借用，對這個葉子來說，往下又是一個整體，遵循整體借用規(guī)則。下圖為一個示意圖，r1被借用后，從r1指向內(nèi)容r2往下又是一個整體，繼續(xù)遵循整體借用規(guī)則。

現(xiàn)在問題來了，r1北向和東西向情況如何呢？

先看東西向兄弟成員，因為兄弟成員和r1沒有任何包含關(guān)系，因此，r1的借用對兄弟成員的狀態(tài)沒有任何影響，兄弟成員可以繼續(xù)借出（所有）、轉(zhuǎn)移或釋放（非永久所有權(quán)的兄弟成員）。

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

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的成員就多了一塊產(chǎn)權(quán)，這可以看做是staff_a在出借期間的增益。這并不難理解。

2.10.4借用者成員

結(jié)構(gòu)體中含有借用者成員，修改一下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. 高維數(shù)據(jù)的借用

C語言最容易迷惑人的是高維指針，實際上前一節(jié)的結(jié)構(gòu)體含有復(fù)雜數(shù)據(jù)類型成員時，也是一種高維指針。只是每一個維度都顯式靜態(tài)定義，更容易理解。在純粹的高維指針中，中間維度是動態(tài)關(guān)聯(lián)，中間關(guān)系就沒有那么直觀。先看一個例子：

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

char **s2 = &s1；// 檢查器報錯，&s1是永久所有權(quán)，無法轉(zhuǎn)移

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

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

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

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

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

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

3. 生命周期（lifetimes）

3.1 函數(shù)返回的生命周期問題

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

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

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 )

{

……

}

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

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

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

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

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;

}

在這個例子中，函數(shù)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語言一樣，只有一個返回值，所以，對于函數(shù)調(diào)用過程中生命周期的問題處理上比RUST要簡單一些。

3.2. 結(jié)構(gòu)體的生命周期問題

除了函數(shù)返回借用外，如果帶有結(jié)構(gòu)體，也可能返回一個借用。仍然采用前面的結(jié)構(gòu)體來說明問題。

typedef struct staff

{

char name[10];

int age;

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

}STAFF_T;

然后，改造一下調(diào)用函數(shù)的參數(shù)：

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 );

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

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影響。

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

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

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

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

void fun_a( )

{

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

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

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

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是一個借用，但開始只有一個定義，并未進行實際借用動作，真正借用動作發(fā)生在被調(diào)用函數(shù)fun_b中。為了能在被調(diào)用函數(shù)中進行借用，需要將s3再提升一個維度，所以這里發(fā)生了第二個借用:

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

可見，通過高維借用，也能讓函數(shù)調(diào)用產(chǎn)生借用“輸出”，如果這個輸出和輸入的借用有關(guān)，那就需要進行生命周期的注解，如下：

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

4. 并發(fā)多任務(wù)

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

4.1. 消息傳遞

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

4.2共享內(nèi)存

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

為了應(yīng)對多任務(wù)并發(fā)環(huán)境下的寫操作，TC采用了和RUST不同的做法。TC利用系統(tǒng)已有的同步或互斥機制（后續(xù)簡稱為鎖）來對借用進行增強。規(guī)則如下：

1) 將臨界區(qū)數(shù)據(jù)只讀借用給各個任務(wù)；

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

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

相應(yīng)的綁定注解語法如下：

@BINDING 借用者 TO 上鎖代碼;

下面來看個例子：

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

char *share_date;//共享內(nèi)存，臨界資源

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，會降低安全性，在多個地方直接使用全局量，檢查器會告警。此處可寫借用也會報錯，哪怕只有一個任務(wù)，因為注解已經(jīng)聲明這是一個臨界區(qū)資源。*/

pthread_mutex_lock(&mutex)// 加鎖

/* borrow_data此處自動轉(zhuǎn)變?yōu)榭蓪懡栌?#xff0c;可盡情進行處理了 */

/* 如果試圖釋放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);

// 只需要釋放全局所有權(quán)，pt，id在作用域結(jié)束會自動釋放

return;

}

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

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

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。