c是編譯時還是運行時

A. c語言中編譯 生成 調試 測試 運行各是什麼意思有什麼區別

C語言中編譯 生成 調試 測試 運行的區別如下：

區別一：

從編譯方面來看：

編譯依賴於編譯器，英文是compile, vc中這一過程是將源代碼轉換成目標文件，如：obj文件，rc文件等。

區別二：

從生成方面來看：

生成指的是連接的過程,英文是build，依賴於鏈接器。vc中在這一階段將所有的目標文件和所有需要用到的組件組合成一個整體，例如需要生成的是windows系統下的PE可執行文件，鏈接器會依照特定格式將目標文件組合，最後生成PE格式的，exe或dll文件。

區別三：

從調試方面來看：

調試是所有或部分代碼編寫完成後，讓程序在調試器中運行，用這種手段對程序進行分析，找出並修正潛在問題。

區別四：

從運行方面來看：

運行就是讓程序在系統中運行。

(1)c是編譯時還是運行時擴展閱讀：

C語言的介紹：

C語言是目前流行的通用程序設計語言,是計算機專業人員和計算機愛好者開發軟體的首選開發工具。C語言源程序必須經過某種編譯工具翻譯成為目標機器語言程序才能夠在計算機上執行。

然而隨著程序編寫規模的擴大，順利編寫出正確的程序絕非一件容易的事情，早期的許多編譯工具僅僅提供翻譯功能，已滿足不了應用的要求，編程人員需要-種功能全面並高度集成的編譯環境。

程序是一段具有一定功能的代碼，編寫程序的目的是解決問題。當程序人員寫完程序後，其實並不起作用，只有當編寫的程序經過一系列的處理後，能夠解決問題時。

序才成為真正的程序，這一系列的處理過程，-般就是編輯、編譯、連接、調試與運行等。目前最成熟的C語言集成環境主要有Turbo C2.0和Turbo C 3.0( 簡稱TC30)或Borland C++3.1( 簡稱BC31)以及Visual C++ 6.0。

B. C++中什麼是編譯時,什麼是運行時,二者有何區別

編譯階段主要進行語法的檢查，無誤。將程序代碼轉換成目標代碼（二進製表示，打開看不懂），沒有和操作系統進行連接，不能運行。完成連接後，程序能夠進入系統運行。
運行時，一定是編譯過的，沒有語法錯誤。編譯時，沒有生成目標文件，可能有語法錯誤。

C. c語言是編譯型語言嗎

當然！

c程序，編譯後才能運行

D. C代碼咋判斷是「編譯時執行」還是「運行時執行」

如何判斷？其實沒有一個准確的答案。
常量及常量和基本運算符組成的運算表達式，一般是在編譯時做的，
比如，
int a = 3;
int b = 3 + 5;
這里的 3 和 8 通常是由編譯器運算完成後固化到代碼中的，但是a 和 b 兩個變數的位置，則是運行時確定的，由線程棧的地址確定，程序中只有一個偏移的多少個位元組的標記。

sizeof() 編譯運算符，是用於取其內的變數的類型或一個指定的類型 在 線程棧上佔用的 位元組數，比如在32位機上
int* p;
p = (int*)malloc(1000);
sizeof(p) 的值為4 ，因為p的類型就是一個指針，而在32位機里，指針的長度就是4個位元組。

傳給sizeof 編譯運算符號的，必須是一個明確的類型。

一般有函數調用的，都是運行時執行的，通常編譯器不會把函數優化掉。
一般作用於棧上的操作，又沒有函數調用的，是在編譯時優化處理的。

E. C語言程序中的關於常量的計算是在編譯時進行的還是程序執行時進行的

編譯的時候，先會進行預編譯處理，就是把程序中所有的符號常量用數字常量替換，比如說你的例子中的N，注意只是發生替換，所有的計算都是在程序執行的時候進行的！
C是面向過程的，每次執行都會重新計算一次！

F. 執行C語言一定要先編譯么，不可以直接執行么

