1. 變量的聲明和定義有什么區(qū)別

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

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

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

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

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

#ifdefMATH
#include"math.c"
#endif

在子程序前加上標記，以便于追蹤和調(diào)試。

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

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

「注意」：雖然不用條件編譯命令而直接用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. 結(jié)構(gòu)體可以直接賦值嗎？

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

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

5. sizeof和strlen的區(qū)別

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

6. C語言的關(guān)鍵字static和C++的關(guān)鍵字static有什么區(qū)別？

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

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

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

• new 、delete 是操作符，可以重載，只能在C++ 中使用。
• malloc、free 是函數(shù)，可以覆蓋，C、C++ 中都可以使用。
• new 可以調(diào)用對象的構(gòu)造函數(shù)，對應的delete 調(diào)用相應的析構(gòu)函數(shù)。
• malloc 僅僅分配內(nèi)存，free 僅僅回收內(nèi)存，并不執(zhí)行構(gòu)造和析構(gòu)函數(shù)
• new 、delete 返回的是某種數(shù)據(jù)類型指針，malloc、free 返回的是void 指針。

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

8. 寫一個“標準”宏MIN

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

9. ++i和i++的區(qū)別

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

10. volatile有什么作用？

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

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

11. 一個參數(shù)可以既是const又是volatile嗎?

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

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

12. a和&a有什么區(qū)別？

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

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

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

13. 用C編寫一個死循環(huán)程序

while(1)
{}

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

14. 結(jié)構(gòu)體內(nèi)存對齊問題

請寫出以下代碼的輸出結(jié)果：

#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

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

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

15. 全局變量和局部變量有什么區(qū)別？怎么實現(xiàn)的？操作系統(tǒng)和編譯器是怎么知道的？

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

16. 簡述C、C++程序編譯的內(nèi)存分配情況

• 從靜態(tài)存儲區(qū)域分配：

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

• 在棧上分配：

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

• 從堆上分配：

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

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

17. 簡述strcpy、sprintf與memcpy的區(qū)別

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

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

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

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

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

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

20. typedef和define有什么區(qū)別？

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

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

21. 指針常量與常量指針的區(qū)別

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

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

22. 簡述隊列和棧的異同

隊列和棧都是線性存儲結(jié)構(gòu)，但是兩者的插入和刪除數(shù)據(jù)的操作不同，隊列是“先進先出”，棧是 “后進先出”。

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

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

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

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

24. 編碼實現(xiàn)字符串轉(zhuǎn)化為數(shù)字

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

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

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

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

25. C語言的結(jié)構(gòu)體和C++的有什么區(qū)別？

• C語言的結(jié)構(gòu)體是不能有函數(shù)成員的，而C++的類可以有。
• C語言的結(jié)構(gòu)體中數(shù)據(jù)成員是沒有private、public和protected訪問限定的。而C++的類的成員有這些訪問限定。
• C語言的結(jié)構(gòu)體是沒有繼承關(guān)系的，而C++的類卻有豐富的繼承關(guān)系。

「注意」：雖然C的結(jié)構(gòu)體和C++的類有很大的相似度，但是類是實現(xiàn)面向?qū)ο蟮幕A(chǔ)。而結(jié)構(gòu)體只可以簡單地理解為類的前身。

26. 簡述指針常量與常量指針的區(qū)別

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

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

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

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

28. 句柄和指針的區(qū)別和聯(lián)系是什么？

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

29. new/delete與malloc/free的區(qū)別是什么？

• new能自動計算需要分配的內(nèi)存空間，而malloc需要手工計算字節(jié)數(shù)。

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操作和構(gòu)造。new操作對應與malloc，但new操作可以重載，可以自定義內(nèi)存分配策略，不做內(nèi)存分配，甚至分配到非內(nèi)存設(shè)備上，而malloc不行。
• new調(diào)用構(gòu)造函數(shù)，malloc不能；delete調(diào)用析構(gòu)函數(shù)，而free不能。
• malloc/free需要庫文件stdlib.h的支持，new/delete則不需要！

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

30. 說一說extern“C”

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

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

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

31. C++中struct和class的區(qū)別

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

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

32. C++類內(nèi)可以定義引用數(shù)據(jù)成員嗎？

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

33. C++中類成員的訪問權(quán)限

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

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

左值和右值的概念：

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

35. 面向?qū)ο蟮娜筇卣?/span>

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

36. 說一說c++中四種cast轉(zhuǎn)換

C++中四種類型轉(zhuǎn)換是：static_cast, dynamic_cast, const_cast, reinterpret_cast

1、const_cast

• 用于將const變量轉(zhuǎn)為非const

2、static_cast

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

3、dynamic_cast

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

• 向上轉(zhuǎn)換：指的是子類向基類的轉(zhuǎn)換
• 向下轉(zhuǎn)換：指的是基類向子類的轉(zhuǎn)換

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

4、reinterpret_cast

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

5、為什么不使用C的強制轉(zhuǎn)換？

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

37. C++的空類有哪些成員函數(shù)？

• 缺省構(gòu)造函數(shù)。
• 缺省拷貝構(gòu)造函數(shù)。
• 省析構(gòu)函數(shù)。
• 賦值運算符。
• 取址運算符。
• 取址運算符 const 。

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

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

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

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

• auto_ptr（c++98的方案，cpp11已經(jīng)拋棄）

采用所有權(quán)模式。

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

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

• unique_ptr（替換auto_ptr）

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

采用所有權(quán)模式。

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

編譯器認為p4=p3非法，避免了p3不再指向有效數(shù)據(jù)的問題。因此，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，因為它調(diào)用 unique_ptr 的構(gòu)造函數(shù)，該構(gòu)造函數(shù)創(chuàng)建的臨時對象在其所有權(quán)讓給 pu3 后就會被銷毀。這種隨情況而已的行為表明，unique_ptr 優(yōu)于允許兩種賦值的auto_ptr 。

「注意」：如果確實想執(zhí)行類似與#1的操作，要安全的重用這種指針，可給它賦新值。C++有一個標準庫函數(shù)std::move()，讓你能夠?qū)⒁粋€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:
//默認構(gòu)造函數(shù)
String(constchar*str=nullptr);
//拷貝構(gòu)造函數(shù)
String(constString&str);
//析構(gòu)函數(shù)
~String();
//字符串賦值函數(shù)
String&operator=(constString&str);

private:
char*m_data;
intm_size;
};

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

//拷貝構(gòu)造函數(shù)
String::String(const String &str)//得分點：輸入?yún)?shù)為const型
{
m_size=str.m_size;
 m_data = new char[m_size + 1];//加分點：對m_data加NULL 判斷
strcpy(m_data,str.m_data);
}

//析構(gòu)函數(shù)
String::~String()
{
delete[]m_data;
}

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

 delete[] m_data;//得分點：釋放原有的內(nèi)存資源
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;

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

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

returnS;
}

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

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

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

//出棧函數(shù)：
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;//節(jié)點出棧

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

returntemp;
}

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

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

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

template//模板函數(shù)
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();//特例化版本，執(zhí)行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;
}
//運行結(jié)果：
//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;
}
//運行結(jié)果：
//Parentconstructfunction
//Sonconstructfunction
//Sondestructorfunction
//Parentdestructorfunction