c++語言程序設(shè)計超級簡單了解

信息來源：邪惡八進(jìn)制信息安全團隊（[url]www.eviloctal.com[/url]）
文章作者：金州

c++語言程序設(shè)計超級簡單了解


千里之行，始于足下。

這是非常非常非常表面的介紹，是為一點都不知道的朋友寫著玩的。也許你看過之后什么都沒有
收獲到，一直罵作者是個sb.那么我請您原諒耽誤了您的時間，先表示抱歉了。呵呵

一。結(jié)構(gòu)程序設(shè)計方法，要點。.三種基本控制結(jié)構(gòu)。順序，循環(huán)，選擇
選擇結(jié)構(gòu)，兩種。if switch
if形式1.if   2. if else 3. if else if else if
switch(多分支選擇，金州注釋)
switch
{case 常量表達(dá)式1 ：語句1
case 常量表達(dá)式n ：語句n
default:語句n+1
}
循環(huán)，while(沒有什么解釋的，先判斷，后執(zhí)行，金州注釋)
例子，求1到100整數(shù)和
#include <iostream.h>   （套入函數(shù)，金州注釋）
　void main()         （下面主體，金州注釋）
　{                
　　int i, sum = 0;     （定義i，賦予數(shù)值1，總和開始為0，金州注釋）
　　i = 1;
　　while(i <= 100) （循環(huán)下面部分，當(dāng)i<100，判斷條件，金州注釋）
　　{
　　　sum += i;   （加，一直加，金州注釋）
　　　i++;
　　}         （循環(huán)結(jié)束，金州注釋）
　　cout<<"sum = "<<sum;   （搞出來結(jié)果，字符串sum=那個結(jié)果。金州注釋）
　}
do-while 循環(huán)（先執(zhí)行，后判斷）
例子，還舉上面那個，就是求1到100整數(shù)和
＃include <iostream.h>
　void main()
　{
　　int i, sum=0;     （定義賦值。金州注釋）
　　i = 1;
　　do             （下面是循環(huán)，金州注釋）
　　{
　　　sum += i;
　　　i++;
　　}while(i<=100);   （條件，如果條件滿足就循環(huán)，金州注釋）
　　cout<<"sum = "<<i;
　}
for循環(huán)，
例子，還是上面那個，求1到100整數(shù)和
＃include <iostream.h>
　void main()
　{
　　for(sum = 0, i = 1; i <= 100; i++)sum += i;
　　cout<<"sum = "<<sum;
　}
（就是1-2-3-2-3-2-3(1指的是表達(dá)式)，如果2不滿足，結(jié)束。金州注釋）

二，語言基礎(chǔ)：
看例子比較方便了解，
//simple.cpp是一個簡單的C++程序 （標(biāo)準(zhǔn)注釋方法，不執(zhí)行，我沒有用這種注釋，金州注釋）
#include <iostream.h> （一個文件頭，金州注釋）
void main(void)   （函數(shù)，金州注釋）
{             （main函數(shù)體開始標(biāo)記，金州注釋）
int i;         （聲明一個變量，金州注釋）
cout<<"jinzhou sb!";       （輸出，后面的東西，金州注釋）
cout<<"請輸入一個整數(shù)：\n"; （\n是換行的意思，<<輸出符號，金州注釋）
cin>>i;               （輸入，后面的東西。金州注釋）
cout<<"輸入的整數(shù)是：";  
cout <<i;
cout <<‘\n‘;   （上三行簡寫：cout<<"您輸入的整數(shù)是：" <<i <<‘\n‘;）
}           （主體結(jié)束，金州注釋）
（Visual C++6編譯連接運行后，就是屏幕上出現(xiàn)“jinzhou sb!請輸入一個整數(shù)”
然后你隨便輸入一個，回車，得到“輸入的整數(shù)是：”，就是你輸入的那個，大
概明白是這么個格式就行了。注意一點的就是，函數(shù)定義返回類型為void,不用返回
，如果定義為int,則不同。如下。金州注釋。）
int main()
{
　…
　return 0;
}
（還有就是c++區(qū)分大小寫，一般命令小寫多，常量大寫多。變量混用多。金州注釋）
數(shù)據(jù)類型略過。大多類似的。
變量使用舉一個簡單的例子。
#include <iostream.h>
int main (void)  
{
int workDays = 5;     （定義一個整型變量，初始化為5，金州注釋）
float workHours, payRate, weeklyPay;   （實型變量三個，金州注釋）
workHours = 7.5; payRate = 38.55;   （賦值，金州注釋）
weeklyPay = workDays * workHours * payRate; （乘法運算，金州注釋）
cout << "Weekly Pay = " << weeklyPay << ‘\n‘; （輸出換行，金州注釋）
}