一般來說編譯過後就成了基本上能執行的2進制代碼。但是這些2進制代碼並不完善，一個程序往往需要調用不止一部分的代碼，所以需要把這些代碼全部整合起來才能執行。
即時你的程序看起來只有一個文件，但是編譯過後，多多少少裡面至少會調用到一些操作系統功能，和其它的一些設置，所以依然需要組建這個過程把這個程序和這些系統默認的代碼組建起來形成一個完成、單一的可執行文件。所以一般組建過程就包含了組建內部和外部代碼，一般來說內部代碼就是我說的系統預留的必要的一些代碼（例如怎麼具體完成把一些字元顯示在屏幕上呀這些功能），而外部代碼就是額外的調用自己寫得或者別人寫得其它程序功能（往往當你的程序調用了非c標准函數的時候）。
所以就算你的代碼可以編譯，但是可能因為組建並不成功（例如需要組建的代碼本身有bug，或者丟失，或者版本不匹配），你的程序依然可能無法正確運行。

G. C語言是解釋類還是編譯類的語言什麼是解釋類語言,編譯類語言

C語言是屬編譯類語言

計算機不能直接理解高級語言，只能直接理解機器語言，所以必須要把高級語言翻譯成機器語言，計算機才能執行高級語言編寫的程序。
翻譯的方式有兩種，一個是編譯，一個是解釋。兩種方式只是翻譯的時間不同。編譯型語言寫的程序執行之前，需要一個專門的編譯過程，把程序編譯成為機器語言的文件，比如exe文件，以後要運行的話就不用重新翻譯了，直接使用編譯的結果就行了（exe文件），因為翻譯只做了一次，運行時不需要翻譯，所以編譯型語言的程序執行效率高。
解釋則不同，解釋性語言的程序不需要編譯，省了道工序，解釋性語言在運行程序的時候才翻譯，比如解釋性basic語言，專門有一個解釋器能夠直接執行basic程序，每個語句都是執行的時候才翻譯。這樣解釋性語言每執行一次就要翻譯一次，效率比較低。
java很特殊，java程序也需要編譯，但是沒有直接編譯稱為機器語言，而是編譯稱為位元組碼，然後用解釋方式執行位元組碼。

H. C語言文件的編譯與執行的四個階段並分別描述

開發C程序有四個步驟：編輯、編譯、連接和運行。

任何一個體系結構處理器上都可以使用C語言程序，只要該體系結構處理器有相應的C語言編譯器和庫，那麼C源代碼就可以編譯並連接到目標二進制文件上運行。

1、預處理：導入源程序並保存（C文件）。

2、編譯：將源程序轉換為目標文件（Obj文件）。

3、鏈接：將目標文件生成為可執行文件（EXE文件）。

4、運行：執行，獲取運行結果的EXE文件。

(8)c是編譯時還是運行時擴展閱讀：

將C語言代碼分為程序的幾個階段：

1、首先，源代碼文件測試。以及相關的頭文件，比如stdio。H、由預處理器CPP預處理為．I文件。預編譯的。文件不包含任何宏定義，因為所有宏都已展開，並且包含的文件已插入。我歸檔。

2、編譯過程是對預處理文件進行詞法分析、語法分析、語義分析和優化，生成相應的匯編代碼文件。這個過程往往是整個程序的核心部分，也是最復雜的部分之一。

3、匯編程序不直接輸出可執行文件，而是輸出目標文件。匯編程序可以調用LD來生成可以運行的可執行程序。也就是說，您需要鏈接大量的文件才能獲得「a.out」，即最終的可執行文件。

4、在鏈接過程中，需要重新調整其他目標文件中定義的函數調用指令，而其他目標文件中定義的變數也存在同樣的問題。

I. C語言中 sizeof 運算的值是在編譯時還是運

一、在 Pascal 語言中，sizeof() 是一種內存容量度量函數，功能是返回一個變數或者類型的大小（以位元組為單位）；在 C 語言中，sizeof() 是一個判斷數據類型或者表達式長度的運算符。在Pascal 語言與C語言中，對 sizeof() 的處理都是在編譯階段進行。

二、C語言中

1. 判斷數據類型長度符的關鍵字

