1. 變量的聲明和定義有什么區別

變量的定義為變量分配地址和存儲空間， 變量的聲明不分配地址。一個變量可以在多個地方聲明， 但是只在一個地方定義。加入extern 修飾的是變量的聲明，說明此變量將在文件以外或在文件后面部分定義。

說明：很多時候一個變量，只是聲明不分配內存空間，直到具體使用時才初始化，分配內存空間， 如外部變量。

intmain()
{
externintA;
//這是個聲明而不是定義，聲明A是一個已經定義了的外部變量
//注意：聲明外部變量時可以把變量類型去掉如：extern A;
dosth();//執行函數
}
intA;//是定義，定義了A為整型的外部變量

2. 簡述#ifdef、#else、#endif和#ifndef的作用

利用#ifdef、#endif將某程序功能模塊包括進去，以向特定用戶提供該功能。在不需要時用戶可輕易將其屏蔽。

#ifdefMATH
#include"math.c"
#endif

在子程序前加上標記，以便于追蹤和調試。

#ifdefDEBUG
printf("Indebugging......!");
#endif

應對硬件的限制。由于一些具體應用環境的硬件不一樣，限于條件，本地缺乏這種設備，只能繞過硬件，直接寫出預期結果。

「注意」：雖然不用條件編譯命令而直接用if語句也能達到要求，但那樣做目標程序長（因為所有語句都編譯），運行時間長（因為在程序運行時間對if語句進行測試）。而采用條件編譯，可以減少被編譯的語句，從而減少目標程序的長度，減少運行時間。

3. 寫出int、bool、float、指針變量與“零值”比較的if語句

//int與零值比較
if(n==0)
if(n!=0)

//bool與零值比較
if(flag)//表示flag為真
if(!flag)//表示flag為假