就是計算工資呢。
例子，打印給定半徑的圓的面積和周長（有常量定義的實例程序）
void main()
{
　const double PI = 3.1415926535898;   （定義圓周率常量PI，金州注釋）
　double radius;   （定義圓半徑變量，金州注釋）
　double area;   （定義圓面積變量，金州注釋）
　double circumference;   （定義圓周長變量，金州注釋，）
　cout << "輸入半徑 : ";   （輸出，屏幕顯示，金州注釋）
　cin >> radius;       （輸入，金州注釋）
　area = PI*radius*radius; （面積公式，金州注釋）
　circumference = 2.0*PI*radius;   （周長共識，金州注釋）
　cout << "面積 " << radius << " is "
　<< area << " \n";
　cout << "周長是 " << circumference   （輸出到屏幕，金州注釋）
<< ";
}
（注意定義常量的形式為 const 類型 名字 = 值。）


三，運算符和表達(dá)式
要注意的是：
+ + 自加(前綴) ++valuel + 10 // 得出16，valuel變?yōu)?
+ + 自加(后綴) valuel++ + 10 // 得出15，valuel變?yōu)?
- - 自減(前綴) --valuel + 10 // 得出14，valuel變?yōu)?
- - 自減(后綴) valuel-- + 10 // 得出15，valuel變?yōu)?
（其實質(zhì)就是用‘++‘代替了"+1"(后綴)和"1+"（前綴）、‘-‘代替了"-1"。金州注釋）

!   邏輯非   !(5 = = 5) // 得出 0     （0是假，1是真，金州注釋）
&&   邏輯與   5 < 6 && 6 < 6 // 得出 0
||   邏輯或   5 < 6 || 6 < 5 // 得出 1
~   取反 ~‘\011‘ // 得出 ‘\366‘
&   逐位與 ‘\011‘ & ‘\027‘ // 得出‘\001‘
|   逐位或 ‘\011‘ | ‘\027‘ // 得出‘\037‘
^   逐位異或 ‘\011‘ ^ ‘\027‘ // 得出‘\036‘
<< 逐位左移 ‘\011‘ << 2 // 得出‘\044‘
>> 逐位右移 ‘\011‘ >> 2 // 得出‘\002‘
實例 10進(jìn)制值 二進(jìn)制值
x   011     0 0 0 0 1 0 0 1
y   027     0 0 0 1 0 1 1 1
~x   366     1 1 1 1 0 1 1 0
x & y 001     0 0 0 0 0 0 0 1
x | y 037     0 0 0 1 1 1 1 1
x ^ y 036     0 0 0 1 1 1 1 0
x << 2 044   0 0 1 0 0 1 0 0
x >> 2 002   0 0 0 0 0 0 1 0
運算例子，
#include <iostream.h>
void main( )
{
　int a,b, m=3,n=4;
　a=7*2+-3%5-4/3;//-3%5=-3，4/3=1
　b=m++ - --n;
　cout<<a<<"\t"<<b<<"\t"<<m<<"\t"<<n<<endl;
}
結(jié)果10 0 4 3
例子
#include <iostream.h>
void main( )
{
　char x=‘m‘,y=‘n‘;
　int n;
　n=x<y;
　cout <<n<<endl;
　n=x==y-1;
　cout<<n<<endl;
　n=(‘y‘!=‘Y‘)+(5<3)+(y-x==1);
　cout <<n<<endl;
}
結(jié)果 1 1 2

