有乾貨、更有故事,微信搜索【編程指北】關注這個不一樣的程序員,等你來撩~
是的,這一篇的文章主題是「指針與內存模型」
說到指針,就不可能脫離開內存,學會指針的人分爲兩種,一種是不瞭解內存模型,另外一種則是瞭解。
不瞭解的對指針的理解就停留在“指針就是變量的地址”這句話,會比較害怕使用指針,特別是各種高級操作。
而瞭解內存模型的則可以把指針用得爐火純青,各種 byte 隨意操作,讓人直呼 666。
一、內存本質
編程的本質其實就是操控數據,數據存放在內存中。
因此,如果能更好地理解內存的模型,以及 C 如何管理內存,就能對程序的工作原理洞若觀火,從而使編程能力更上一層樓。
大家真的別認爲這是空話,我大一整年都不敢用 C 寫上千行的程序也很抗拒寫 C。
因爲一旦上千行,經常出現各種莫名其妙的內存錯誤,一不小心就發生了 coredump...... 而且還無從排查,分析不出原因。
相比之下,那時候最喜歡 Java,在 Java 裏隨便怎麼寫都不會發生類似的異常,頂多偶爾來個 NullPointerException,也是比較好排查的。
直到後來對內存和指針有了更加深刻的認識,才慢慢會用 C 寫上千行的項目,也很少會再有內存問題了。(過於自信
「指針存儲的是變量的內存地址」這句話應該任何講 C 語言的書都會提到吧。
所以,要想徹底理解指針,首先要理解 C 語言中變量的存儲本質,也就是內存。
1.1 內存編址
計算機的內存是一塊用於存儲數據的空間,由一系列連續的存儲單元組成,就像下面這樣,
每一個單元格都表示 1 個 Bit,一個 bit 在 EE 專業的同學看來就是高低電位,而在 CS 同學看來就是 0、1 兩種狀態。
由於 1 個 bit 只能表示兩個狀態,所以大佬們規定 8個 bit 爲一組,命名爲 byte。
並且將 byte 作爲內存尋址的最小單元,也就是給每個 byte 一個編號,這個編號就叫內存的地址。
這就相當於,我們給小區裏的每個單元、每個住戶都分配一個門牌號: 301、302、403、404、501......
在生活中,我們需要保證門牌號唯一,這樣就能通過門牌號很精準的定位到一家人。
同樣,在計算機中,我們也要保證給每一個 byte 的編號都是唯一的,這樣才能夠保證每個編號都能訪問到唯一確定的 byte。
1.2 內存地址空間
上面我們說給內存中每個 byte 唯一的編號,那麼這個編號的範圍就決定了計算機可尋址內存的範圍。
所有編號連起來就叫做內存的地址空間,這和大家平時常說的電腦是 32 位還是 64 位有關。
早期 Intel 8086、8088 的 CPU 就是隻支持 16 位地址空間,寄存器和地址總線都是 16 位,這意味着最多對 2^16 = 64 Kb
的內存編號尋址。
這點內存空間顯然不夠用,後來,80286 在 8086 的基礎上將地址總線和地址寄存器擴展到了20 位,也被叫做 A20 地址總線。
當時在寫 mini os 的時候,還需要通過 BIOS 中斷去啓動 A20 地址總線的開關。
但是,現在的計算機一般都是 32 位起步了,32 位意味着可尋址的內存範圍是 2^32 byte = 4GB
。
所以,如果你的電腦是 32 位的,那麼你裝超過 4G 的內存條也是無法充分利用起來的。
好了,這就是內存和內存編址。
1.3 變量的本質
有了內存,接下來我們需要考慮,int、double 這些變量是如何存儲在 0、1 單元格的。
在 C 語言中我們會這樣定義變量:
int a = 999;
char c = 'c';
當你寫下一個變量定義的時候,實際上是向內存申請了一塊空間來存放你的變量。
我們都知道 int 類型佔 4 個字節,並且在計算機中數字都是用補碼(不瞭解補碼的記得去百度)表示的。
999
換算成補碼就是:0000 0011 1110 0111
這裏有 4 個byte,所以需要四個單元格來存儲:
有沒有注意到,我們把高位的字節放在了低地址的地方。
那能不能反過來呢?
當然,這就引出了大端和小端。
像上面這種將高位字節放在內存低地址的方式叫做大端
反之,將低位字節放在內存低地址的方式就叫做小端:
上面只說明瞭 int 型的變量如何存儲在內存,而 float、char 等類型實際上也是一樣的,都需要先轉換爲補碼。
對於多字節的變量類型,還需要按照大端或者小端的格式,依次將字節寫入到內存單元。
記住上面這兩張圖,這就是編程語言中所有變量的在內存中的樣子,不管是 int、char、指針、數組、結構體、對象... 都是這樣放在內存的。
二、指針是什麼東西?
2.1 變量放在哪?
上面我說,定義一個變量實際就是向計算機申請了一塊內存來存放。
那如果我們要想知道變量到底放在哪了呢?
可以通過運算符&
來取得變量實際的地址,這個值就是變量所佔內存塊的起始地址。
(PS: 實際上這個地址是虛擬地址,並不是真正物理內存上的地址
我們可以把這個地址打印出來:
printf("%x", &a);
大概會是像這樣的一串數字:0x7ffcad3b8f3c
2.2 指針本質
上面說,我們可以通過&
符號獲取變量的內存地址,那獲取之後如何來表示這是一個地址,而不是一個普通的值呢?
也就是在 C 語言中如何表示地址這個概念呢?
對,就是指針,你可以這樣:
int *pa = &a;
pa 中存儲的就是變量 a
的地址,也叫做指向 a
的指針。
在這裏我想談幾個看起來有點無聊的話題:
爲什麼我們需要指針?直接用變量名不行嗎?
當然可以,但是變量名是有侷限的。
變量名的本質是什麼?
是變量地址的符號化,變量是爲了讓我們編程時更加方便,對人友好,可計算機可不認識什麼變量 a
,它只知道地址和指令。
所以當你去查看 C 語言編譯後的彙編代碼,就會發現變量名消失了,取而代之的是一串串抽象的地址。
你可以認爲,編譯器會自動維護一個映射,將我們程序中的變量名轉換爲變量所對應的地址,然後再對這個地址去進行讀寫。
也就是有這樣一個映射表存在,將變量名自動轉化爲地址:
a | 0x7ffcad3b8f3c
c | 0x7ffcad3b8f2c
h | 0x7ffcad3b8f4c
....
說的好!
可是我還是不知道指針存在的必要性,那麼問題來了,看下面代碼:
int func(...) {
...
};
int main() {
int a;
func(...);
};
假設我有一個需求:
要求在
func
函數裏要能夠修改main
函數裏的變量a
,這下咋整,在main
函數裏可以直接通過變量名去讀寫a
所在內存。但是在
func
函數裏是看不見a
的呀。
你說可以通過&
取地址符號,將 a
的地址傳遞進去:
int func(int address) {
....
};
int main() {
int a;
func(&a);
};
這樣在func
裏就能獲取到 a
的地址,進行讀寫了。
理論上這是完全沒有問題的,但是問題在於:
編譯器該如何區分一個 int 裏你存的到底是 int 類型的值,還是另外一個變量的地址(即指針)。
這如果完全靠我們編程人員去人腦記憶了,會引入複雜性,並且無法通過編譯器檢測一些語法錯誤。
而通過int *
去定義一個指針變量,會非常明確:這就是另外一個 int 型變量的地址。
編譯器也可以通過類型檢查來排除一些編譯錯誤。
這就是指針存在的必要性。
實際上任何語言都有這個需求,只不過很多語言爲了安全性,給指針戴上了一層枷鎖,將指針包裝成了引用。
可能大家學習的時候都是自然而然的接受指針這個東西,但是還是希望這段囉嗦的解釋對你有一定啓發。
同時,在這裏提點小問題:
既然指針的本質都是變量的內存首地址,即一個 int 類型的整數。
那爲什麼還要有各種類型呢?
比如 int 指針,float 指針,這個類型影響了指針本身存儲的信息嗎?
這個類型會在什麼時候發揮作用?
2.3 解引用
上面的問題,就是爲了引出指針解引用的。
pa
中存儲的是a
變量的內存地址,那如何通過地址去獲取a
的值呢?
這個操作就叫做解引用,在 C 語言中通過運算符 *
就可以拿到一個指針所指地址的內容了。
比如*pa
就能獲得a
的值。
我們說指針存儲的是變量內存的首地址,那編譯器怎麼知道該從首地址開始取多少個字節呢?
這就是指針類型發揮作用的時候,編譯器會根據指針的所指元素的類型去判斷應該取多少個字節。
如果是 int 型的指針,那麼編譯器就會產生提取四個字節的指令,char 則只提取一個字節,以此類推。
下面是指針內存示意圖:
pa
指針首先是一個變量,它本身也佔據一塊內存,這塊內存裏存放的就是 a
變量的首地址。
當解引用的時候,就會從這個首地址連續劃出 4 個 byte,然後按照 int 類型的編碼方式解釋。
2.4 活學活用
別看這個地方很簡單,但卻是深刻理解指針的關鍵。
舉兩個例子來詳細說明:
比如:
float f = 1.0;
short c = *(short*)&f;
你能解釋清楚上面過程,對於 f
變量,在內存層面發生了什麼變化嗎?
或者 c
的值是多少?1 ?
實際上,從內存層面來說,f
什麼都沒變。
如圖:
假設這是f
在內存中的位模式,這個過程實際上就是把 f
的前兩個 byte 取出來然後按照 short 的方式解釋,然後賦值給 c
。
詳細過程如下:
-
&f
取得f
的首地址 (short*)&f
上面第二步什麼都沒做,這個表達式只是說 :
“噢,我認爲f
這個地址放的是一個 short 類型的變量”
最後當去解引用的時候*(short*)&f
時,編譯器會取出前面兩個字節,並且按照 short 的編碼方式去解釋,並將解釋出的值賦給 c
變量。
這個過程 f
的位模式沒有發生任何改變,變的只是解釋這些位的方式。
當然,這裏最後的值肯定不是 1,至於是什麼,大家可以去真正算一下。
那反過來,這樣呢?
short c = 1;
float f = *(float*)&c;
如圖:
具體過程和上述一樣,但上面肯定不會報錯,這裏卻不一定。
爲什麼?
(float*)&c
會讓我們從c
的首地址開始取四個字節,然後按照 float 的編碼方式去解釋。
但是c
是 short 類型只佔兩個字節,那肯定會訪問到相鄰後面兩個字節,這時候就發生了內存訪問越界。
當然,如果只是讀,大概率是沒問題的。
但是,有時候需要向這個區域寫入新的值,比如:
*(float*)&c = 1.0;
那麼就可能發生 coredump,也就是訪存失敗。
另外,就算是不會 coredump,這種也會破壞這塊內存原有的值,因爲很可能這是是其它變量的內存空間,而我們去覆蓋了人家的內容,肯定會導致隱藏的 bug。
如果你理解了上面這些內容,那麼使用指針一定會更加的自如。
2.6 看個小問題
講到這裏,我們來看一個問題,這是一位羣友問的,這是他的需求:
這是他寫的代碼:
他把 double 寫進文件再讀出來,然後發現打印的值對不上。
而關鍵的地方就在於這裏:
char buffer[4];
...
printf("%f %x\n", *buffer, *buffer);
他可能認爲 buffer
是一個指針(準確說是數組),對指針解引用就該拿到裏面的值,而裏面的值他認爲是從文件讀出來的 4 個byte,也就是之前的 float 變量。
注意,這一切都是他認爲的,實際上編譯器會認爲:
“哦,buffer
是 char類型的指針,那我取第一個字節出來就好了”。
然後把第一個字節的值傳遞給了 printf 函數,printf 函數會發現,%f
要求接收的是一個 float 浮點數,那就會自動把第一個字節的值轉換爲一個浮點數打印出來。
這就是整個過程。
錯誤關鍵就是,這個同學誤認爲,任何指針解引用都是拿到裏面“我們認爲的那個值”,實際上編譯器並不知道,編譯器只會傻傻的按照指針的類型去解釋。
所以這裏改成:
printf("%f %x\n", *(float*)buffer, *(float*)buffer);
相當於明確的告訴編譯器:
“buffer
指向的這個地方,我放的是一個 float,你給我按照 float 去解釋”
三、 結構體和指針
結構體內包含多個成員,這些成員之間在內存中是如何存放的呢?
比如:
struct fraction {
int num; // 整數部分
int denom; // 小數部分
};
struct fraction fp;
fp.num = 10;
fp.denom = 2;
這是一個定點小數結構體,它在內存佔 8 個字節(這裏不考慮內存對齊),兩個成員域是這樣存儲的:
我們把 10 放在了結構體中基地址偏移爲 0 的域,2 放在了偏移爲 4 的域。
接下來我們做一個正常人永遠不會做的操作:
((fraction*)(&fp.denom))->num = 5;
((fraction*)(&fp.denom))->denom = 12;
printf("%d\n", fp.denom); // 輸出多少?
上面這個究竟會輸出多少呢?自己先思考下噢~
接下來我分析下這個過程發生了什麼:
首先,&fp.denom
表示取結構體 fp 中 denom 域的首地址,然後以這個地址爲起始地址取 8 個字節,並且將它們看做一個 fraction 結構體。
在這個新結構體中,最上面四個字節變成了 denom 域,而 fp 的 denom 域相當於新結構體的 num 域。
因此:
((fraction*)(&fp.denom))->num = 5
實際上改變的是 fp.denom
,而
((fraction*)(&fp.denom))->denom = 12
則是將最上面四個字節賦值爲 12。
當然,往那四字節內存寫入值,結果是無法預測的,可能會造成程序崩潰,因爲也許那裏恰好存儲着函數調用棧幀的關鍵信息,也可能那裏沒有寫入權限。
大家初學 C 語言的很多 coredump 錯誤都是類似原因造成的。
所以最後輸出的是 5。
爲什麼要講這種看起來莫名其妙的代碼?
就是爲了說明結構體的本質其實就是一堆的變量打包放在一起,而訪問結構體中的域,就是通過結構體的起始地址,也叫基地址,然後加上域的偏移。
其實,C++、Java 中的對象也是這樣存儲的,無非是他們爲了實現某些面向對象的特性,會在數據成員以外,添加一些 Head 信息,比如C++ 的虛函數表。
實際上,我們是完全可以用 C 語言去模仿的。
這就是爲什麼一直說 C 語言是基礎,你真正懂了 C 指針和內存,對於其它語言你也會很快的理解其對象模型以及內存佈局。
四、多級指針
說起多級指針這個東西,我以前大一,最多理解到 2 級,再多真的會把我繞暈,經常也會寫錯代碼。
你要是給我寫個這個:int ******p
能把我搞崩潰,我估計很多同學現在就是這種情況🤣
其實,多級指針也沒那麼複雜,就是指針的指針的指針的指針......非常簡單。
今天就帶大家認識一下多級指針的本質。
首先,我要說一句話,沒有多級指針這種東西,指針就是指針,多級指針只是爲了我們方便表達而取的邏輯概念。
首先看下生活中的快遞櫃:
這種大家都用過吧,豐巢或者超市儲物櫃都是這樣,每個格子都有一個編號,我們只需要拿到編號,然後就能找到對應的格子,取出裏面的東西。
這裏的格子就是內存單元,編號就是地址,格子裏放的東西就對應存儲在內存中的內容。
假設我把一本書,放在了 03 號格子,然後把 03 這個編號告訴你,你就可以根據 03 去取到裏面的書。
那如果我把書放在 05 號格子,然後在 03 號格子只放一個小紙條,上面寫着:「書放在 05 號」。
你會怎麼做?
當然是打開 03 號格子,然後取出了紙條,根據上面內容去打開 05 號格子得到書。
這裏的 03 號格子就叫指針,因爲它裏面放的是指向其它格子的小紙條(地址)而不是具體的書。
明白了嗎?
那我如果把書放在 07 號格子,然後在 05 號格子 放一個紙條:「書放在 07號」,同時在03號格子放一個紙條「書放在 05號」
這裏的 03 號格子就叫二級指針,05 號格子就叫指針,而 07 號就是我們平常用的變量。
依次,可類推出 N 級指針。
所以你明白了嗎?同樣的一塊內存,如果存放的是別的變量的地址,那麼就叫指針,存放的是實際內容,就叫變量。
int a;
int *pa = &a;
int **ppa = &pa;
int ***pppa = &ppa;
上面這段代碼,pa
就叫一級指針,也就是平時常說的指針,ppa
就是二級指針。
內存示意圖如下:
不管幾級指針有兩個最核心的東西:
- 指針本身也是一個變量,需要內存去存儲,指針也有自己的地址
- 指針內存存儲的是它所指向變量的地址
這就是我爲什麼多級指針是邏輯上的概念,實際上一塊內存要麼放實際內容,要麼放其它變量地址,就這麼簡單。
怎麼去解讀int **a
這種表達呢?
int ** a
可以把它分爲兩部分看,即int*
和 *a
,後面 *a
中的*
表示 a
是一個指針變量,前面的 int*
表示指針變量a
只能存放 int*
型變量的地址。
對於二級指針甚至多級指針,我們都可以把它拆成兩部分。
首先不管是多少級的指針變量,它首先是一個指針變量,指針變量就是一個*
,其餘的*
表示的是這個指針變量只能存放什麼類型變量的地址。
比如int****a
表示指針變量 a
只能存放int***
型變量的地址。
五、指針與數組
5.1 一維數組
數組是 C 自帶的基本數據結構,徹底理解數組及其用法是開發高效應用程序的基礎。
數組和指針表示法緊密關聯,在合適的上下文中可以互換。
如下:
int array[10] = {10, 9, 8, 7};
printf("%d\n", *array); // 輸出 10
printf("%d\n", array[0]); // 輸出 10
printf("%d\n", array[1]); // 輸出 9
printf("%d\n", *(array+1)); // 輸出 9
int *pa = array;
printf("%d\n", *pa); // 輸出 10
printf("%d\n", pa[0]); // 輸出 10
printf("%d\n", pa[1]); // 輸出 9
printf("%d\n", *(pa+1)); // 輸出 9
在內存中,數組是一塊連續的內存空間:
第 0 個元素的地址稱爲數組的首地址,數組名實際就是指向數組首地址,當我們通過array[1]
或者*(array + 1)
去訪問數組元素的時候。
實際上可以看做 address[offset]
,address
爲起始地址,offset
爲偏移量,但是注意這裏的偏移量offset
不是直接和 address
相加,而是要乘以數組類型所佔字節數,也就是: address + sizeof(int) * offset
。
學過彙編的同學,一定對這種方式不陌生,這是彙編中尋址方式的一種:基址變址尋址。
看完上面的代碼,很多同學可能會認爲指針和數組完全一致,可以互換,這是完全錯誤的。
儘管數組名字有時候可以當做指針來用,但數組的名字不是指針。
最典型的地方就是在 sizeof:
printf("%u", sizeof(array));
printf("%u", sizeof(pa));
第一個將會輸出 40,因爲 array
包含有 10 個int類型的元素,而第二個在 32 位機器上將會輸出 4,也就是指針的長度。
爲什麼會這樣呢?
站在編譯器的角度講,變量名、數組名都是一種符號,它們都是有類型的,它們最終都要和數據綁定起來。
變量名用來指代一份數據,數組名用來指代一組數據(數據集合),它們都是有類型的,以便推斷出所指代的數據的長度。
對,數組也有類型,我們可以將 int、float、char 等理解爲基本類型,將數組理解爲由基本類型派生得到的稍微複雜一些的類型,
數組的類型由元素的類型和數組的長度共同構成。而 sizeof
就是根據變量的類型來計算長度的,並且計算的過程是在編譯期,而不會在程序運行時。
編譯器在編譯過程中會創建一張專門的表格用來保存變量名及其對應的數據類型、地址、作用域等信息。
sizeof
是一個操作符,不是函數,使用 sizeof
時可以從這張表格中查詢到符號的長度。
所以,這裏對數組名使用sizeof
可以查詢到數組實際的長度。
pa
僅僅是一個指向 int 類型的指針,編譯器根本不知道它指向的是一個整數,還是一堆整數。
雖然在這裏它指向的是一個數組,但數組也只是一塊連續的內存,沒有開始和結束標誌,也沒有額外的信息來記錄數組到底多長。
所以對 pa
使用 sizeof
只能求得的是指針變量本身的長度。
也就是說,編譯器並沒有把 pa
和數組關聯起來,pa
僅僅是一個指針變量,不管它指向哪裏,sizeof
求得的永遠是它本身所佔用的字節數。
5.2 二維數組
大家不要認爲二維數組在內存中就是按行、列這樣二維存儲的,實際上,不管二維、三維數組... 都是編譯器的語法糖。
存儲上和一維數組沒有本質區別,舉個例子:
int array[3][3] = {{1, 2,3}, {4, 5,6},{7, 8, 9}};
array[1][1] = 5;
或許你以爲在內存中 array
數組會像一個二維矩陣:
1 2 3
4 5 6
7 8 9
可實際上它是這樣的:
1 2 3 4 5 6 7 8 9
和一維數組沒有什麼區別,都是一維線性排列。
當我們像 array[1][1]
這樣去訪問的時候,編譯器會怎麼去計算我們真正所訪問元素的地址呢?
爲了更加通用化,假設數組定義是這樣的:
int array[n][m]
訪問: array[a][b]
那麼被訪問元素地址的計算方式就是: array + (m * a + b)
這個就是二維數組在內存中的本質,其實和一維數組是一樣的,只是語法糖包裝成一個二維的樣子。
六、神奇的 void 指針
想必大家一定看到過 void 的這些用法:
void func();
int func1(void);
在這些情況下,void 表達的意思就是沒有返回值或者參數爲空。
但是對於 void 型指針卻表示通用指針,可以用來存放任何數據類型的引用。
下面的例子就 是一個 void 指針:
void *ptr;
void 指針最大的用處就是在 C 語言中實現泛型編程,因爲任何指針都可以被賦給 void 指針,void 指針也可以被轉換回原來的指針類型, 並且這個過程指針實際所指向的地址並不會發生變化。
比如:
int num;
int *pi = #
printf("address of pi: %p\n", pi);
void* pv = pi;
pi = (int*) pv;
printf("address of pi: %p\n", pi);
這兩次輸出的值都會是一樣:
平常可能很少會這樣去轉換,但是當你用 C 寫大型軟件或者寫一些通用庫的時候,一定離不開 void 指針,這是 C 泛型的基石,比如 std 庫裏的 sort 函數申明是這樣的:
void qsort(void *base,int nelem,int width,int (*fcmp)(const void *,const void *));
所有關於具體元素類型的地方全部用 void 代替。
void 還可以用來實現 C 語言中的多態,這是一個挺好玩的東西。
不過也有需要注意的:
- 不能對 void 指針解引用
比如:
int num;
void *pv = (void*)#
*pv = 4; // 錯誤
爲什麼?
因爲解引用的本質就是編譯器根據指針所指的類型,然後從指針所指向的內存連續取 N 個字節,然後將這 N 個字節按照指針的類型去解釋。
比如 int *型指針,那麼這裏 N 就是 4,然後按照 int 的編碼方式去解釋數字。
但是 void,編譯器是不知道它到底指向的是 int、double、或者是一個結構體,所以編譯器沒法對 void 型指針解引用。
七、花式秀技
很多同學認爲 C 就只能面向過程編程,實際上利用指針,我們一樣可以在 C 中模擬出對象、繼承、多態等東西。
也可以利用 void 指針實現泛型編程,也就是 Java、C++ 中的模板。
大家如果對 C 實現面向對象、模板、繼承這些感興趣的話,可以積極一點,點贊,留言~ 呼聲高的話,我就再寫一篇。
實際上也是很有趣的東西,當你知道了如何用 C 去實現這些東西,那你對 C++ 中的對象、Java 中的對象也會理解得更加透徹。
比如爲啥有 this
指針,或者 Python 中的 self
究竟是個啥?
關於指針想寫的內容還有很多,這其實也只算是開了個頭,限於篇幅,以後有機會補齊以下內容:
- 二維數組和二維指針
- 數組指針和指針數組
- 指針運算
- 函數指針
- 動態內存分配: malloc 和 free
- 堆、棧
- 函數參數傳遞方式
- 內存泄露
- 數組退化成指針
- const 修飾指針
- ...
絮叨
我其實挺想寫一個系列,大概就是關於內存、指針、引用、函數調用、堆棧、面向對象實現機制等等這樣的底層一點的東西。
不知道大家有興趣沒有,有興趣的話,那就給我點個贊或者在看,數量夠多,我就會寫下去。
太少的話,就繼續寫受衆更廣知識,比如網絡、算法、MySQL、Redis、系統設計之類的東西。
對了,今晚是萬聖節之夜🎃
Happy halloween~
我是小北,咱們明天再見~
文章持續更新,可以微信搜一搜「 編程指北 」第一時間閱讀,有我準備的編程電子書和一線大廠面試資料