C++預處理:常用預處理,預處理的由來,預處理功能,預處理指令,

C++的預處理（Preprocess），是指在C++程式原始碼被編譯之前，由預處理器（Preprocessor）對C++程式原始碼進行的處理。這個過程並不對程式的原始碼進行解析，但它把原始碼分割或處理成為特定的符號用來支持宏調用。

基本介紹

中文名：C++預處理
外文名：Preprocess
包含頭檔案：#include
否則：#else
條件：#if

常用預處理,預處理的由來,預處理功能,預處理指令,

常用預處理

1)常用的預處理：

#include 包含頭檔案

#if 條件

#else 否則

#elif 否則如果

#endif 結束條件

#ifdef 或 #if defined 如果定義了一個符號, 就執行操作

#ifndef 或 #if !defined 如果沒有定義一個符號，就指執行操作

#define 定義一個符號

#undef 刪除一個符號

#line 重新定義當前行號和檔案名稱

#error 輸出編譯錯誤訊息,　停止編譯

#pragma 提供機器專用的特性,同時保證與C++的完全兼容

2)#include　在程式中包含頭檔案

頭檔案通常以.h結尾,其內容可使用#include預處理器指令包含到程式中

頭檔案中一般包含: 函式原型與全局變數

形式常有下面兩種

#include <iostream>

#include "myheader.h"

前者<>用來引用標準庫頭檔案,後者""常用來引用自定義的頭檔案

前者<>編譯器只搜尋包含標準庫頭檔案的默認目錄,後者首先搜尋正在編譯的源檔案所在的目錄,找不到時再搜尋包含標準庫頭檔案的默認目錄.

如果把頭檔案放在其他目錄下,為了查找到它,必須在雙引號中指定從源檔案到頭檔案的完整路徑

3)#define 定義符號、宏

1>符號

#define PI 3.1415925 //定義符號PI為3.1415925

#undef PI　//取消PI的值

這裡PI看起來像一個變數，但它與變數沒有任何關係，它只是一個符號或標誌，在程式代碼編譯前，此符號會用一組指定的字元來代替

3.14159265　不是一個數值，只是一個字元串，不會進行檢查

在編譯前，預處理器會遍歷代碼，在它認為置換有意義的地方，用字元串PI的定義值(3.14159265)來代替

在注釋或字元串中的PI不進行替換

在C中常以#define來定義符號常量，但在C++中最好使用const 來定義常量

#define PI 3.14159265

const long double PI=3.14159265;

兩者比較下，前者沒有類型的指定容易引起不必須的麻煩，而後者定義清楚，所以在C++中推薦使用const來定義常量

#define的缺點:

1)不支持類型檢查

2)不考慮作用域

3)符號名不能限制在一個命名空間中

2>#undef 刪除#define定義的符號

#define PI 3.14159265

... //之間所有的PI都可以被替換為3.14159265

#undef PI

之後不再有PI這個標識符

3>定義宏

#define Print(Var) count<<(Var)<<endl

用宏名中的參數帶入語句中的參數

宏後面沒有;號

Print(Var)中的Print和(之間不能有空格，否則(就會被解釋為置換字元串的一部分

#define Print(Var, digits) cout << setw(digits) << (Var) << endl

調用

Print(ival, 15)

預處理器就會把它換成

cout << setw(15) << (ival) << endl;

所有的情況下都可以使用內聯函式來代替宏，這樣可以增強類型的檢查

template<class T> inline void Print (const T& var, const int& digits)

{

cout<<setw(digits)<<var<<endl;

}

調用

Print(ival, 15);

使用宏時應注意的易引起的錯誤:

#define max(x,y) x>y?x:y;

調用 result = max(myval, 99); 則換成 result = myval>99?myval:99; 這個沒有問題是正確的

調用 result = max(myval++, 99); 則換成 result = myval++>99?myval++:99; 這樣如果myval>99那么myval就會遞增兩次，這種情況下()是沒什麼用的如result=max((x),y)則 result = (myval++)>99?(myval++):99;

再如

#define product(m,n) m*n

調用

result = product(5+1,6);則替換為result = 5+1*6; 所以產生了錯誤的結果，此時應使用()把參數括起

#define product(m,n) (m)*(n)

則result = product(5+1,6);則替換為result = (5+1)*(6); 所以產生了錯誤的結果，此時應使用()把參數括起

結論:　一般用內聯函式來代替預處理器宏

技巧:

1)給替換變數加引號

#define MYSTR "I love you"

cout << MYSTR ; //I love you而不是"I love you"

如果

cout << "MYSTR" ; //則會輸出"MYSTR"而不是"I love you"

可以這樣做

cout << #MYSTR ; //則會輸出 "I love you"即cout << "\"I love you\"";

2)在宏表達式中連線幾個參數