四，流程控制語句。
if語句；if-else語句；switch語句；while語句；do-while語句；for語句；break語句；continue語句
（都是簡單英語，沒有什么解釋的，哈哈，金州注釋）
五，函數(shù)。
這個解釋多多網(wǎng)上。
舉例子；求長方形面積。
#include<iostream.h>   （C++庫函數(shù)說明，金州注釋）
int area(int length, int width);   （ area函數(shù)說明，定義長寬,金州注釋）
void main()     （主函數(shù)，程序從該函數(shù)開始執(zhí)行，金州注釋）
{
　int this_length, this_width;   （定義長寬，金州注釋）
　cout << "輸入長度: "; （cout和cin，就是函數(shù)，輸出后面字符串。金州注釋）
　cin >> this_length;   （輸入，金州注釋）
　cout << "輸入寬度: ";   （輸出那句話到屏幕，金州注釋）
　cin >> this_width;
　cout << "\n";         （回車，金州注釋）
　cout << "面積 " << this_length << "x" << this_width;
　cout << " 長方形面積是 " << area(this_length, this_width); （調(diào)用area函數(shù)，金州注釋）
}
int area(int length, int width) （area函數(shù)定義，金州注釋）
{
　int number;
　number = length * width;
　return number;
}
例子，比較大小的。
#include <iostream.h>
int max(int a,int b) （調(diào)用這個函數(shù)，金州注釋）
{
　if(a>b)return a; （如果則怎么怎么的，金州注釋）
　else return b;
}           （以上是定義max函數(shù)的，金州注釋）
void main()
{
　int max(int a,int b);
　int x,y,z;
　cout<<"輸入兩個數(shù)"<<endl; （屏幕顯示，回車輸入）
　cin>>x>>y;
　z=max(x,y);             （z為比較結(jié)果，金州注釋）
　cout<<"最大的數(shù)="<<z;     （輸出，金州注釋）
}
例子

#include <iostream.h>
void Foo (int num)
{
　num = 0;
　cout << "num = " << num << ‘\n‘;
}
int main (void)
{
　int x = 10;
　Foo(x);
　cout << "x = " << x << ‘\n‘;
　return 0;
}
（這個更簡單，不多說，主要是明白num是一個形參變量num，x是實參變量，實參調(diào)用時
送到形參，但是因為內(nèi)存單元不同，即使num賦值0，并不影響x的值，道理大概理解了
就好，金州注釋）
（不多解釋了，相關(guān)詳細(xì)內(nèi)容，要找資料好好揣摩，這里只是簡單說一下，金州注釋）

六，數(shù)組與字符串。
#include <iostream.h>
void main(void)
{
　int marks[4] = {82,92,95,88}; （這個就是數(shù)組，就是這個格式，金州注釋）
　cout<<"第二個元素是:"<<marks[1]<<endl; （四個數(shù)排序是0123，所以1是第二個元素，金州注釋）
}
（這就是定義數(shù)組了，找第二個元素的。92。金州注釋）
例子，求字符串的長度 （這個是字符串的，金州注釋。）
#define MAXLEN 80
#include <stdio.h>
void main(void)
{
　char str[MAXLEN + 1];   （最長加1，因為是從0計算的，金州注釋）
　int l;           （定義長度，這個符號可不是1啊，金州注釋）
　printf("Input a string:"); （輸出，告訴你開始輸入，金州注釋）
　scanf("%s",str);       （檢查你輸入的，如果空，金州注釋）
　l = 0;             （長度0，金州注釋）
　while(str[l] != ‘\0‘) （非空，金州注釋）
　l ++;             （加加，數(shù)出來，金州注釋）
　printf("The length of this string is %d\n",l); （輸出結(jié)果回車，金州注釋）
}

