預編譯指令

Ⅰ C語言預編譯命令

#include <assert.h> //設定插入點
#include <ctype.h> //字元處理
#include <errno.h> //定義錯誤碼
#include <float.h> //浮點數處理
#include <fstream.h> //文件輸入／輸出
#include <iomanip.h> //參數化輸入／輸出
#include <iostream.h> //數據流輸入／輸出
#include <limits.h> //定義各種數據類型最值常量
#include <locale.h> //定義本地化函數
#include <math.h> //定義數學函數
#include <stdio.h> //定義輸入／輸出函數
#include <stdlib.h> //定義雜項函數及內存分配函數
#include <string.h> //字元串處理
#include <strstrea.h> //基於數組的輸入／輸出
#include <time.h> //定義關於時間的函數
#include <wchar.h> //寬字元處理及輸入／輸出
#include <wctype.h> //寬字元分類

//////////////////////////////////////////////////////////////////////////

標准 C++ （同上的不再注釋）

#include <algorithm> //STL 通用演算法
#include <bitset> //STL 位集容器
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex> //復數類
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque> //STL 雙端隊列容器
#include <exception> //異常處理類
#include <fstream>
#include <functional> //STL 定義運算函數（代替運算符）
#include <limits>
#include <list> //STL 線性列表容器
#include <map> //STL 映射容器
#include <iomanip>
#include <ios> //基本輸入／輸出支持
#include <iosfwd> //輸入／輸出系統使用的前置聲明
#include <iostream>
#include <istream> //基本輸入流
#include <ostream> //基本輸出流
#include <queue> //STL 隊列容器
#include <set> //STL 集合容器
#include <sstream> //基於字元串的流
#include <stack> //STL 堆棧容器
#include <stdexcept> //標准異常類
#include <streambuf> //底層輸入／輸出支持
#include <string> //字元串類
#include <utility> //STL 通用模板類
#include <vector> //STL 動態數組容器
#include <cwchar>
#include <cwctype>

using namespace std;

//////////////////////////////////////////////////////////////////////////

C99 增加

#include <complex.h> //復數處理
#include <fenv.h> //浮點環境
#include <inttypes.h> //整數格式轉換
#include <stdbool.h> //布爾環境
#include <stdint.h> //整型環境
#include <tgmath.h> //通用類型數學宏

Ⅱ 編譯和預編譯有什麼區別。

預編譯又稱為預處理，是做些代碼文本的替換工作。

處理#開頭的指令，比如拷貝#include包含的文件代碼，#define宏定義的替換,條件編譯等

就是為編譯做的預備工作的階段

主要處理#開始的預編譯指令
編譯(compilation , compile) 1、利用編譯程序從源語言編寫的源程序產生目標程序的過程。 2、用編譯程序產生目標程序的動作。 編譯就是把高級語言變成計算機可以識別的2進制語言，計算機只認識1和0，編譯程序把人們熟悉的語言換成2進制的。

Ⅲ C語言提供的預編譯處理命令主要有哪三種

