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

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

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

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

2. 簡(jiǎn)述#ifdef、#else、#endif和#ifndef的作用

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

#ifdefMATH
#include"math.c"
#endif

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

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

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

「注意」：雖然不用條件編譯命令而直接用if語(yǔ)句也能達(dá)到要求，但那樣做目標(biāo)程序長(zhǎng)（因?yàn)樗姓Z(yǔ)句都編譯），運(yùn)行時(shí)間長(zhǎng)（因?yàn)樵诔绦蜻\(yùn)行時(shí)間對(duì)if語(yǔ)句進(jìn)行測(cè)試）。而采用條件編譯，可以減少被編譯的語(yǔ)句，從而減少目標(biāo)程序的長(zhǎng)度，減少運(yùn)行時(shí)間。

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

//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)體可以直接賦值嗎？

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

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

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

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

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

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

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

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

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

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

8. 寫一個(gè)“標(biāo)準(zhǔn)”宏MIN

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

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

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

10. volatile有什么作用？

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

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

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

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

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

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

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

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

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

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

while(1)
{}

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

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

請(qǐng)寫出以下代碼的輸出結(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)體作為一種復(fù)合數(shù)據(jù)類型，其構(gòu)成元素既可以是基本數(shù)據(jù)類型的變量，也可以是一些復(fù)合型類型數(shù)據(jù)。對(duì)此，編譯器會(huì)自動(dòng)進(jìn)行成員變量的對(duì)齊以提高運(yùn)算效率。默認(rèn)情況下，按自然對(duì)齊條件分配空間。各個(gè)成員按照它們被聲明的順序在內(nèi)存中順序存儲(chǔ)，第一個(gè)成員的地址和整個(gè)結(jié)構(gòu)的地址相同，向結(jié)構(gòu)體成員中size最大的成員對(duì)齊。

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

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

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

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

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

內(nèi)存在程序編譯時(shí)就已經(jīng)分配好，這塊內(nèi)存在程序的整個(gè)運(yùn)行期間都存在。速度快、不容易出錯(cuò)， 因?yàn)橛邢到y(tǒng)會(huì)善后。例如全局變量，static 變量，常量字符串等。

• 在棧上分配：

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

• 從堆上分配：

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

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

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

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

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

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

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

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

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

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

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

「注意」：typedef 定義是語(yǔ)句，因?yàn)榫湮惨由戏痔?hào)。而define 不是語(yǔ)句，千萬(wàn)不能在句尾加分號(hào)。

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

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

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

22. 簡(jiǎn)述隊(duì)列和棧的異同

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

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

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

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

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

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

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

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

intn=0;
char*p=str;
if(p==NULL)//判斷指針的合法性
{
return-1;
}
while(*p++!='')//計(jì)算數(shù)字符串度
{
n++;
}
p=str;
if(p[0]=='-')//判斷數(shù)組是否有負(fù)號(hào)
{
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)//如果字符串中有負(fù)號(hào)，將數(shù)值取反
{
return(0-num);
}
else
{
returnnum;//返回轉(zhuǎn)換后的數(shù)值
}
}

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

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

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

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

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

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

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

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

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

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

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

• new能自動(dòng)計(jì)算需要分配的內(nèi)存空間，而malloc需要手工計(jì)算字節(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];就會(huì)報(bào)錯(cuò)；而int p = malloc(2sizeof(int))編譯時(shí)編譯器就無(wú)法指出錯(cuò)誤來。
• new一般分為兩步：new操作和構(gòu)造。new操作對(duì)應(yīng)與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需要庫(kù)文件stdlib.h的支持，new/delete則不需要！

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

30. 說一說extern“C”

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

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

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

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

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

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

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

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

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

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

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

左值和右值的概念：

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

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

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

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

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

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

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

4、reinterpret_cast

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

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

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

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

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

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

38. 對(duì)c++中的smart pointer四個(gè)智能指針：shared_ptr,unique_ptr,weak_ptr,auto_ptr的理解

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

智能指針的作用是管理一個(gè)指針，因?yàn)榇嬖谝韵逻@種情況：申請(qǐng)的空間在函數(shù)結(jié)束時(shí)忘記釋放，造成內(nèi)存泄漏。使用智能指針可以很大程度上的避免這個(gè)問題，因?yàn)橹悄苤羔樉褪且粋€(gè)類，當(dāng)超出了類的作用域是，類會(huì)自動(dòng)調(diào)用析構(gòu)函數(shù)，析構(gòu)函數(shù)會(huì)自動(dòng)釋放資源。所以智能指針的作用原理就是在函數(shù)結(jié)束時(shí)自動(dòng)釋放內(nèi)存空間，不需要手動(dòng)釋放內(nèi)存空間。

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

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

auto_ptrp1(newstring("Ireignedlonelyasacloud.”));
auto_ptrp2;
p2=p1;//auto_ptr不會(huì)報(bào)錯(cuò).

此時(shí)不會(huì)報(bào)錯(cuò)，p2剝奪了p1的所有權(quán)，但是當(dāng)程序運(yùn)行時(shí)訪問p1將會(huì)報(bào)錯(cuò)。所以auto_ptr的缺點(diǎn)是：存在潛在的內(nèi)存崩潰問題！

• unique_ptr（替換auto_ptr）

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

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

unique_ptrp3(newstring("auto"));//#4
unique_ptr p4；//#5
p4 = p3;//此時(shí)會(huì)報(bào)錯(cuò)！！

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

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

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

其中#1留下懸掛的unique_ptr(pu1)，這可能導(dǎo)致危害。而#2不會(huì)留下懸掛的unique_ptr，因?yàn)樗{(diào)用 unique_ptr 的構(gòu)造函數(shù)，該構(gòu)造函數(shù)創(chuàng)建的臨時(shí)對(duì)象在其所有權(quán)讓給 pu3 后就會(huì)被銷毀。這種隨情況而已的行為表明，unique_ptr 優(yōu)于允許兩種賦值的auto_ptr 。

「注意」：如果確實(shí)想執(zhí)行類似與#1的操作，要安全的重用這種指針，可給它賦新值。C++有一個(gè)標(biāo)準(zhǔn)庫(kù)函數(shù)std::move()，讓你能夠?qū)⒁粋€(gè)unique_ptr賦給另一個(gè)。例如：

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:
//默認(rèn)構(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)//加分點(diǎn)：對(duì)m_data加NULL 判斷
{
 m_data = new char[1];//得分點(diǎn)：對(duì)空字符串自動(dòng)申請(qǐng)存放結(jié)束標(biāo)志''的
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)//得分點(diǎn)：輸入?yún)?shù)為const型
{
m_size=str.m_size;
 m_data = new char[m_size + 1];//加分點(diǎn)：對(duì)m_data加NULL 判斷
strcpy(m_data,str.m_data);
}

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

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

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

#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));//申請(qǐng)新結(jié)點(diǎn)
if(NULL==S)
{
printf("Failtomallocanewnode.
");

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

returnS;
}

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

LinkStackp=NULL;
p=(LinkStack)malloc(sizeof(node));//申請(qǐng)新結(jié)點(diǎn)

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

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

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

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

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

returntemp;
}

//雙棧實(shí)現(xiàn)隊(duì)列的入隊(duì)函數(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é)點(diǎn)入棧

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;
}
//模板特例化,滿足針對(duì)字符串特定的比較，要提供所有實(shí)參，這里只有一個(gè)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()
{
//進(jìn)行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;
}
//運(yùn)行結(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;
}
//運(yùn)行結(jié)果：
//Parentconstructfunction
//Sonconstructfunction
//Sondestructorfunction
//Parentdestructorfunction