//float與零值比較
constfloatEPSINON=0.00001;
if((x >=- EPSINON)&&(x <= EPSINON)?//其中EPSINON是允許的誤差（即精度）。
//指針變量與零值比較?
if(p==NULL)
if(p!=NULL)

4. 結構體可以直接賦值嗎？

聲明時可以直接初始化，同一結構體的不同對象之間也可以直接賦值，但是當結構體中含有指針“成員”時一定要小心。

「注意」：當有多個指針指向同一段內存時，某個指針釋放這段內存可能會導致其他指針的非法操作。因此在釋放前一定要確保其他指針不再使用這段內存空間。

5. sizeof和strlen的區別

• sizeof是一個操作符，strlen是庫函數。
• sizeof的參數可以是數據的類型，也可以是變量，而strlen只能以結尾為‘’的字符串作參數。
• 編譯器在編譯時就計算出了sizeof的結果，而strlen函數必須在運行時才能計算出來。并且sizeof計算的是數據類型占內存的大小，而strlen計算的是字符串實際的長度。
• 數組做sizeof的參數不退化，傳遞給strlen就退化為指針了

6. C語言的關鍵字static和C++的關鍵字static有什么區別？

在 C 中 static 用來修飾局部靜態變量和外部靜態變量、函數。而 C++中除了上述功能外，還用來定義類的成員變量和函數。即靜態成員和靜態成員函數。

「注意」：編程時 static 的記憶性，和全局性的特點可以讓在不同時期調用的函數進行通信，傳遞信息，而 C++的靜態成員則可以在多個對象實例間進行通信，傳遞信息。

7. Ｃ語言的malloc和Ｃ＋＋中的new有什么區別?

• new 、delete 是操作符，可以重載，只能在C++ 中使用。
• malloc、free 是函數，可以覆蓋，C、C++ 中都可以使用。
• new 可以調用對象的構造函數，對應的delete 調用相應的析構函數。
• malloc 僅僅分配內存，free 僅僅回收內存，并不執行構造和析構函數
• new 、delete 返回的是某種數據類型指針，malloc、free 返回的是void 指針。

「注意」：malloc 申請的內存空間要用free 釋放，而new 申請的內存空間要用delete 釋放，不要混用。

8. 寫一個“標準”宏MIN

#define min(a,b)((a)<=(b)?(a):(b))

9. ++i和i++的區別

++i先自增1，再返回，i++先返回i,再自增1

10. volatile有什么作用？

• 狀態寄存器一類的并行設備硬件寄存器。
• 一個中斷服務子程序會訪問到的非自動變量。
• 多線程間被幾個任務共享的變量。

「注意」：雖然volatile在嵌入式方面應用比較多，但是在PC軟件的多線程中，volatile修飾的臨界變量也是非常實用的。

11. 一個參數可以既是const又是volatile嗎?

可以，用const和volatile同時修飾變量，表示這個變量在程序內部是只讀的，不能改變的，只在程序外部條件變化下改變，并且編譯器不會優化這個變量。每次使用這個變量時，都要小心地去內存讀取這個變量的值，而不是去寄存器讀取它的備份。

注意：在此一定要注意const的意思，const只是不允許程序中的代碼改變某一變量，其在編譯期發揮作用，它并沒有實際地禁止某段內存的讀寫特性。

12. a和&a有什么區別？

&a：其含義就是“變量a的地址”。

*a：用在不同的地方，含義也不一樣。

• 在聲明語句中，*a只說明a是一個指針變量，如int *a；
• 在其他語句中，*a前面沒有操作數且a是一個指針時，*a代表指針a指向的地址內存放的數據，如b=*a；
• *a前面有操作數且a是一個普通變量時，a代表乘以a，如c=ba。

13. 用C編寫一個死循環程序

while(1)
{}

「注意」：很多種途徑都可實現同一種功能，但是不同的方法時間和空間占用度不同，特別是對于嵌入 式軟件，處理器速度比較慢，存儲空間較小，所以時間和空間優勢是選擇各種方法的首要考慮條件。

14. 結構體內存對齊問題

請寫出以下代碼的輸出結果：

#include
structS1
{
inti:8;
charj:4;
inta:4;
doubleb;
};

structS2
{
inti:8;
charj:4;
doubleb;
inta:4;
};

structS3
{
inti;
charj;
doubleb;
inta;
};

intmain()
{
printf("%d
",sizeof(S1));//輸出8
printf("%d
",sizeof(S1);//輸出12
printf("%d
",sizeof(Test3));//輸出8
return0;
}

sizeof(S1)=16
sizeof(S2)=24
sizeof(S3)=32

「說明」：結構體作為一種復合數據類型，其構成元素既可以是基本數據類型的變量，也可以是一些復合型類型數據。對此，編譯器會自動進行成員變量的對齊以提高運算效率。默認情況下，按自然對齊條件分配空間。各個成員按照它們被聲明的順序在內存中順序存儲，第一個成員的地址和整個結構的地址相同，向結構體成員中size最大的成員對齊。

許多實際的計算機系統對基本類型數據在內存中存放的位置有限制，它們會要求這些數據的首地址的值是某個數k（通常它為4或8）的倍數，而這個k則被稱為該數據類型的對齊模數。

15. 全局變量和局部變量有什么區別？怎么實現的？操作系統和編譯器是怎么知道的？

• 全局變量是整個程序都可訪問的變量，誰都可以訪問，生存期在整個程序從運行到結束（在程序結束時所占內存釋放）；
• 而局部變量存在于模塊（子程序，函數）中，只有所在模塊可以訪問，其他模塊不可直接訪問，模塊結束（函數調用完畢），局部變量消失，所占據的內存釋放。
• 操作系統和編譯器，可能是通過內存分配的位置來知道的，全局變量分配在全局數據段并且在程序開始運行的時候被加載.局部變量則分配在堆棧里面。

16. 簡述C、C++程序編譯的內存分配情況

• 從靜態存儲區域分配：

內存在程序編譯時就已經分配好，這塊內存在程序的整個運行期間都存在。速度快、不容易出錯， 因為有系統會善后。例如全局變量，static 變量，常量字符串等。

• 在棧上分配：

在執行函數時，函數內局部變量的存儲單元都在棧上創建，函數執行結束時這些存儲單元自動被釋 放。棧內存分配運算內置于處理器的指令集中，效率很高，但是分配的內存容量有限。大小為2M。

• 從堆上分配：

即動態內存分配。程序在運行的時候用 malloc 或new 申請任意大小的內存，程序員自己負責在何 時用free 或delete 釋放內存。動態內存的生存期由程序員決定，使用非常靈活。如果在堆上分配了空間，就有責任回收它，否則運行的程序會出現內存泄漏，另外頻繁地分配和釋放不同大小的堆空間將會產生 堆內碎塊。

一個C、C++程序編譯時內存分為5 大存儲區：堆區、棧區、全局區、文字常量區、程序代碼區。

17. 簡述strcpy、sprintf與memcpy的區別

• 操作對象不同，strcpy 的兩個操作對象均為字符串，sprintf 的操作源對象可以是多種數據類型， 目的操作對象是字符串，memcpy 的兩個對象就是兩個任意可操作的內存地址，并不限于何種數據類型。
• 執行效率不同，memcpy 最高，strcpy 次之，sprintf 的效率最低。
• 實現功能不同，strcpy 主要實現字符串變量間的拷貝，sprintf 主要實現其他數據類型格式到字 符串的轉化，memcpy 主要是內存塊間的拷貝。

「注意」：strcpy、sprintf 與memcpy 都可以實現拷貝的功能，但是針對的對象不同，根據實際需求，來 選擇合適的函數實現拷貝功能。

18. 解析((void ()( ) )0)( )的含義

• void (*0)( ) ：是一個返回值為void，參數為空的函數指針0。
• (void (*)( ))0：把0轉變成一個返回值為void，參數為空的函數指針。
• (void ()( ))0：在上句的基礎上加*表示整個是一個返回值為void，無參數，并且起始地址為0的函數的名字。
• ((void ()( ))0)( )：這就是上句的函數名所對應的函數的調用。

19. C語言的指針和引用和C++的有什么區別？

• 指針有自己的一塊空間，而引用只是一個別名；
• 使用sizeof看一個指針的大小是4，而引用則是被引用對象的大小；
• 作為參數傳遞時，指針需要被解引用才可以對對象進行操作，而直接對引 用的修改都會改變引用所指向的對象；
• 可以有const指針，但是沒有const引用；
• 指針在使用中可以指向其它對象，但是引用只能是一個對象的引用，不能 被改變；
• 指針可以有多級指針（**p），而引用止于一級；
• 指針和引用使用++運算符的意義不一樣；
• 如果返回動態內存分配的對象或者內存，必須使用指針，引用可能引起內存泄露。

20. typedef和define有什么區別？

• 用法不同：typedef 用來定義一種數據類型的別名，增強程序的可讀性。define 主要用來定義 常量，以及書寫復雜使用頻繁的宏。
• 執行時間不同：typedef 是編譯過程的一部分，有類型檢查的功能。define 是宏定義，是預編譯的部分，其發生在編譯之前，只是簡單的進行字符串的替換，不進行類型的檢查。
• 作用域不同：typedef 有作用域限定。define 不受作用域約束，只要是在define 聲明后的引用 都是正確的。
• 對指針的操作不同：typedef 和define 定義的指針時有很大的區別。

「注意」：typedef 定義是語句，因為句尾要加上分號。而define 不是語句，千萬不能在句尾加分號。

21. 指針常量與常量指針的區別

指針常量是指定義了一個指針，這個指針的值只能在定義時初始化，其他地方不能改變。常量指針 是指定義了一個指針，這個指針指向一個只讀的對象，不能通過常量指針來改變這個對象的值。指針常量強調的是指針的不可改變性，而常量指針強調的是指針對其所指對象的不可改變性。

「注意」：無論是指針常量還是常量指針，其最大的用途就是作為函數的形式參數，保證實參在被調用 函數中的不可改變特性。

22. 簡述隊列和棧的異同

隊列和棧都是線性存儲結構，但是兩者的插入和刪除數據的操作不同，隊列是“先進先出”，棧是 “后進先出”。

「注意」：區別棧區和堆區。堆區的存取是“順序隨意”，而棧區是“后進先出”。棧由編譯器自動分 配釋放 ，存放函數的參數值，局部變量的值等。其操作方式類似于數據結構中的棧。堆一般由程序員 分配釋放， 若程序員不釋放，程序結束時可能由OS 回收。分配方式類似于鏈表。它與本題中的堆和棧是兩回事。堆棧只是一種數據結構，而堆區和棧區是程序的不同內存存儲區域。

23. 設置地址為0x67a9的整型變量的值為0xaa66

int*ptr;
ptr=(int*)0x67a9;
*ptr=0xaa66;

「注意」：這道題就是強制類型轉換的典型例子，無論在什么平臺地址長度和整型數據的長度是一樣的， 即一個整型數據可以強制轉換成地址指針類型，只要有意義即可。

24. 編碼實現字符串轉化為數字

編碼實現函數atoi()，設計一個程序，把一個字符串轉化為一個整型數值。例如數字：“5486321 ”， 轉化成字符：5486321。

intmyAtoi(constchar*str)
{
intnum=0;//保存轉換后的數值
intisNegative=0;//記錄字符串中是否有負號

intn=0;
char*p=str;
if(p==NULL)//判斷指針的合法性
{
return-1;
}
while(*p++!='')//計算數字符串度
{
n++;
}
p=str;
if(p[0]=='-')//判斷數組是否有負號
{
isNegative=1;
}

chartemp='0';
for(inti=0;iif(temp>'9'||temp'0')//濾除非數字字符
{
continue;
}
if(num!=0||temp!='0')//濾除字符串開始的0字符
{
temp-=0x30;//將數字字符轉換為數值
num+=temp*int(pow(10,n-1-i));
}
}
if(isNegative)//如果字符串中有負號，將數值取反
{
return(0-num);
}
else
{
returnnum;//返回轉換后的數值
}
}

25. C語言的結構體和C++的有什么區別？

• C語言的結構體是不能有函數成員的，而C++的類可以有。
• C語言的結構體中數據成員是沒有private、public和protected訪問限定的。而C++的類的成員有這些訪問限定。
• C語言的結構體是沒有繼承關系的，而C++的類卻有豐富的繼承關系。

「注意」：雖然C的結構體和C++的類有很大的相似度，但是類是實現面向對象的基礎。而結構體只可以簡單地理解為類的前身。

26. 簡述指針常量與常量指針的區別

• 指針常量是指定義了一個指針，這個指針的值只能在定義時初始化，其他地方不能改變。常量指針是指定義了一個指針，這個指針指向一個只讀的對象，不能通過常量指針來改變這個對象的值。
• 指針常量強調的是指針的不可改變性，而常量指針強調的是指針對其所指對象的不可改變性。

「注意」：無論是指針常量還是常量指針，其最大的用途就是作為函數的形式參數，保證實參在被調用函數中的不可改變特性。

27. 如何避免“野指針”？

• 指針變量聲明時沒有被初始化。解決辦法：指針聲明時初始化，可以是具體的地址值，也可讓它指向NULL。
• 指針p被free或者delete之后，沒有置為NULL。解決辦法：指針指向的內存空間被釋放后指針應該指向NULL。
• 指針操作超越了變量的作用范圍。解決辦法：在變量的作用域結束前釋放掉變量的地址空間并且讓指針指向NULL。

28. 句柄和指針的區別和聯系是什么？

句柄和指針其實是兩個截然不同的概念。Windows系統用句柄標記系統資源，隱藏系統的信息。你只要知道有這個東西，然后去調用就行了，它是個32it的uint。指針則標記某個物理內存地址，兩者是不同的概念。

29. new/delete與malloc/free的區別是什么？

• new能自動計算需要分配的內存空間，而malloc需要手工計算字節數。

int*p=newint[2];
int*q=(int*)malloc(2*sizeof(int));

• new與delete直接帶具體類型的指針，malloc和free返回void類型的指針。
• new類型是安全的，而malloc不是。例如int *p = new float[2];就會報錯；而int p = malloc(2sizeof(int))編譯時編譯器就無法指出錯誤來。
• new一般分為兩步：new操作和構造。new操作對應與malloc，但new操作可以重載，可以自定義內存分配策略，不做內存分配，甚至分配到非內存設備上，而malloc不行。
• new調用構造函數，malloc不能；delete調用析構函數，而free不能。
• malloc/free需要庫文件stdlib.h的支持，new/delete則不需要！

「注意」：delete和free被調用后，內存不會立即回收，指針也不會指向空，delete或free僅僅是告訴操作系統，這一塊內存被釋放了，可以用作其他用途。但是由于沒有重新對這塊內存進行寫操作，所以內存中的變量數值并沒有發生變化，出現野指針的情況。因此，釋放完內存后，應該講該指針指向NULL。

30. 說一說extern“C”

extern "C"的主要作用就是為了能夠正確實現C++代碼調用其他C語言代碼。加上extern "C"后，會指示編譯器這部分代碼按C語言（而不是C++）的方式進行編譯。由于C++支持函數重載，因此編譯器編譯函數的過程中會將函數的參數類型也加到編譯后的代碼中，而不僅僅是函數名；而C語言并不支持函數重載，因此編譯C語言代碼的函數時不會帶上函數的參數類型，一般只包括函數名。

這個功能十分有用處，因為在C++出現以前，很多代碼都是C語言寫的，而且很底層的庫也是C語言寫的，為了更好的支持原來的C代碼和已經寫好的C語言庫，需要在C++中盡可能的支持C，而extern "C"就是其中的一個策略。

• C++代碼調用C語言代碼
• 在C++的頭文件中使用
• 在多個人協同開發時，可能有的人比較擅長C語言，而有的人擅長C++，這樣的情況下也會有用到

31. C++中struct和class的區別

在C++中，class和struct做類型定義是只有兩點區別：

• 默認繼承權限不同，class繼承默認是private繼承，而struct默認是public繼承
• class還可用于定義模板參數，像typename，但是關鍵字struct不能同于定義模板參數 C++保留struct關鍵字，原因
• 保證與C語言的向下兼容性，C++必須提供一個struct
• C++中的struct定義必須百分百地保證與C語言中的struct的向下兼容性，把C++中的最基本的對象單元規定為class而不是struct，就是為了避免各種兼容性要求的限制
• 對struct定義的擴展使C語言的代碼能夠更容易的被移植到C++中

32. C++類內可以定義引用數據成員嗎？

可以，必須通過成員函數初始化列表初始化。

33. C++中類成員的訪問權限

C++通過 public、protected、private 三個關鍵字來控制成員變量和成員函數的訪問權限，它們分別表示公有的、受保護的、私有的，被稱為成員訪問限定符。在類的內部（定義類的代碼內部），無論成員被聲明為 public、protected 還是 private，都是可以互相訪問的，沒有訪問權限的限制。在類的外部（定義類的代碼之外），只能通過對象訪問成員，并且通過對象只能訪問 public 屬性的成員，不能訪問 private、protected 屬性的成員

34. 什么是右值引用？跟左值又有什么區別？

左值和右值的概念：

• 左值：能取地址，或者具名對象，表達式結束后依然存在的持久對象；
• 右值：不能取地址，匿名對象，表達式結束后就不再存在的臨時對象；區別：
• 左值能賦值，右值不能；
• 左值可變，右值不能（僅對基礎類型適用，用戶自定義類型右值引用可以通過成員函數改變）；

35. 面向對象的三大特征

• 封裝性：將客觀事物抽象成類，每個類對自身的數據和方法實行 protection （private ， protected ， public ）。
• 繼承性：廣義的繼承有三種實現形式：實現繼承（使用基類的屬性和方法而無需額外編碼的能力)、可 視繼承(子窗體使用父窗體的外觀和實現代碼)、接口繼承(僅使用屬性和方法,實現滯后到子類實現)。
• 多態性：是將父類對象設置成為和一個或更多它的子對象相等的技術。用子類對象給父類對象賦值 之后，父類對象就可以根據當前賦值給它的子對象的特性以不同的方式運作。

36. 說一說c++中四種cast轉換

C++中四種類型轉換是：static_cast, dynamic_cast, const_cast, reinterpret_cast

1、const_cast

• 用于將const變量轉為非const

2、static_cast

• 用于各種隱式轉換，比如非const轉const，void*轉指針等, static_cast能用于多態向上轉化，如果向下轉能成功但是不安全，結果未知；

3、dynamic_cast

用于動態類型轉換。只能用于含有虛函數的類，用于類層次間的向上和向下轉化。只能轉指針或引用。向下轉化時，如果是非法的***對于指針返回NULL，對于引用拋異常***。要深入了解內部轉換的原理。

• 向上轉換：指的是子類向基類的轉換
• 向下轉換：指的是基類向子類的轉換

它通過判斷在執行到該語句的時候變量的運行時類型和要轉換的類型是否相同來判斷是否能夠進行向下轉換。

4、reinterpret_cast

• 幾乎什么都可以轉，比如將int轉指針，可能會出問題，盡量少用；

5、為什么不使用C的強制轉換？

• C的強制轉換表面上看起來功能強大什么都能轉，但是轉化不夠明確，不能進行錯誤檢查，容易出錯。

37. C++的空類有哪些成員函數？

• 缺省構造函數。
• 缺省拷貝構造函數。
• 省析構函數。
• 賦值運算符。
• 取址運算符。
• 取址運算符 const 。

「注意」：有些書上只是簡單的介紹了前四個函數。沒有提及后面這兩個函數。但后面這兩個函數也是 空類的默認函數。另外需要注意的是，只有當實際使用這些函數的時候，編譯器才會去定義它們。

38. 對c++中的smart pointer四個智能指針：shared_ptr,unique_ptr,weak_ptr,auto_ptr的理解

C++里面的四個智能指針: auto_ptr, shared_ptr, weak_ptr, unique_ptr 其中后三個是c++11支持，并且第一個已經被11棄用。

智能指針的作用是管理一個指針，因為存在以下這種情況：申請的空間在函數結束時忘記釋放，造成內存泄漏。使用智能指針可以很大程度上的避免這個問題，因為智能指針就是一個類，當超出了類的作用域是，類會自動調用析構函數，析構函數會自動釋放資源。所以智能指針的作用原理就是在函數結束時自動釋放內存空間，不需要手動釋放內存空間。

• auto_ptr（c++98的方案，cpp11已經拋棄）

采用所有權模式。

auto_ptrp1(newstring("Ireignedlonelyasacloud.”));
auto_ptrp2;
p2=p1;//auto_ptr不會報錯.

此時不會報錯，p2剝奪了p1的所有權，但是當程序運行時訪問p1將會報錯。所以auto_ptr的缺點是：存在潛在的內存崩潰問題！

• unique_ptr（替換auto_ptr）

unique_ptr實現獨占式擁有或嚴格擁有概念，保證同一時間內只有一個智能指針可以指向該對象。它對于避免資源泄露(例如“以new創建對象后因為發生異常而忘記調用delete”)特別有用。

采用所有權模式。

unique_ptrp3(newstring("auto"));//#4
unique_ptr p4；//#5
p4 = p3;//此時會報錯！！

編譯器認為p4=p3非法，避免了p3不再指向有效數據的問題。因此，unique_ptr比auto_ptr更安全。

另外unique_ptr還有更聰明的地方：當程序試圖將一個 unique_ptr 賦值給另一個時，如果源 unique_ptr 是個臨時右值，編譯器允許這么做；如果源 unique_ptr 將存在一段時間，編譯器將禁止這么做，比如：

unique_ptrpu1(newstring("helloworld"));
unique_ptrpu2;
pu2=pu1;//#1notallowed
unique_ptrpu3;
pu3=unique_ptr(newstring("You"));//#2allowed

其中#1留下懸掛的unique_ptr(pu1)，這可能導致危害。而#2不會留下懸掛的unique_ptr，因為它調用 unique_ptr 的構造函數，該構造函數創建的臨時對象在其所有權讓給 pu3 后就會被銷毀。這種隨情況而已的行為表明，unique_ptr 優于允許兩種賦值的auto_ptr 。

「注意」：如果確實想執行類似與#1的操作，要安全的重用這種指針，可給它賦新值。C++有一個標準庫函數std::move()，讓你能夠將一個unique_ptr賦給另一個。例如：

unique_ptrps1,ps2;
ps1=demo("hello");
ps2=move(ps1);
ps1=demo("alexia");
cout<

classB;
classA
{
public:
shared_ptrpb_;
~A()
{
cout<<"Adelete
";
}
};
classB
{
public:
shared_ptrpa_;
~B()
{
cout<<"Bdelete
";
}
};
voidfun()
{
shared_ptrpb(newB());
shared_ptrpa(newA());
pb->pa_=pa;
pa->pb_=pb;
cout<main()
{
fun();
return0;
}

try{
Circle&ref_circle=dynamic_cast(ref_shape);
}
catch(bad_castb){
cout<"Caught:"<

templateclassA
{
friendT;
private:
A(){}
~A(){}
};
classB:virtualpublicA
{
public:
B(){}
~B(){}
};
classC:virtualpublicB
{
public:
C(){}
~C(){}
};
voidmain(void)
{
Bb;
//Cc;
return;
}

#include
#include

usingnamespacestd;

classString{
public:
//默認構造函數
String(constchar*str=nullptr);
//拷貝構造函數
String(constString&str);
//析構函數
~String();
//字符串賦值函數
String&operator=(constString&str);

private:
char*m_data;
intm_size;
};

//構造函數
String::String(constchar*str)
{
if(str == nullptr)//加分點：對m_data加NULL 判斷
{
 m_data = new char[1];//得分點：對空字符串自動申請存放結束標志''的
m_data[0]='';
m_size=0;
}
else
{
m_size=strlen(str);
m_data=newchar[m_size+1];
strcpy(m_data,str);
}
}

//拷貝構造函數
String::String(const String &str)//得分點：輸入參數為const型
{
m_size=str.m_size;
 m_data = new char[m_size + 1];//加分點：對m_data加NULL 判斷
strcpy(m_data,str.m_data);
}

//析構函數
String::~String()
{
delete[]m_data;
}

//字符串賦值函數
String& String::operator=(const String &str)//得分點：輸入參數為const
{
if(this ==&str)//得分點：檢查自賦值
return*this;

 delete[] m_data;//得分點：釋放原有的內存資源
m_size=strlen(str.m_data);
 m_data = new char[m_size + 1];//加分點：對m_data加NULL 判斷
strcpy(m_data,str.m_data);
return*this;//得分點：返回本對象的引用
}

#include
classA
{
virtualvoidg()
{
cout<"A::g"<f()
{
cout<"A::f"<g()
{
cout<"B::g"<h()
{
cout<"B::h"<main()
{
Bb;
FunpFun;
for(inti=0;i

B::g
A::f
B::h

typedefstructnode
{
intdata;
node*next;
}node,*LinkStack;

//創建空棧：
LinkStackCreateNULLStack(LinkStack&S)
{
S=(LinkStack)malloc(sizeof(node));//申請新結點
if(NULL==S)
{
printf("Failtomallocanewnode.
");

returnNULL;
}
S->data=0;//初始化新結點
S->next=NULL;

returnS;
}

//棧的插入函數：
LinkStackPush(LinkStack&S,intdata)
{
if(NULL==S)//檢驗棧
{
printf("Therenonodeinstack!");
returnNULL;
}

LinkStackp=NULL;
p=(LinkStack)malloc(sizeof(node));//申請新結點

if(NULL==p)
{
printf("Failtomallocanewnode.
");
returnS;
}
if(NULL==S->next)
{
p->next=NULL;
}
else
{
p->next=S->next;
}
p->data=data;//初始化新結點
S->next=p;//插入新結點
returnS;
}

//出棧函數：
nodePop(LinkStack&S)
{
nodetemp;
temp.data=0;
temp.next=NULL;

if(NULL==S)//檢驗棧
{
printf("Therenonodeinstack!");
returntemp;
}
temp=*S;

if(S->next==NULL)
{
printf("ThestackisNULL,can'tpop!
");
returntemp;
}
LinkStackp=S->next;//節點出棧

S->next=S->next->next;
temp=*p;
free(p);
p=NULL;

returntemp;
}

//雙棧實現隊列的入隊函數：
LinkStackStackToQueuPush(LinkStack&S,intdata)
{
noden;
LinkStackS1=NULL;
CreateNULLStack(S1);//創建空棧

while(NULL!=S->next)//S出棧入S1
{
n=Pop(S);
Push(S1,n.data);
}
Push(S1,data);//新結點入棧

while(NULL!=S1->next)//S1出棧入S
{
n=Pop(S1);
Push(S,n.data);
}
returnS;
}

template//模板函數
intcompare(constT&v1,constT&v2)
{
if(v1>v2)return-1;
if(v2>v1)return1;
return0;
}
//模板特例化,滿足針對字符串特定的比較，要提供所有實參，這里只有一個T
template<>
intcompare(constchar*const&v1,constchar*const&v2)
{
returnstrcmp(p1,p2);
}

template<>
classhash
{
size_toperator()(sales_data&s);
//里面所有T都換成特例化類型版本sales_data
//按照最佳匹配原則，若T != sales_data，就用普通類模板，否則，就使用含有特定功能的特例化版本。
};

template
classFoo
{
voidBar();
voidBarst(Ta)();
};

template<>
voidFoo::Bar()
{
//進行int類型的特例化處理
cout<"我是int型特例化"<fs;
Foofi;//使用特例化
fs.Bar();//使用的是普通模板，即Foo::Bar()
fi.Bar();//特例化版本，執行Foo::Bar()
//Foo::Bar()和Foo::Bar()功能不同

#include
usingnamespacestd;

classParent{
public:
Parent(){
cout<"Parentconstructfunction"<Parent(){
cout<"Parentdestructorfunction"<Son(){
cout<"Sonconstructfunction"<Son(){
cout<"Sondestructorfunction"<main()
{
Parent*p=newSon();
deletep;
p=NULL;
return0;
}
//運行結果：
//Parentconstructfunction
//Sonconstructfunction
//Parentdestructorfunction

#include
usingnamespacestd;

classParent{
public:
Parent(){
cout<"Parentconstructfunction"<Parent(){
cout<"Parentdestructorfunction"<Son(){
cout<"Sonconstructfunction"<Son(){
cout<"Sondestructorfunction"<main()
{
Parent*p=newSon();
deletep;
p=NULL;
return0;
}
//運行結果：
//Parentconstructfunction
//Sonconstructfunction
//Sondestructorfunction
//Parentdestructorfunction