七，指針與引用
指針就是在內(nèi)存中的地址，它可能是變量的地址，也可能是函數(shù)的入口地址。
引用為變量提供了一個別名，變量通過引用訪問與通過變量名訪問是完全等價的。
引用提供了與指針相同的能力，但比指針更為直觀，更易于理解。
int d =1;
int* const p =&d
（有const表示不可修改，p是一個常量指針，它指向一個整型變量。就是d,p本
身不能修改，但它所指向的內(nèi)容卻可以修改：*p =2；這個不大好說，請查閱相
嚴(yán)謹(jǐn)詳細(xì)資料。關(guān)金州注釋。）
例如：
#include <iostream.h>
#define SIZE 10  
void main()
{
　int array[SIZE]; （聲明整數(shù)數(shù)組，金州注釋）
　int *p=array;     （定義一個整型指針p，給他數(shù)組首地址，金州注釋）
　int i ;         （定義變量i,金州注釋）
　for(i=0;i<SIZE;i++)   （賦值，運算，金州注釋）
　　array[i]=i;
　for(i=0;i<SIZE;i++)
　　cout<<*p++<<endl;   （*p++就是訪問下一個數(shù)組元素，金州注釋）
　p=&array[8];     （給他array[8]的地址，金州注釋）
　cout<<"array[8]="<<*p<<endl;     （輸出*p，金州注釋）
　cout<<"array[8]="<<array[8]<<endl; （輸出array[8]，金州注釋）
}  
（兩個值是一樣的，因為從0開始，所以都是對數(shù)組第9個元素的訪問。金州注釋）
例子：折半查找函數(shù)
int BinSearch (char *item, char *table[],     （就是在table中查找是否含有item的元素）
int n, int (*Compare)(const char*, const char*))   Compare是一個比較函數(shù)指針，金州注釋）
{
　int bot = 0;     （底部0，金州注釋）
　int top = n - 1;   （頂部n-1，金州注釋）
　int mid, cmp;   （定義比較變量，比較，金州注釋）
while (bot <= top) （比較當(dāng)然需要循環(huán)，循環(huán)條件，意思就是不空，金州注釋）
　{           （以下循環(huán)內(nèi)容）
mid = (bot + top) / 2;   （mid等于，全部除以2，就是一半，金州注釋）
if ((cmp = Compare(item,table[mid])) == 0) （如果恰好相等，金州注釋）
　return mid;   （ 就是它，金州注釋）
　else if (cmp < 0) （不相等，金州注釋）
　　　　top = mid - 1; （ 查找數(shù)組的下半部，金州注釋）
　　　else
　　　 bot = mid + 1;   （ 查找數(shù)組的上半部，金州注釋）
　}
return -1; （上面循環(huán)之后，返回-1,沒有找到，因為n就是0了。金州注釋）
}

例如。
char *cities[] = {"Beijing", "Shanghai", "Tianjin", "Zhongqing"};
cout << BinSearch("Tianjin ", cities, 4, strcmp) << ‘\n‘
輸出結(jié)果2
（就是，給出一個數(shù)組，找找“Tianjin”在四個中的位置，2就是在第三個位置。）

