前面一篇文章提到過 陣列越界行為，雖然編譯器為我們做了大量的檢查工作讓我們避免這些錯誤。

但是我覺得還是有必要模擬一下陣列越界，感受一下這個錯誤。

那麼對於.NET來說我們怎麼來模擬陣列越界呢？

一、 [VS]  專案 -> 右擊 -> 屬性 -> 生成 -> (勾選)允許不安全程式碼

二、測試程式碼

 1          unsafe private static void OutOfIndexMini()
 2         {
 3             int* i = stackalloc
 
 int[1];
 4 
 5             i[0] = 0;
 6             //i[0] = 1;
 7 
 8             //double* d = stackalloc double[1];
 9             //d[0] = 0.01;
10 
11             int* a = stackalloc int[3];
12 
13             for (; i[0] <= 3; i[0]++)
14             {
15                 a[i[0]] = 0;
16 
17                 Console.WriteLine($"
 
int* i = {i[0]}");
18 
19                 Console.WriteLine($"int* a[{i[0]}] = {a[i[0]]}");
20             }
21 
22         }

簡單說明一下：

unsafe 關鍵字 -- 支援不安全程式碼，就是說我們可以使用指標了。

stackalloc 關鍵字 -- 允許向堆疊申請記憶體了。

下面這兩句：我向記憶體申請 了陣列 int[1]，容量為一個int，並同時給這個賦值為1

int* i = stackalloc
 
 int[1];

i[0] = 0;

接下來：我緊接著向記憶體申請了陣列 int[3]，容量為 3個int.

int* a = stackalloc int[3];

然後注意：我的for迴圈陣列越界了  i[0] <= 3

for (; i[0] <= 3; i[0]++)
{
　　a[i[0]] = 0;

　　Console.WriteLine($"int* i = {i[0]}");

　　Console.WriteLine($"int* a[{i[0]}] = {a[i[0]]}");
}

初始值  i[ 0 ] = 0，所以進入for迴圈

i[0] = 0    >>>    a[ i[ 0 ] ] =0   >>>  a[ 0 ] =0

i[0] = 1    >>>    a[ i[ 0 ] ] =0   >>>  a[ 1 ] =0

i[0] = 2    >>>    a[ i[ 0 ] ] =0   >>>  a[ 2 ] =0

i[0] = 3    >>>    a[ i[ 0 ] ] =0   >>>  a[ 3 ] =0 ?

此時 a[ 3 ] 對於我們平常來說已經陣列越界了，但是這裡仍然可以正常賦值。那這個值我們給了誰？

我們先給出一個答案：

　　a[3] 其實越界到了 i[0] 地盤，也就是 a[3] = i[0] = 0,

　　這就造成 當 i[0] = 3 時，a[3] 越界將 i[0] 修改為0，程式進入死迴圈 ... ...

 三、驗證

如果，我將  i[0] 初始值修改一下，改成1

int* i = stackalloc int[1];

//i[0] = 0;
i[0] = 1;            

那麼在越界後 a[3] = i[0] = 0 ，打印出來 i [0] = 0 說明陣列確實越界並修改了值。

 那麼，我在中間再宣告一個不是int型別的陣列，導致越界不是修改的 i[0] 這樣就不會死迴圈了。

int* i = stackalloc int[1];

//i[0] = 0;
i[0] = 1;

double* d = stackalloc double[1];
d[0] = 1;

int* a = stackalloc int[3];

四、原理分析

因為陣列是相同的資料型別，連續記憶體。

第一次：i=0 ，a[0] 記憶體地址 1000

第二次：i=1 ，a[1] 記憶體地址 1004

第三次：i=2 ，a[2] 記憶體地址 1008

第四次：i=3 ，a[3] 記憶體地址 1012，也就是越界到了 i[0]