2. 用法

   sizeof(類型說明符，數組名或表達式);
   或sizeof (變數名);

3. 定義

4. sizeof是C/C++中的一個操作符（operator），簡單的說其作用就是返回一個對象或者類型所佔的內存位元組數。

   MSDN上的解釋為：

   The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type(including aggregate types). This keyword returns a value of type size_t.

   其返回值類型為size_t，在頭文件stddef.h中定義。這是一個依賴於編譯系統的值，一般定義為

5. typedefunsignedintsize_t;

6. 在C99及以上標准中，sizeof(char)、sizeof(int)、sizeof(long)、sizeof(long long)、sizeof(float)、sizeof(double)、sizeof(long double)的值分別是1，4，4，8，4，8，16。[1]

7. 語法

   sizeof有三種語法形式，如下：

8. sizeof(object);//sizeof(對象);
   sizeof(type_name);//sizeof(類型);
   sizeofobject;//sizeof對象;

   所以，

9. inti;
   sizeof(i);//ok
   sizeofi;//ok
   sizeof(int);//ok
   sizeofint;//error

   既然寫法3可以用寫法1代替，為求形式統一以及減少我們大腦的負擔，第3種寫法，忘掉它吧！實際上，sizeof計算對象的大小也是轉換成對對象類型的計算，也就是說，同種類型的不同對象其sizeof值都是一致的。這里，對象可以進一步延伸至表達式，即sizeof可以對一個表達式求值，編譯器根據表達式的最終結果類型來確定大小，一般不會對表達式進行計算。如：

10. sizeof(2);//2的類型為int，所以等價於sizeof(int);
    sizeof(2+3.14);//3.14的類型為double，2也會被提升成double類型，所以等價於sizeof(double);

11. sizeof也可以對一個函數調用求值，其結果是函數返回類型的大小，函數並不會被調用，我們來看一個完整的例子：