八。結(jié)構(gòu) 鏈表
結(jié)構(gòu)（struct）數(shù)據(jù)類型，它能夠識別一組相關(guān)的數(shù)據(jù)。
鏈表也是表示線性數(shù)據(jù)最有用的方法之一，用鏈表保存線性數(shù)據(jù)，可以克服數(shù)組的問題
舉例
#include <iostream.h>
#include <string.h>
struct Person_Info {   （個人信息表，下面是相關(guān)內(nèi)容。金州注釋）
　char name[10];
　int age;
　long ssn;
};
void main (void)
{
　Person_Info* p1;     （給個指針，金州注釋）
　p1 = new Person_Info;   (申請內(nèi)存,金州注釋）
　p1->age = 27; （ 給age成員賦值，金州注釋）
　strcpy(p1->name,"jinzhou"); （給name成員賦值 ，金州注釋)
　cout << "Name: " << p1->name << endl; ( 打印name成員,金州注釋）
　cout << "Age: " << p1->age << endl; （打印age成員，金州注釋）
　delete p1;                 （釋放申請的內(nèi)存，金州注釋）
}
簡單例子學(xué)生結(jié)構(gòu)的實例
struct stu
　　{
　　　int num;
　　　int score;
　　　stu *next;
　　}
（明白這個意思就行了，金州注釋）

九，編譯預(yù)處理
C++提供的編譯預(yù)處理功能主要有以下三種：（一） 宏定義（二） 文件包含（三） 條件編譯
宏定義例子;
#include <iostream.h>， (一定要有，或者出錯，金州注釋)
#define CUBE_THREE 3*3* （用簡單宏定義定義了一個符號常量"CUBE_THREE"）
void main()
{
　int a;           （定義變量，金州注釋）
　a=CUBE_THREE;     （賦予值，就是a=3*3*3，金州注釋）
　cout<<"a is"<<a<<endl;   （輸出，結(jié)果為27，金州注釋）
}
（這個意思主要是說可以把常用的東西定義為宏。這個不帶參數(shù)，帶參數(shù)的略。金州注釋）
文件包含類的略。
例子：條件編譯命令的一個例子
#include <iostream.h>
#define TIME
void main()
{
　#ifdef TIME             （如果TIME被定義過，輸出下面句話。金州注釋）
　　cout<<"Now begin to work"<<endl;
　#else               （如果沒有定義，輸出下面的，金州注釋）
　　cout<<"You can have a rest"<<endl;
　#endif
}
（所謂條件，就是有條件的，金州注釋。就是要選擇。哈哈）

十。類與對象
略過，請找尋相關(guān)詳細(xì)資料閱讀，不好意思。

十一，繼承與多態(tài)。（略過）
十二，輸入輸出流。
抽象流基類
ios 　　　　　　　　流基類
輸入流類
istream 　　　　　　普通輸入流類和用于其它輸入流的基類
ifstream　　　　　　輸入文件流類
istream_withassign　用于cin的輸入流類
istrstream　　　　　輸入串流類
輸出流類
ostream　　　　　　普通輸出流類和用于其它輸出流類的基類
ofstream 　　　　　輸出文件流類
ostream_withassign 用于cout、cerr和clog的流類
ostrstream.　　　　輸出串流類
輸入輸出流類
iostream 　　　　　普通輸入輸出流類和用于其它輸入輸出流的基類
fstream　　　　　　輸入輸出文件流類
strstream　　　　　輸入輸出串流類
stdiostream　　　　用于標(biāo)準(zhǔn)輸入輸出文件的輸入輸出類
緩沖流類
streambuf　　　　　抽象緩沖流基類
filebuf　　　　　　用于磁盤文件的緩沖流類
strstreambuf.　　　用于串的緩沖流類
stdiobuf 　　　　　用于標(biāo)準(zhǔn)輸入輸出文件的緩沖流類
預(yù)定義流初始化類
iostream_init　　　預(yù)定義流初始化的類
其中，ios、istream、ostream和streambuf類構(gòu)成了C++中iostream輸入輸出功能的基礎(chǔ)
（略）

  如果你真的捏著鼻子再捏著鼻子讀完的話，也許和我一樣覺得算是了解了c++九牛一毛了，
其實后來才發(fā)現(xiàn)不過是才知道牛是有毛的而已。到現(xiàn)在我也沒有抓住牛頭，據(jù)說編程需要天才，
我沒有哪個天分，哈哈，只是希望有朋友看到之后能夠有一個很大概地了解。不好意思。不過大家可
以常常到邪惡八進(jìn)制來看看，這里有很多這方面的超級高手，至少算是看看天才的樣子，哈哈
祝福！
                              金州。邪惡八進(jìn)制
                                  2005.12.17

定義常量也可以使用define、inline去實現(xiàn)

我建議大家用const和inline而不用#define

這個條款最好稱為：“盡量用編譯器而不用預(yù)處理”，因為#define經(jīng)常被認(rèn)為好象不是語言本身的一部分。這是問題之一。再看下面的語句：

#define ASPECT_RATIO 1.653

編譯器會永遠(yuǎn)也看不到ASPECT_RATIO這個符號名，因為在源碼進(jìn)入編譯器之前，它會被預(yù)處理程序去掉，于是ASPECT_RATIO不會加入到符號列表中。如果涉及到這個常量的代碼在編譯時報錯，就會很令人費解，因為報錯信息指的是1.653，而不是ASPECT_RATIO。如果ASPECT_RATIO不是在你自己寫的頭文件中定義的，你就會奇怪1.653是從哪里來的，甚至?xí)〞r間跟蹤下去。這個問題也會出現(xiàn)在符號調(diào)試器中，因為同樣地，你所寫的符號名不會出現(xiàn)在符號列表中。
解決這個問題的方案很簡單：不用預(yù)處理宏，定義一個常量：

const double ASPECT_RATIO = 1.653;

這種方法很有效。但有兩個特殊情況要注意。
首先，定義指針常量時會有點不同。因為常量定義一般是放在頭文件中（許多源文件會包含它），除了指針?biāo)傅念愋鸵x成const外，重要的是指針也經(jīng)常要定義成const。例如，要在頭文件中定義一個基于char*的字符串常量，你要寫兩次const：

const char * const authorName = "Scott Meyers";

關(guān)于const的含義和用法，特別是和指針相關(guān)聯(lián)的問題，參見條款21。

另外，定義某個類(class)的常量一般也很方便，只有一點點不同。要把常量限制在類中，首先要使它成為類的成員；為了保證常量最多只有一份拷貝，還要把它定義為靜態(tài)成員：
     

class GamePlayer {
private:
      static const int NUM_TURNS = 5; // constant eclaration  
      int scores[NUM_TURNS];                 // use of constant
      ...
};