如

#define join(a,b) ab　這樣不會理解為參數a的值與參數b的值的連線，即如join(10,999)不會理解為10999而是把ab理解為字元串，即輸出ab

這時可以

#define join(a,b) a##b

則join(10,999)就會輸出10999

3)邏輯預處理器指令

#if defined CALCAVERAGE　或 #ifdef CALCAVERAGE

int count=sizeof(data)/sizeof(data[0]);

for(int i=0; i<count; i++)

average += data;

average /= count;

#endif

如果已經定義符號CALCAVERAGE則把#if與#endif間的語句放在要編譯的原始碼內

防止重複引入某些頭檔案

#ifndef COMPARE_H

#define COMPARE_H 注意: 這裡只是定義一個沒有值的符號COMPARE_H, 下面的namespace compare不是COMPARE_H的內容，這裡的定義不像是定義一個常量或宏，僅僅定義一個符號，指出此符號已定義，則就會有下面的內容namespace compare{...

namespace compare{

double max(const double* data, int size);

double min(const double* data, int size);

}

#endif

比較

#define VERSION \

因為有換行符\　所以上句等價於 #define VERSION 3

由此可以看出#define COMPARE_H與namespace compare是獨立沒有關係的兩個行

也可以這樣用

#if defined block1 && defined block2

...

#endif

#if CPU==PENTIUM4

...

#endif

#if LANGUAGE == ENGLISH

#define Greeting "Good Morning."

#elif LANGUAGE == GERMAN

#define Greeting "Guten Tag."

#elif LANGUAGE == FRENCH

#define Greeting "Bonjour."

#else

#define Greeting "Hi."

#endif

std::cout<<Greeting << std::endl;

#if VERSION == 3

...

#elif VERSION == 4

...

#else

...

#endif

5)標準的預處理器宏

__LINE__ 當前源檔案中的代碼行號，十進制整數

__FILE__　源檔案的名稱，字元串字面量

__DATE__　源檔案的處理日期，字元串字面量，格式mmm dd yyyy其中mmm是月份如Jan、Feb等　dd是01-31 yyyy是四位的年份

__TIME__ 源檔案的編譯時間，也是字元串字面量格式是hh:mm:ss

__STDC__ 這取決於實現方式，如果編譯器選項設定為編譯標準的C代碼，通常就定義它，否則就不定義它

__cplusplus 在編譯C++ 程式時，它就定義為199711L

使用#line可以修改__FILE__返回的字元串

如

#line 1000 把當前行號設定為1000

#line 1000 "the program file" 修改__FILE__返回的字元串列號改為了1000，檔案名稱改為了"the program file"

#line __LINE__ "the program file" 修改__FILE__返回的字元串列號沒變，檔案名稱改為了"the program file"

cout << "program last complied at "<<__TIME__

<< " on " << __DATE__

<< endl;

6)#error

在預處理階段，如果出現了錯誤，則#error指令可以生成一個診斷訊息，並顯示為一個編譯錯誤，同時中止編譯

#ifndef __cplusplus

#error "Error - Should be C++"

#endif

7)#pragma

專門用於實現預先定義好的選項，其結果在編譯器說明文檔中進行了詳細的解釋。編譯器未識別出來的#pragma指令都會被忽略

8)assert()宏

在標準庫頭檔案<cassert>中聲明

用於在程式中測試一個邏輯表達式，如果邏輯表達式為false, 則assert()會終止程式，並顯示診斷訊息

用於在條件不滿足就會出現重大錯誤，所以應確保後面的語句不應再繼續執行，所以它的套用非常靈活

注意: assert不是錯誤處理機制，邏輯表達式的結果不應產生負面效果，也不應超出程式設計師的控制(如找開一個檔案是否成功), 程式應提供適當的代碼來處理這種情況

assert(expression);

assert(expression) && assert(expression2);

可以使用#define NDEBUG來關閉斷言機制

#include <iostream>

#include <cassert>

using std::cout;

using std::endl;

int main()

{

int x=0;

int y=0;

cout<<endl;

for(x=0; x<20; x++)

{

cout<<"x= "<<x <<" y= "<<y<<endl;

assert(x<y);　//當x>=y與x==y時，就報錯，並終止程式的執行

}

return 0;

}

預處理的由來

在C++的歷史發展中，有很多的語言特徵（特別是語言的晦澀之處）來自於C語言，預

處理就是其中的一個。C++從C語言那裡把C語言預處理器繼承過來（C語言預處理器，被Bj

arne博士簡稱為Cpp，不知道是不是C Program Preprocessor的簡稱）。