12. charfoo()
    {
    printf("foo()hasbeencalled.
    ");
    return'a';
    }
    intmain()
    {
    size_tsz=sizeof(foo());
    //foo()的返回值類型為char，所以sz=sizeof(char)，foo()並不會被調用
    printf("sizeof(foo())=%d
    ",sz);
    }

13. C99標准規定，函數、不能確定類型的表達式以及位域（bit-field）成員不能被計算sizeof值，即下面這些寫法都是錯誤的：[1]

14. sizeof(foo);//error
    voidfoo2(){}
    sizeof(foo2());//error
    structS
    {
    unsignedintf1:1;
    unsignedintf2:5;
    unsignedintf3:12;
    };
    sizeof(S.f1);//error

15. sizeof的常量性

    sizeof的計算發生在編譯時刻，所以它可以被當作常量表達式使用，如：

    charary[sizeof(int)*10];//ok
    

16. 最新的C99標准規定sizeof也可以在運行時刻進行計算，如下面的程序在Dev-C++中可以正確執行：[1]

17. intn;
    n=10;//n動態賦值
    charary[n];//C99也支持數組的動態定義
    printf("%d
    ",sizeof(ary));//ok.輸出10

18. 但在沒有完全實現C99標準的編譯器中就行不通了，上面的代碼在VC6中就通不過編譯。所以我們最好還是認為sizeof是在編譯期執行的，這樣不會帶來錯誤，讓程序的可移植性強些。

    基本數據類型的sizeof

    這里的基本數據類型指short、int、long、float、double這樣的簡單內置數據類型，由於它們都是和系統相關的，所以在不同的系統下取值可能不同，這務必引起我們的注意，盡量不要在這方面給自己程序的移植造成麻煩。

    一般的，在32位編譯環境中，sizeof(int)的取值為4。

19. 指針變數的sizeof

    學過數據結構的你應該知道指針是一個很重要的概念，它記錄了另一個對象的地址。既然是來存放地址的，那麼它當然等於計算機內部地址匯流排的寬度。所以在32位計算機中，一個指針變數的返回值必定是4（注意結果是以位元組為單位），但是，在64位系統中指針變數的sizeof結果為8。

20. char*pc="abc";
    int*pi;
    string*ps;
    char**ppc=&pc;
    void(*pf)();//函數指針
    sizeof(pc);//結果為4
    sizeof(pi);//結果為4
    sizeof(ps);//結果為4
    sizeof(ppc);//結果為4
    sizeof(pf);//結果為4

21. 指針變數的sizeof值與指針所指的對象沒有任何關系，正是由於所有的指針變數所佔內存大小相等，所以MFC消息處理函數使用兩個參數WPARAM、LPARAM就能傳遞各種復雜的消息結構（使用指向結構體的指針）。

    數組的sizeof

    數組的sizeof值等於數組所佔用的內存位元組數，如：

    char a1[] = "abc"; int a2[3]; sizeof( a1 ); // 結果為4，字元末尾還存在一個NULL終止符 sizeof( a2 ); // 結果為3*4=12（依賴於int）

    一些朋友剛開始時把sizeof當作了求數組元素的個數，如今你應該知道這是不對的，那麼應該怎麼求數組元素的個數呢Easy，通常有下面兩種寫法：

22. intc1=sizeof(a1)/sizeof(char);//總長度/單個元素的長度char型
    intc2=sizeof(a2)/sizeof(a2[0]);//總長度/第一個元素的長度int型

    寫到這里，提一問，下面的c3，c4值應該是多少呢

23. voidfoo3(chara3[3])
    {
    intc3=sizeof(a3);//c3==
    }
    voidfoo4(chara4[])
    {
    intc4=sizeof(a4);//c4==
    }

    也許當你試圖回答c4的值時已經意識到c3答錯了，是的，c3!=3。這里函數參數a3已不再是數組類型，而是蛻變成指針，相當於char* a3，為什麼仔細想想就不難明白，我們調用函數foo3時，程序會在棧上分配一個大小為3的數組嗎不會！數組是「傳址」的，調用者只需將實參的地址傳遞過去，所以a3自然為指針類型（char*），c3的值也就為4。

    結構體的sizeof

    這是初學者問得最多的一個問題，所以這里有必要多費點筆墨。讓我們先看一個結構體：

    structS1{charc;inti;};
    

    問sizeof(s1)等於多少聰明的你開始思考了，char佔1個位元組，int佔4個位元組，那麼加起來就應該是5。是這樣嗎？你在你機器上試過了嗎？也許你是對的，但很可能你是錯的！VC6中按默認設置得到的結果為8。
    

    我們來好好琢磨一下sizeof的定義——sizeof的結果等於對象或者類型所佔的內存位元組數，好吧，那就讓我們來看看S1的內存分配情況：

    S1 s1={'a',0xFFFFFFFF};

    定義上面的變數後，加上斷點，運行程序，觀察s1所在的內存，你發現了什麼

    以我的VC6.0為例，s1的地址為0x0012FF78，其數據內容如下：

    0012FF78: 61 CC CC CC FF FF FF FF

    發現了什麼怎麼中間夾雜了3個位元組的CC看看MSDN上的說明：

    When applied to a structure type or variable, sizeof returns the actual size, which may include padding bytes inserted for alignment.

    原來如此，這就是傳說中的位元組對齊啊！一個重要的話題出現了。

    為什麼需要位元組對齊計算機組成原理教導我們這樣有助於加快計算機的取數速度，否則就得多花指令周期了。為此，編譯器默認會對結構體進行處理（實際上其它地方的數據變數也是如此），讓寬度為2的基本數據類型（short等）都位於能被2整除的地址上，讓寬度為4的基本數據類型（int等）都位於能被4整除的地址上，以此類推。這樣，兩個數中間就可能需要加入填充位元組，所以整個結構體的sizeof值就增長了。

    讓我們交換一下S1中char與int的位置：

    struct S2{inti;charc;};

    看看sizeof(S2)的結果為多少，怎麼還是8再看看內存，原來成員c後面仍然有3個填充位元組，這又是為什麼啊別著急，下面總結規律。

    位元組對齊的細節和編譯器實現相關，但一般而言，滿足三個准則：

24. 1)結構體變數的首地址能夠被其最寬基本類型成員的大小所整除；

    2)結構體每個成員相對於結構體首地址的偏移量（offset）都是成員大小的整數倍，如有需要編譯器會在成員之間加上填充位元組（internal padding）；

    3)結構體的總大小為結構體最寬基本類型成員大小的整數倍，如有需要編譯器會在最末一個成員之後加上填充位元組（trailing padding）。

    對於上面的准則，有幾點需要說明：

    1) 前面不是說結構體成員的地址是其大小的整數倍，怎麼又說到偏移量了呢因為有了第1點存在，所以我們就可以只考慮成員的偏移量，這樣思考起來簡單。想想為什麼。

    結構體某個成員相對於結構體首地址的偏移量可以通過宏offsetof()來獲得，這個宏也在stddef.h中定義，如下：

    #define offsetof(s,m)(size_t)&(((s*)0)->m)

    例如，想要獲得S2中c的偏移量，方法為

    size_tpos=offsetof(S2,c);//pos等於4

    2) 基本類型是指前面提到的像char、short、int、float、double這樣的內置數據類型，這里所說的「數據寬度」就是指其sizeof的大小。由於結構體的成員可以是復合類型，比如另外一個結構體，所以在尋找最寬基本類型成員時，應當包括復合類型成員的子成員，而不是把復合成員看成是一個整體。但在確定復合類型成員的偏移位置時則是將復合類型作為整體看待。

    這里敘述起來有點拗口，思考起來也有點撓頭，還是讓我們看看例子吧（具體數值仍以VC6為例，以後不再說明）：

    struct S3{charc1;S1s;charc2;};

    S1的最寬簡單成員的類型為int，S3在考慮最寬簡單類型成員時是將S1「打散」看的，所以S3的最寬簡單類型為int，這樣，通過S3定義的變數，其存儲空間首地址需要被4整除，整個sizeof(S3)的值也應該被4整除。

    c1的偏移量為0，s的偏移量呢這時s是一個整體，它作為結構體變數也滿足前面三個准則，所以其大小為8，偏移量為4，c1與s之間便需要3個填充位元組，而c2與s之間就不需要了，所以c2的偏移量為12，算上c2的大小為13，13是不能被4整除的，這樣末尾還得補上3個填充位元組。最後得到sizeof(S3)的值為16。

    通過上面的敘述，我們可以得到一個公式：

    結構體的大小等於最後一個成員的偏移量加上其大小再加上末尾的填充位元組數目，即：