幾個預編譯指令的用法
預處理過程掃描源代碼，對其進行初步的轉換，產生新的源代碼提供給編譯器。可見預處理過程先於編譯器對源代碼進行處理。
在C語言中，並沒有任何內在的機制來完成如下一些功能：在編譯時包含其他源文件、定義宏、根據條件決定編譯時是否包含某些代碼。要完成這些工作，就需要使用預處理程序。盡管在目前絕大多數編譯器都包含了預處理程序，但通常認為它們是獨立於編譯器的。預處理過程讀入源代碼，檢查包含預處理指令的語句和宏定義，並對源代碼進行響應的轉換。預處理過程還會刪除程序中的注釋和多餘的空白字元。
預處理指令是以#號開頭的代碼行。#號必須是該行除了任何空白字元外的第一個字元。#後是指令關鍵字，在關鍵字和#號之間允許存在任意個數的空白字元。整行語句構成了一條預處理指令，該指令將在編譯器進行編譯之前對源代碼做某些轉換。下面是部分預處理指令：
指令
用途
#
空指令，無任何效果
#include
包含一個源代碼文件
#define
定義宏
#undef
取消已定義的宏
#if
如果給定條件為真，則編譯下面代碼
#ifdef
如果宏已經定義，則編譯下面代碼
#ifndef
如果宏沒有定義，則編譯下面代碼
#elif
如果前面的#if給定條件不為真，當前條件為真，則編譯下面代碼
#endif
結束一個#if……#else條件編譯塊
#error
停止編譯並顯示錯誤信息
一、文件包含
#include預處理指令的作用是在指令處展開被包含的文件。包含可以是多重的，也就是說一個被包含的文件中還可以包含其他文件。標准C編譯器至少支持八重嵌套包含。
預處理過程不檢查在轉換單元中是否已經包含了某個文件並阻止對它的多次包含。這樣就可以在多次包含同一個頭文件時，通過給定編譯時的條件來達到不同的效果。例如：
#define
AAA
#include
"t.c"
#undef
AAA
#include
"t.c"
為了避免那些只能包含一次的頭文件被多次包含，可以在頭文件中用編譯時條件來進行控制。例如：
#ifndef
MY_H
#define
MY_H
……
#endif
在程序中包含頭文件有兩種格式：
#include
<my.h>
#include
"my.h"
第一種方法是用尖括弧把頭文件括起來。這種格式告訴預處理程序在編譯器自帶的或外部庫的頭文件中搜索被包含的頭文件。第二種方法是用雙引號把頭文件括起來。這種格式告訴預處理程序在當前被編譯的應用程序的源代碼文件中搜索被包含的頭文件，如果找不到，再搜索編譯器自帶的頭文件。
採用兩種不同包含格式的理由在於，編譯器是安裝在公共子目錄下的，而被編譯的應用程序是在它們自己的私有子目錄下的。一個應用程序既包含編譯器提供的公共頭文件，也包含自定義的私有頭文件。採用兩種不同的包含格式使得編譯器能夠在很多頭文件中區別出一組公共的頭文件。
二、宏
宏定義了一個代表特定內容的標識符。預處理過程會把源代碼中出現的宏標識符替換成宏定義時的值。宏最常見的用法是定義代表某個值的全局符號。宏的第二種用法是定義帶參數的宏，這樣的宏可以象函數一樣被調用，但它是在調用語句處展開宏，並用調用時的實際參數來代替定義中的形式參數。
1.#define指令
#define預處理指令是用來定義宏的。該指令最簡單的格式是：首先神明一個標識符，然後給出這個標識符代表的代碼。在後面的源代碼中，就用這些代碼來替代該標識符。這種宏把程序中要用到的一些全局值提取出來，賦給一些記憶標識符。
#define
MAX_NUM
10
int
array[MAX_NUM];
for(i=0;i<MAX_NUM;i++)
在這個例子中，對於閱讀該程序的人來說，符號MAX_NUM就有特定的含義，它代表的值給出了數組所能容納的最大元素數目。程序中可以多次使用這個值。作為一種約定，習慣上總是全部用大寫字母來定義宏，這樣易於把程序紅的宏標識符和一般變數標識符區別開來。如果想要改變數組的大小，只需要更改宏定義並重新編譯程序即可。
宏表示的值可以是一個常量表達式，其中允許包括前面已經定義的宏標識符。例如：
#define
ONE
1
#define
TWO
2
#define
THREE
(ONE+TWO)
注意上面的宏定義使用了括弧。盡管它們並不是必須的。但出於謹慎考慮，還是應該加上括弧的。例如：
six=THREE*TWO;
預處理過程把上面的一行代碼轉換成：
six=(ONE+TWO)*TWO;
如果沒有那個括弧，就轉換成six=ONE+TWO*TWO;了。
宏還可以代表一個字元串常量，例如：
#define
VERSION
"Version
1.0
Copyright(c)
2003"
2.帶參數的#define指令
帶參數的宏和函數調用看起來有些相似。看一個例子：
#define
Cube(x)
(x)*(x)*(x)
可以時任何數字表達式甚至函數調用來代替參數x。這里再次提醒大家注意括弧的使用。宏展開後完全包含在一對括弧中，而且參數也包含在括弧中，這樣就保證了宏和參數的完整性。看一個用法：
int
num=8+2;
volume=Cube(num);
展開後為(8+2)*(8+2)*(8+2);
如果沒有那些括弧就變為8+2*8+2*8+2了。
下面的用法是不安全的：
volume=Cube(num++);
如果Cube是一個函數，上面的寫法是可以理解的。但是，因為Cube是一個宏，所以會產生副作用。這里的擦書不是簡單的表達式，它們將產生意想不到的結果。它們展開後是這樣的：
volume=(num++)*(num++)*(num++);
很顯然，結果是10*11*12,而不是10*10*10;
那麼怎樣安全的使用Cube宏呢？必須把可能產生副作用的操作移到宏調用的外面進行：
int
num=8+2;
volume=Cube(num);
num++;
3.#運算符
出現在宏定義中的#運算符把跟在其後的參數轉換成一個字元串。有時把這種用法的#稱為字元串化運算符。例如：
#define
PASTE(n)
"adhfkj"#n
main()
{
printf("%s\n",PASTE(15));
}
宏定義中的#運算符告訴預處理程序，把源代碼中任何傳遞給該宏的參數轉換成一個字元串。所以輸出應該是adhfkj15。
4.##運算符
##運算符用於把參數連接到一起。預處理程序把出現在##兩側的參數合並成一個符號。看下面的例子：
#define
NUM(a,b,c)
a##b##c
#define
STR(a,b,c)
a##b##c
main()
{
printf("%d\n",NUM(1,2,3));
printf("%s\n",STR("aa","bb","cc"));
}
最後程序的輸出為:
123
aabbcc
千萬別擔心，除非需要或者宏的用法恰好和手頭的工作相關，否則很少有程序員會知道##運算符。絕大多數程序員從來沒用過它。
三、條件編譯指令
條件編譯指令將決定那些代碼被編譯，而哪些是不被編譯的。可以根據表達式的值或者某個特定的宏是否被定義來確定編譯條件。
1.#if指令
#if指令檢測跟在製造另關鍵字後的常量表達式。如果表達式為真，則編譯後面的代碼，知道出現#else、#elif或#endif為止；否則就不編譯。
2.#endif指令
#endif用於終止#if預處理指令。
#define
DEBUG
0
main()
{
#if
DEBUG
printf("Debugging\n");
#endif
printf("Running\n");
}
由於程序定義DEBUG宏代表0，所以#if條件為假，不編譯後面的代碼直到#endif，所以程序直接輸出Running。
如果去掉#define語句，效果是一樣的。
3.#ifdef和#ifndef
#define
DEBUG
main()
{
#ifdef
DEBUG
printf("yes\n");
#endif
#ifndef
DEBUG
printf("no\n");
#endif
}
#if
defined等價於#ifdef;
#if
!defined等價於#ifndef
4.#else指令
#else指令用於某個#if指令之後，當前面的#if指令的條件不為真時，就編譯#else後面的代碼。#endif指令將中指上面的條件塊。
#define
DEBUG
main()
{
#ifdef
DEBUG
printf("Debugging\n");
#else
printf("Not
debugging\n");
#endif
printf("Running\n");
}
5.#elif指令
#elif預處理指令綜合了#else和#if指令的作用。
#define
TWO
main()
{
#ifdef
ONE
printf("1\n");
#elif
defined
TWO
printf("2\n");
#else
printf("3\n");
#endif
}
程序很好理解，最後輸出結果是2。
6.其他一些標准指令
#error指令將使編譯器顯示一條錯誤信息，然後停止編譯。
#line指令可以改變編譯器用來指出警告和錯誤信息的文件號和行號。
#pragma指令沒有正式的定義。編譯器可以自定義其用途。典型的用法是禁止或允許某些煩人的警告信息。

Ⅳ sizeof操作符可以用於 #if 預編譯指令中嗎

不可以，因為預編譯在編譯過程的早期進行, 此時尚未對類型名稱進行分析。作為替代, 可以考慮使用ANSI 的<limits.h> 中定義的常量, 或者使用「配置」(configure) 腳本。更好的辦法是, 書寫與類型大小無關的代碼。
操作符是指令系統的每一條指令都有一個操作符，它表示該指令應進行什麼性質的操作。不同的指令用操作符這個欄位的不同編碼來表示，每一種編碼代表一種指令。組成操作符欄位的位數一般取決於計算機指令系統的規模。
編譯(compilation , compile) 1、利用編譯程序從源語言編寫的源程序產生目標程序的過程。 2、用編譯程序產生目標程序的動作。 編譯就是把高級語言變成計算機可以識別的2進制語言，計算機只認識1和0，編譯程序把人們熟悉的語言換成2進制的。編譯程序把一個源程序翻譯成目標程序的工作過程分為五個階段：詞法分析；語法分析；語義檢查和中間代碼生成；代碼優化；目標代碼生成。主要是進行詞法分析和語法分析，又稱為源程序分析，分析過程中發現有語法錯誤，給出提示信息。

Ⅳ 什麼是預編譯，請舉例說明使用方法

主要是對代碼做編譯前的處理
主要處理#開始的預編譯指令
比如 #include #define指令 這種的 就是把包引入或者定義引入
也就是在編譯的時候，代碼已經沒有二義性、包含關系等這種麻煩了。

Ⅵ 預編譯命令都有哪些

一、預編譯命令具體什麼意思？
答：預編譯命令是由ANSI C統一規定的，但是它不是C語言的組成部分，不能直接對它們進行編譯。必須在對程序進行通常的編（包括詞法和語法分析，代碼生成，優化等）之前，先對程序中這些特殊的命令進行「預處理」，你慢慢悟，我小學生文化都看懂皮毛了，我不信你不知道它的意思。
二、#include <stdio.h>什麼意思？
答：把stdio.h這個文件包含進來，至於stdio.h是什麼，你自己慢慢看。

三、 void main()這個是什麼意思？？
答：加void 表示無類型，
我們知道main()是系統調用的，
那麼在main()前面加 void就保證系統不使用main()函數帶回的任何值。

Ⅶ 自定義C# 預編譯指令沒生效

不是配置管理器中設置的。在菜單《項目》-->《****屬性》中選擇《生成》標簽頁，在條件編譯符號中填寫『LocalDebug』

Ⅷ 什麼是預編譯，何時需要預編譯

預編譯又稱為預處理，是做些代碼文本的替換工作

預編譯又稱為預處理,是做些代碼文本的替換工作

處理#開頭的指令,比如拷貝#include包含的文件代碼，#define宏定義的替換,條件編譯等

就是為編譯做的預備工作的階段

主要處理#開始的預編譯指令

預編譯指令指示了在程序正式編譯前就由編譯器進行的操作，可以放在程序中的任何位置。常見的預編譯指令有：

(1)#include 指令

該指令指示編譯器將xxx.xxx文件的全部內容插入此處。若用<>括起文件則在系統的INCLUDE目錄中尋找文件，若用" "括起文件則在當前目錄中尋找文件。一般來說，該文件是後綴名為"h"或"cpp"的頭文件。

注意：<>不會在當前目錄下搜索頭文件，如果我們不用<>而用""把頭文件名擴起，其意義為在先在當前目錄下搜索頭文件，再在系統默認目錄下搜索。

(2)#define指令

該指令有三種用法:

第一種是定義標識，標識有效范圍為整個程序，形如#define XXX，常與#if配合使用；

第二種是定義常數，如#define max 100，則max代表100（這種情況下使用const定義常數更好，原因見注1）；

第三種是定義"函數"，如#define get_max(a, b) ((a)>(b)?(a):(b)) 則以後使用get_max(x,y)就可以得到x和y中較大的數（這種方法存在一些弊病，見注2）。

第四種是定義"宏函數"，如#define GEN_FUN(type) type max_##type(type a,type b){return a>b?a:b;} ，使用時，用GEN_FUN(int)，則此處預編譯後就變成了 max_int(int a,int b){return a>b?a:b;},以後就可以使用max_int(x,y)就可以得到x和y中較大的數.比第三種，增加了類型的說明。

(3)#if、#else和#endif指令

這些指令一般這樣配合使用：

#if defined(標識) //如果定義了標識

要執行的指令

#else

要執行的指令

#endif

在頭文件中為了避免重復調用(比如說兩個頭文件互相包含對方)，常採用這樣的結構：

#if !(defined XXX) //XXX為一個在你的程序中唯一的標識符，

//每個頭文件的標識符都不應相同。

//起標識符的常見方法是若頭文件名為"abc.h"

//則標識為"abc_h"

#define XXX

真正的內容，如函數聲明之類

#endif

Ⅸ 預編譯命令行由什麼符號開頭

#include "stdio.h"
#define P 3
void *F(int x)/*定義一個無類型函數，它有返回值，只是返回的值是指向無類型數據的指針*/

void main(){printf("%d\n",(int)F(1+3));/*將無類型函數F返回的指針值通過(int)強制轉換為int型*/

還有幾個問題，
1.預處理命令行必須位於源文件的開頭是對是錯？為什麼？
對！
編譯器在編譯源代碼時都是從開頭到結尾依次讀取，自己定義的變數、宏等等都得放前面，這樣在編譯器在讀到它們時就作一個記錄；
在使用這些變數、宏時，編譯器會在記錄中去尋找，如果找不到就會報錯——此變數未被定義。

函數可以放在結尾（main()之後），但是必須在開頭作一個函數聲明（也叫函數原型）以使編譯器為它作記錄，以便以後使用它時可以在記錄中找到它。
函數也可以放在前面（main()之前），此時就不用再聲明了，編譯器在讀到它時也會作一個記錄。

總之，自己定義的東西都得先聲明後使用，否則使用時在記錄中會找不到它。

預處理命令也是自己定義的東西，同屬這一范疇。

2.為什麼在源文件的一行上不能有多條預處理命令？
每條C語句都有一個「;」作結尾，即使都放一行，編譯器都能分辨得出。
預處理命令並不以「#」作為結尾標記，放一行的話編譯器是無法分辨的，它會把此行作為一個語句處理

通常的語句最好都分行寫，否則程序量大時是不便排錯的。

3.若有下列說明和定義
union dt
date;
變數data所佔內存位元組數與成員c所佔位元組數相同，為什麼？

聯合體的長度是其最長成員（如double c)的長度。
聯合體在內存中的存儲形式：
聯合體所有成員a,b,c都是同一地址，也就是說他們共同佔用這一段內存。
以TC3.0為例，a占這一段內存的頭2個位元組，b占這一段內存的頭一個位元組，c占這一段內存的全部位元組（也就是頭4個位元組）

4.為什麼以下不對
char *sp;*sp="right!";
char s[10];s="right!";
一、進行字元串賦值時可以在定義時：直接在字元串定義後接「="right"」
如：char *sp="right";
或者 char s[10]="right";

二、也可以在非定義時，這時左值必須是左值必須是字元串指針變數。
如：sp="right!";
以下都是錯誤用法：
*sp="right!";//左值不是字元串指針變數
s="right!";//左值只是字元串指針 常量

1、如果說*a包含（x和\0)，而*b包含（x和y），拿*a-*b會得出什麼結果,*a和*b都是char型變數的話