預處理功能

預處理器的主要作用就是把通過預處理的內建功能對一個資源進行等價替換，最常見

的預處理有：檔案包含，條件編譯、布局控制和宏替換4種。

檔案包含：#include 是一種最為常見的預處理，主要是做為檔案的引用組合源程式正

文。

條件編譯：#if,#ifndef,#ifdef,#endif,#undef等也是比較常見的預處理，主要是進

行編譯時進行有選擇的挑選，注釋掉一些指定的代碼，以達到版本控制、防止對檔案重複

包含的功能。

布局控制：#pragma，這也是我們套用預處理的一個重要方面，主要功能是為編譯程式

提供非常規的控制流信息。

宏替換： #define，這是最常見的用法，它可以定義符號常量、函式功能、重新命名

、字元串的拼接等各種功能。

預處理指令

預處理指令的格式如下：

# directive tokens

#符號應該是這一行的第一個非空字元，一般我們把它放在起始位置。如果指令一行放

不下，可以通過\進行控制，例如：

#define Error if(error) exit(1) 等價於

#define Error \

if(error) exit(1)

不過我們為了美化起見，一般都不怎么這么用，更常見的方式如下：

# ifdef __BORLANDC__

if_true<(is_convertible<Value,named_template_param_base>::value)>:

template then<make_named_arg, make_key_value>::type Make;

# else

enum { is_named = is_named_parameter<Value>::value };

typedef typename if_true<(is_named)>::template

then<make_named_arg, make_key_value>::type Make;

# endif

下面我們看一下常見的預處理指令：

#define 宏定義

#undef 未定義宏

#include 文本包含

#ifdef 如果宏被定義就進行編譯

#ifndef 如果宏未被定義就進行編譯

#endif 結束編譯塊的控制

#if 表達式非零就對代碼進行編譯

#else 作為其他預處理的剩餘選項進行編譯

#elif 這是一種#else和#if的組合選項

#line 改變當前的行數和檔案名稱稱

#error 輸出一個錯誤信息

#pragma 為編譯程式提供非常規的控制流信息

下面我們對這些預處理進行一一的說明，考慮到宏的重要性和繁瑣性，我們把它放到

最後講。

四、檔案包含指令：

這種預處理使用方式是最為常見的，平時我們編寫程式都會用到，最常見的用法是：

#include <iostream> //標準庫頭檔案

#include <iostream.h> //舊式的標準庫頭檔案

#include "IO.h" //用戶自定義的頭檔案

#include "../file.h" //UNIX下的父目錄下的頭檔案

#include "/usr/local/file.h" //UNIX下的完整路徑

#include "..\file.h" //Dos下的父目錄下的頭檔案

#include "\usr\local\file.h" //Dos下的完整路徑

這裡面有2個地方要注意：

1、我們用<iostream>還是<iostream.h>?

我們主張使用<iostream>，而不是<iostream.h>,為什麼呢？我想你可能還記得我

曾經給出過幾點理由，這裡我大致的說一下：

首先，.h格式的頭檔案早在98年9月份就被標準委員會拋棄了，我們應該緊跟標準

，以適合時代的發展。

其次，iostream.h只支持窄字元集，iostream則支持窄/寬字元集。

還有，標準對iostream作了很多的改動，接口和實現都有了變化。

最後，iostream組件全部放入namespace std中，防止了名字污染。

2、<io.h>和"io.h"的區別？

其實他們唯一的區別就是搜尋路徑不同：

對於#include <io.h> ，編譯器從標準庫路徑開始搜尋

對於#include "io.h" ，編譯器從用戶的工作路徑開始搜尋

五、編譯控制指令：

這些指令的主要目的是進行編譯時進行有選擇的挑選，注釋掉一些指定的代碼，以達

到版本控制、防止對檔案重複包含的功能。

使用格式，如下：

1、

#ifdef identifier

your code

#endif

如果identifier為一個定義了的符號，your code就會被編譯，否則剔除

2、

#ifndef identifier

your code

#endif

如果identifier為一個未定義的符號，your code就會被編譯，否則剔除

3、

#if expression

your code

#endif

如果expression非零，your code就會被編譯，否則剔除

4、

#ifdef identifier

your code1

#else

your code2

#endif

如果identifier為一個定義了的符號，your code1就會被編譯，否則your code2就

會被編譯

5、

#if expressin1

your code1

#elif expression2

your code2

#else

your code3

#enif

如果epression1非零，就編譯your code1，否則，如果expression2非零，就編譯y

our code2，否則，就編譯your code3

C++預處理

基本介紹

常用預處理

預處理的由來

預處理功能

預處理指令

相關詞條

熱門詞條