25. sizeof(struct)=offsetof(lastitem)+sizeof(lastitem)+sizeof(trailingpadding);

    到這里，朋友們應該對結構體的sizeof有了一個全新的認識，但不要高興得太早，有一個影響sizeof的重要參量還未被提及，那便是編譯器的pack指令。它是用來調整結構體對齊方式的，不同編譯器名稱和用法略有不同，VC6中通過#pragmapack實現，也可以直接修改/Zp編譯開關。#pragma pack的基本用法為：

    #pragmapack(n)，n為位元組對齊數，其取值為1、2、4、8、16，默認是8，如果這個值比結構體成員的sizeof值小，那麼，該成員的偏移量應該以此值為准，即是說，結構體成員的偏移量應該取二者的最小值，

    公式如下：

    offsetof(item)=min(n,sizeof(item))

26. 再看示例：

27. #pragmapack(push)//將當前pack設置壓棧保存
    #pragmapack(2)//必須在結構體定義之前使用
    structS1{charc;inti;};
    structS3{charc1;S1s;charc2;};
    #pragmapack(pop)//恢復先前的pack設置

    計算sizeof(S1)時，min(2, sizeof(i))的值為2，所以i的偏移量為2，加上sizeof(i)等於6，能夠被2整除，所以整個S1的大小為6。

    同樣，對於sizeof(S3)，s的偏移量為2，c2的偏移量為8，加上sizeof(c2)等於9，不能被2整除，添加一個填充位元組，所以sizeof(S3)等於10。

    如今，朋友們可以輕松的出一口氣了，:)

    還有一點要注意，「空結構體」（不含數據成員）的大小不為0，而是1。試想一個「不佔空間」的變數如何被取地址、兩個不同的「空結構體」變數又如何得以區分呢於是，「空結構體」變數也得被存儲，這樣編譯器也就只能為其分配一個位元組的空間用於佔位了。如下：

    struct S5 { }; sizeof( S5 ); // 結果為1含位域結構體的sizeof

    前面已經說過，位域成員不能單獨被取sizeof值，我們這里要討論的是含有位域的結構體的sizeof，只是考慮到其特殊性而將其專門列了出來。

    C99規定int、unsigned int和bool可以作為位域類型，但編譯器幾乎都對此作了擴展，允許其它類型類型的存在。使用位域的主要目的是壓縮存儲，其大致規則為：