最終的表達式*a-*b中，a points to '\0',b points to 'y',so 表達式*a-*b代表的是'\0'-'y',結果是-121（y的ASCII是121）

point(char*p)
main()
{
char b[4]={'a','b','c','d'),*p=b;
point(p); printf("%c\n",*p);
}
A.a B.b C.c D.d
選哪個？為什麼？

選D，p最初是首地址b，然後p是b+3,此時*p相當*(b+3)、b[3].

2號問題：
main()
,,,},i,j;
for(i=0;i<4;i++)
{for (j=0;j<i,j++)
printf("%4c",' ');/*原題就是'和'之間只有個空格,我也不清楚是怎麼回事*/
for(j=__;j<4;j++)
printf(%4d",num[i][j]);
printf("\n");
}
}
printf("%4c",' '); 其中的' '其實是一個空格字元常量，這個同'a','b','c'等字元常量是一樣的。
這個語句中%4c是指要讀取一個字元（這個字元就是後面的空格字元常量' '）並輸出，這個字元在顯示器上應該佔4格。所以此句的功能是輸出4個空格（空格也是屬於字元）。
你改成printf("%4c",'a');printf("%4c",'b');試下，它是輸出3個空格和一個字元。
printf("%8c",' ');是輸出8個空格，這個比printf(" ");來實現輸出8個字元來得方便。