還有一點，正如你看到的，上面的語句是NUM_TURNS的聲明，而不是定義，所以你還必須在類的實現(xiàn)代碼文件中定義類的靜態(tài)成員：

const int GamePlayer::NUM_TURNS;         // mandatory definition;
              // goes in class impl.file

你不必過于擔(dān)心這種小事。如果你忘了定義，鏈接器會提醒你。

舊一點的編譯器會不接受這種語法，因為它認(rèn)為類的靜態(tài)成員在聲明時定義初始值是非法的；而且，類內(nèi)只允許初始化整數(shù)類型(如：int, bool, char 等)，還只能是常量。
在上面的語法不能使用的情況下，可以在定義時賦初值：


class EngineeringConstants { // this goes in the class
private:                 // header file
      static const double FUDGE_FACTOR;
      ...
};
      // this goes in the class implementation file
      const double EngineeringConstants::FUDGE_FACTOR = 1.35;

大多數(shù)情況下你只要做這么多。唯一例外的是當(dāng)你的類在編譯時需要用到這個類的常量的情況，例如上面GamePlayer::scores數(shù)組的聲明(編譯過程中編譯器一定要知道數(shù)組的大小)。所以，為了彌補那些(不正確地)禁止類內(nèi)進(jìn)行整型類常量初始化的編譯器的不足，可以采用稱之為“借用enum”的方法來解決。這種技術(shù)很好地利用了當(dāng)需要int類型時可以使用枚舉類型的原則，所以GamePlayer也可以象這樣來定義：


class GamePlayer {
private:
      enum { NUM_TURNS = 5 }         // "the enum hack" — makes
      // NUM_TURNS a symbolic name  
      // for 5
      int scores[NUM_TURNS];// fine
};

除非你正在用老的編譯器(即寫于1995年之前)，你不必借用enum。當(dāng)然，知道有這種方法還是值得的，因為這種可以追溯到很久以前的時代的代碼可是不常見的喲。

回到預(yù)處理的話題上來。另一個普遍的#define指令的用法是用它來實現(xiàn)那些看起來象函數(shù)而又不會導(dǎo)致函數(shù)調(diào)用的宏。典型的例子是計算兩個對象的最大值：


#define max(a,b) ((a) > (b) ? (a) : (b))

這個語句有很多缺陷，光想想都讓人頭疼，甚至比在高峰時間到高速公路去開車還讓人痛苦。
無論什么時候你寫了象這樣的宏，你必須記住在寫宏體時對每個參數(shù)都要加上括號；否則，別人調(diào)用你的宏時如果用了表達(dá)式就會造成很大的麻煩。但是即使你象這樣做了，還會有象下面這樣奇怪的事發(fā)生：

int a = 5, b = 0;
max(++a, b);// a 的值增加了2次
max(++a, b+10); // a 的值只增加了1次

這種情況下，max內(nèi)部發(fā)生些什么取決于它比較的是什么值！
幸運的是你不必再忍受這樣愚笨的語句了。你可以用普通函數(shù)實現(xiàn)宏的效率，再加上可預(yù)計的行為和類型安全，這就是內(nèi)聯(lián)函數(shù)(見條款33)：


inline int max(int a, int b) { return a > b ? a : b; }
不過這和上面的宏不大一樣，因為這個版本的max只能處理int類型。但模板可以很輕巧地解決這個問題：


template<class T>
inline const T& max(const T& a, const T& b)
{ return a > b ? a : b; }

這個模板產(chǎn)生了一整套函數(shù)，每個函數(shù)拿兩個可以轉(zhuǎn)換成同種類型的對象進(jìn)行比較然后返回較大的(常量)對象的引用。因為不知道T的類型，返回時傳遞引用可以提高效率(見條款22)。

順便說一句，在你打算用模板寫象max這樣有用的通用函數(shù)時，先檢查一下標(biāo)準(zhǔn)庫(見條款49)，看看他們是不是已經(jīng)存在。比如說上面說的max，你會驚喜地發(fā)現(xiàn)你可以后人乘涼：max是C++標(biāo)準(zhǔn)庫的一部分。
有了const和inline，你對預(yù)處理的需要減少了，但也不能完全沒有它。拋棄#include的日子還很遠(yuǎn)，#ifdef/#ifndef在控制編譯的過程中還扮演重要角色。預(yù)處理還不能退休，但你一定要計劃給它經(jīng)常放長假。