28. 1) 如果相鄰位域欄位的類型相同，且其位寬之和小於類型的sizeof大小，則後面的欄位將緊鄰前一個欄位存儲，直到不能容納為止；

    2) 如果相鄰位域欄位的類型相同，但其位寬之和大於類型的sizeof大小，則後面的欄位將從新的存儲單元開始，其偏移量為其類型大小的整數倍；

    3) 如果相鄰的位域欄位的類型不同，則各編譯器的具體實現有差異，VC6採取不壓縮方式，Dev-C++採取壓縮方式；

    4) 如果位域欄位之間穿插著非位域欄位，則不進行壓縮；

    5) 整個結構體的總大小為最寬基本類型成員大小的整數倍。

29. 還是讓我們來看看例子。

    示例1：

    struct BF1{charf1:3;charf2:4;charf3:5;};

    其內存布局為：

30. |_f1__|__f2__|_|____f3___|____|
    

31. |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|

32. 0 3 7 8 1316
    

    位域類型為char，第1個位元組僅能容納下f1和f2，所以f2被壓縮到第1個位元組中，而f3隻

    能從下一個位元組開始。因此sizeof(BF1)的結果為2。

    示例2：

    structBF2{charf1:3;shortf2:4;charf3:5;};

    由於相鄰位域類型不同，在VC6中其sizeof為3，在Dev-C++中為2。

    示例3：

    structBF3{charf1:3;charf2;charf3:5;};

    非位域欄位穿插在其中，不會產生壓縮，在VC6和Dev-C++中得到的大小均為3。

    9.聯合體的sizeof

    結構體在內存組織上是順序式的，聯合體則是重疊式，各成員共享一段內存，所以整個聯合體的sizeof也就是每個成員sizeof的最大值。結構體的成員也可以是復合類型，這里，復合類型成員是被作為整體考慮的。

    所以，下面例子中，U的sizeof值等於sizeof(s)。

33. unionU
    {
    inti;
    charc;
    S1s;
    };

sizeof還可以用函數做參數，比如：

shortf();
printf("%d
",sizeof(f()));

輸出的結果是sizeof(short)，即2。

數組做sizeof的參數不退化，傳遞給strlen就退化為指針了。

大部分編譯程序在編譯的時候就把sizeof計算過了是類型或是變數的長度這就是sizeof(x)可以用來定義數組維數的原因

charstr[20]="0123456789";
inta=strlen(str);//a=10;
intb=sizeof(str);//而b=20;

7.sizeof後如果是類型必須加括弧，如果是變數名可以不加括弧。這是因為sizeof是個操作符不是個函數。

8.當適用於一個結構類型時或變數， sizeof 返回實際的大小，當適用於靜態的空間數組， sizeof 歸還全部數組的尺寸。

sizeof 操作符不能返回被動態分派的數組或外部數組的尺寸

9.數組作為參數傳給函數時傳的是指針而不是數組，傳遞的是數組的首地址，

fun(char[8])fun(char[])

都等價於 fun(char *)

1. 特別注意：

2. 1.sizeof是運算符，strlen是函數，具體如下：

3. sizeof

4. strlen

5. 頭文件：stddef.h格式：1) sizeof( object ); // sizeof( 對象 );

6. 2) sizeof( type_name ); // sizeof( 類型 );