若要按下列形式輸出數組右上半三角（什麼玩意？）。
1 2 3 4 i=0,j=i,那麼j可以是0,1,2,3
6 7 8 i=1,j=i,那麼j可以是1,2,3
11 12 i=2,j=i,那麼j可以是2,3
16 i=3,j=i,那麼j可以是3
則下劃線處應填入的是?為什麼？（B）
A.i-1 B.i
C.i+1 D.4-i

3號問題：
程序中若有下列說明和定義語句：
char fun(char*);
main()
{
char *s="one",a[5]=,(*fl)()=fun,ch;
......
}
下列選項中對函數的正確調用語句是？為什麼？
A.(*fl)(a);
B.*fl(*s);
C.fun(&a);
D.ch=*fl( s);

選擇A，根據定義char fun(char*)，形參必須是一個字元指針，"a","s"才是字元指針(char pointer)，而"*s" is char variable,"&a" is invalid.所以排除B、C

只有fun、*fl才是函數入口地址.
B.*fl(*s);相當於*(fl(*s)),錯誤，指針運算符只能針對指針運算，fl(*s)得到的是int，不是指針，下同。故排除B、D.
D.*fl( s);相當於*(fl( s));

4號問題
#define S(x) 4*x*x+1
main()
{
int i=6,j=8;
printf("%d",S(i+j));
getchar();
}
這個函數的輸出結果是多少？怎麼得的？

得到81.
因為S(i+j)經過預編譯用i+j替換x後,它被展開為4*i+j*i+j+1。即（4*6+8*6+8+1）
你應該這樣改：
#define S(x) 4*(x)*(x)+1
或者 printf("%d",S((i+j)));即將i+j用括弧括起來(i+j),這樣就在替換時用(i+j)替換x