7. 3) sizeof object; // sizeof 對象

8. 功能：一個對象或者類型所佔的內存位元組數;

9. 說明：sizeof操作符的結果類型是size_t，typedef unsigned int size_t;

10. 原型：extern unsigned int strlen(char *s);頭文件：string.h

11. 格式：strlen (字元數組名)

12. 功能：計算字元串s的(unsigned int型)長度,不包括''在內

13. 說明：返回s的長度，不包括結束符NULL。

14. 2.strlen只能用char*做參數，且必須是以''''結尾的，而sizeof可用類型做參數，還可用函數做參數，如：

    int sum();

    printf("%d ",sizeof(sum()));//輸出的結果是sizeof(int)，即4。

    數組做sizeof的參數不退化，傳遞給strlen就退化為指針了。

    大部分編譯程序,sizeof在編譯時確定，因此sizeof(x)可以用來定義數組維數；而strlen要在運行時才能計算出來，用來計算字元串的長度，而不是類型占內存的大小；

    char str[20]="0123456789";

    int len1=strlen(str);//len1=10;

    int len2=sizeof(str);//len2=20;

15. sizeof後，若為類型必須加括弧，若為變數名可以不加括弧。這是因為sizeof是個操作符不是個函數。
    當適用於一個結構類型時或變數， sizeof 返回實際的大小；當適用一靜態地空間數組，sizeof 歸還全部數組的尺寸。
    sizeof 操作符不能返回動態地被分派了的數組或外部的數組的尺寸；
    數組作為參數傳給函數時傳的是指針而不是數組，傳遞的是數組的首地址，
    如：

    fun(char[8])

    fun(char[])

16. 都等價於 fun( char * )
    在C++里參數傳遞數組永遠都是傳遞指向數組首元素的指針，編譯器不知道數組的大小，如果想在函數內知道數組的大小， 需要這樣做：
    進入函數後用memcpy拷貝出來，長度由另一個形參傳進去

17. fun(unsigedchar*p1,intlen)
    {
    unsignedchar*buf=newunsignedchar[len+1];
    memcpy(buf,p1,len);
    }

18. 常在用到 sizeof 和 strlen 的時候，通常是計算字元串數組的長度，如果是對指針，結果則會不一樣的：
    char* str = "abacd";
    sizeof(str) //結果 4 --->str是指向字元串常量的字元指針，sizeof 獲得的是一個指針所佔的空間,應該是長整型的，所以是4；
    sizeof(*str) //結果 1 --->*str是第一個字元，其實就是字元串的第一位'a' 所佔的內存空間，是char類型的，佔了 1 位；
    strlen(str)= 5 //--->若要獲得這個字元串的長度，則一定要使用 strlen

19. 看了上面的詳細解釋，發現兩者的使用還是有區別的，從這個例子可以看得很清楚：

    char str[20]="0123456789";

    int a=strlen(str); //a=10; >>>> strlen 計算字元串的長度，以結束符 0x00 為字元串結束。

20. int b=sizeof(str); //而b=20; >>>> sizeof 計算的則是分配的數組str[20] 所佔的內存空間的大小，不受裡面存儲的內容改變。上面是對靜態數組處理的結果，如果是對指針，結果就不一樣了

    char* ss = "0123456789";sizeof(ss) 結果 4 ===》ss是指向字元串常量的字元指針，sizeof 獲得的是一個指針的之所佔的空間,應該是長整型的，所以是4

    sizeof(*ss) 結果 1 ===》*ss是第一個字元其實就是獲得了字元串的第一位'0' 所佔的內存空間，是char類型的，佔了 1 個位元組

    strlen(ss)= 10 >>>> 如果要獲得這個字元串的長度，則一定要使用 strlen

    sizeof返回對象所佔用的位元組大小. //正確

    strlen返回字元個數. //正確

21. 在使用sizeof時，有一個很特別的情況，就是數組名到指針蛻變，

    charArray[3]={'0'};

    sizeof(Array)==3;

    char*p=Array;

    strlen(p)==1;//sizeof(p)結果為4

    在傳遞一個數組名到一個函數中時，它會完全退化為一個指針
    

    大部分編譯程序 在編譯的時候就把sizeof計算過了 是類型或是變數的長度

    這就是sizeof(x)可以用來定義數組維數的原因

22. charstr[20]="0123456789";
    inta=strlen(str);//a=10;
    intb=sizeof(str);//而b=20;
    charss[]="0123456789";
    sizeof(ss)結果11===》ss是數組，計算到位置，因此是10+1
    sizeof(*ss)結果1===》*ss是第一個字元
    charss[100]="0123456789";
    sizeof(ss)結果是100===》ss表示在內存中的大小100×1
    strlen(ss)結果是10===》strlen是個函數內部實現是用一個循環計算到為止之前
    intss[100]="0123456789";
    sizeof(ss)結果400===》ss表示在內存中的大小100×4
    strlen(ss)錯誤===》strlen的參數只能是char*且必須是以''結尾的
    charq[]="abc";
    charp[]="a
    ";
    sizeof(q),sizeof(p),strlen(q),strlen(p);

    結果是 4 3 3 2

23. 第三個例子

    charszPath[MAX_PATH]
    

    如果在函數內這樣定義，那麼sizeof(szPath)將會是MAX_PATH，但是將szPath作為虛參聲明時

    （voidfun(charszPath[MAX_PATH]))

    sizeof(szPath) 卻會是4(指針大小)

    還有一位網友的說明也很好：

    其實理解 sizeof 只需要抓住一個要點：棧

    程序存儲分布有三個區域：棧、靜態和動態。能夠從代碼直接操作的對象，包括任何類型的變數、指針，都是在棧上的；動態和靜態存儲區是靠棧上的所有指針間接操作的。 sizeof 操作符，計算的是對象在棧上的投影體積；記住這個就很多東西都很清楚了。

24. charconst*static_string="Hello";
    //sizeof(static_string)是sizeof一個指針，所以在32bitsystem是4
    charstack_string[]="Hello";
    //sizeof(stack_string)是sizeof一個數組，所以是6*sizeof(char)
    char*string=newchar[6];
    strncpy(string,"Hello",6");
    //sizeof(string)是sizeof一個指針，所以還是4。
    //和第一個不同的是，這個指針指向了動態存儲區而不是靜態存儲區。

    不管指針指向的內容在什麼地方，sizeof 得到的都是指針的棧大小

    C++ 中對引用的處理比較特殊；sizeof 一個引用得到的結果是 sizeof 一個被引用的對象的大小；所以

25. structtest
    {
    inta,b,c,d,e,f,g,h;
    };
    intmain()
    {
    test&r=*newtest;
    cout<<sizeof(test)<<endl;//32
    cout<<sizeofr<<endl;//也是32
    system("PAUSE");
    }

    r 引用的是整個的 test 對象而不是指向 test 的指針，所以 sizeof r 的結果和 sizeof test 完全相同。

J. 初學c語言時，輸入程序後運行，是執行還是預編譯預編譯是什麼為什麼最開始要有#include如

預編譯是把一個工程中較穩定的代碼預先編譯好放在一個文件里.這些預先編譯好的代碼可以是任何的C/C++代碼。而輸入程序後的運行，只是將代碼編譯成了obj（object）文件，所有obj文件經鏈接(link)成為可執行文件。而你說的執行，應該就是點擊最後生成的.exe文件了。開始要有的#include，是表明要包含的頭文件，或者其它的保存的代碼文件。只有這樣，你才可以引用到那個文件中的代碼，來供目前的文件來使用。
至於你說的什麼大型游戲的編程，應該也是這樣的一套，因為C語言就是上述生成文件的套路。游戲的編程，初學的話可以建議看《游戲編程入門》（ 美 哈本），這本書基於windows平台，是為幾乎沒有游戲開發經驗的初學者寫的，循序漸進，從2D講到3D 的一些基本技術，其中的例子也非常經典，看完書基本就可以做出不錯的2D 游戲了，也有了一定的3D基礎了，之後再看一些深入的書籍像《Windows游戲編程大師技巧》。