問1：請用簡單的語言告訴我C++ 是什么？
答：C++是在C語言的基礎上開發的一種面向對象編程語言，應用廣泛。C++支持多種編程范式 －－面向對象編程、泛型編程和過程化編程。 其編程領域眾廣，常用于系統開發，引擎開發等應用領域，是最受廣大程序員受用的最強大編程語言之一,支持類：類、封裝、重載等特性!
問2：C和C++的區別？
答：c++在c的基礎上增添類，C是一個結構化語言，它的重點在于算法和數據結構。C程序的設計首要考慮的是如何通過一個過程，對輸入（或環境條件）進行運算處理得到輸出（或實現過程（事務）控制），而對于C++，首要考慮的是如何構造一個對象模型，讓這個模型能夠契合與之對應的問題域，這樣就可以通過獲取對象的狀態信息得到輸出或實現過程（事務）控制。
問3：什么是面向對象（OOP）？
答：面向對象是一種對現實世界理解和抽象的方法、思想，通過將需求要素轉化為對象進行問題處理的一種思想。
問4：什么是多態？
答：多態是指相同的操作或函數、過程可作用于多種類型的對象上并獲得不同的結果。不同的對象，收到同一消息可以產生不同的結果，這種現象稱為多態。
問5：設計模式懂嘛，簡單舉個例子？
答：設計模式（Design pattern）是一套被反復使用、多數人知曉的、經過分類編目的、代碼設計經驗的總結。
比如單例模式，保證一個類僅有一個實例，并提供一個訪問它的全局訪問點。
適用于：當類只能有一個實例而且客戶可以從一個眾所周知的訪問點訪問它時；當這個唯一實例應該是通過子類化可擴展的，并且客戶應該無需更改代碼就能使用一個擴展的實例時。
比如工廠模式，定義一個用于創建對象的接口，讓子類決定實例化哪一個類。Factory Method 使一個類的實例化延遲到其子類。
適用于：當一個類不知道它所必須創建的對象的類的時候；當一個類希望由它的子類來指定它所創建的對象的時候；當類將創建對象的職責委托給多個幫助子類中的某一個，并且你希望將哪一個幫助子類是代理者這一信息局部化的時候。
問6：STL庫用過嗎？常見的STL容器有哪些？算法用過哪幾個？
答：STL包括兩部分內容：容器和算法。（重要的還有融合這二者的迭代器）容器，即存放數據的地方。比如array等。在STL中，容器分為兩類：序列式容器和關聯式容器。
序列式容器，其中的元素不一定有序，但都可以被排序。如：vector、list、deque、stack、queue、heap、priority_queue、slist；
關聯式容器，內部結構基本上是一顆平衡二叉樹。所謂關聯，指每個元素都有一個鍵值和一個實值，元素按照一定的規則存放。如：RB-tree、set、map、multiset、multimap、hashtable、hash_set、hash_map、hash_multiset、hash_multimap。
下面各選取一個作為說明。
vector：它是一個動態分配存儲空間的容器。區別于c++中的array，array分配的空間是靜態的，分配之后不能被改變，而vector會自動重分配（擴展）空間。
set：其內部元素會根據元素的鍵值自動被排序。區別于map，它的鍵值就是實值，而map可以同時擁有不同的鍵值和實值。
算法，如排序，復制……以及個容器特定的算法。這點不用過多介紹，主要看下面迭代器的內容。
迭代器是STL的精髓，我們這樣描述它：迭代器提供了一種方法，使它能夠按照順序訪問某個容器所含的各個元素，但無需暴露該容器的內部結構。它將容器和算法分開，好讓這二者獨立設計。
問7：數據結構會嗎？項目開發過程中主要用到那些？
答：數據結構中主要會用到數組，鏈表，樹（較少），也會用到棧和隊列的思想。
問8：const知道嗎？解釋其作用。
答：
1.const 修飾類的成員變量，表示成員常量，不能被修改。
2.const修飾函數承諾在本函數內部不會修改類內的數據成員，不會調用其它非 const 成員函數。
3.如果 const 構成函數重載，const 對象只能調用 const 函數，非 const 對象優先調用非 const 函數。
4.const 函數只能調用 const 函數。非 const 函數可以調用 const 函數。
5.類體外定義的 const 成員函數，在定義和聲明處都需要 const 修飾符。。
問9：類的static變量在什么時候初始化？函數的static變量在什么時候初始化？
答：類的靜態成員變量在類實例化之前就已經存在了，并且分配了內存。函數的static變量在執行此函數時進行初始化。
問10：堆和棧的區別？堆和棧的生命周期？
答：
一、堆棧空間分配區別：
1、棧（操作系統）：由操作系統自動分配釋放 ，存放函數的參數值，局部變量的值等。其操作方式類似于數據結構中的棧；
2、堆（操作系統）： 一般由程序員分配釋放， 若程序員不釋放，程序結束時可能由OS回收，分配方式倒是類似于鏈表。
二、堆棧緩存方式區別：
1、棧使用的是一級緩存， 他們通常都是被調用時處于存儲空間中，調用完畢立即釋放；
2、堆是存放在二級緩存中，生命周期由虛擬機的垃圾回收算法來決定（并不是一旦成為孤兒對象就能被回收）。所以調用這些對象的速度要相對來得低一些。
三、堆棧數據結構區別：
堆（數據結構）：堆可以被看成是一棵樹，如：堆排序；
棧（數據結構）：一種先進后出的數據結構。
問11：C和C++的區別？
答：C++在C的基礎上增添類
C是一個結構化語言，它的重點在于算法和數據結構。
C程序的設計首要考慮的是如何通過一個過程，對輸入（或環境條件）進行運算處理得到輸出（或實現過程（事務）控制），而對于C++，首要考慮的是如何構造一個對象模型，讓這個模型能夠契合與之對應的問題域，這樣就可以通過獲取對象的狀態信息得到輸出或實現過程（事務）控制。
問12：解釋下封裝、繼承和多態？
一、封裝：
封裝是實現面向對象程序設計的第一步，封裝就是將數據或函數等集合在一個個的單元中（我們稱之為類）。
封裝的意義在于保護或者防止代碼（數據）被我們無意中破壞。
二、繼承：
繼承主要實現重用代碼，節省開發時間。
子類可以繼承父類的一些東西。
三、多態
多態：同一操作作用于不同的對象，可以有不同的解釋，產生不同的執行結果。在運行時，可以通過指向基類的指針，來調用實現派生類中的方法。
問13：指針和引用的區別？
答：
1. 指針是一個變量，只不過這個變量存儲的是一個地址，指向內存的一個存儲單元；而引用僅是個別名；
2. 引用使用時無需解引用(*)，指針需要解引用；
3. 引用只能在定義時被初始化一次，之后不可變；指針可變；
4. 引用沒有 const，指針有 const；
5. 引用不能為空，指針可以為空；
6. “sizeof 引用”得到的是所指向的變量(對象)的大小，而“sizeof 指針”得到的是指針本身的大小；
7. 指針和引用的自增(++)運算意義不一樣；
8. 指針可以有多級，但是引用只能是一級（int **p；合法 而 int &&a是不合法的）
9.從內存分配上看：程序為指針變量分配內存區域，而引用不需要分配內存區域。
問14：什么是內存泄漏？面對內存泄漏和指針越界，你有哪些方法？你通常采用哪些方法來避免和減少這類錯誤？
答：用動態存儲分配函數動態開辟的空間，在使用完畢后未釋放，結果導致一直占據該內存單元即為內存泄露。
使用的時候要記得指針的長度。
malloc的時候得確定在那里free.
對指針賦值的時候應該注意被賦值指針需要不需要釋放.
動態分配內存的指針最好不要再次賦值.
問15：常用的排序算法有哪些？簡單描述幾個排序算法的優缺點？
答：選擇、冒泡、快速、**、希爾、歸并、堆排等。
1.快排：是冒泡排序的一種改進。
優點：快，數據移動少
缺點：穩定性不足
2.歸并：分治法排序，穩定的排序算法，一般用于對總體無序，但局部有序的數列。
優點：效率高O(n)，穩定
缺點：比較占用內存
問16：new和malloc的區別？
答：
1、malloc與free是C++/C語言的標準庫函數，new/delete是C++的運算符。它們都可用于申請動態內存和釋放內存。
2、對于非內部數據類型的對象而言，光用maloc/free無法滿足動態對象的要求。對象在創建的同時要自動執行構造函數，對象在消亡之前要自動執行析構函數。
3、由于malloc/free是庫函數而不是運算符，不在編譯器控制權限之內，不能夠把執行構造函數和析構函數的任務強加于malloc/free。因此C++語言需要一個能完成動態內存分配和初始化工作的運算符new，以一個能完成清理與釋放內存工作的運算符delete。注意new/delete不是庫函數。
4、C++程序經常要調用C函數，而C程序只能用malloc/free管理動態內存。
5、new可以認為是malloc加構造函數的執行。new出來的指針是直接帶類型信息的。而malloc返回的都是void指針。
問17：TCP和UDP通信的差別？什么是IOCP？
答：
1.TCP面向連接， UDP面向無連接的2.TCP有保障的，UDP傳輸無保障的3.TCP是效率低的，UDP效率高的4.TCP是基于流的，UDP基于數據報文5.TCP傳輸重要數據，UDP傳輸不重要的數據
IOCP全稱I/O Completion Port，中文譯為I/O完成端口。IOCP是一個異步I/O的API，它可以高效地將I/O事件通知給應用程序。
與使用select()或是其它異步方法不同的是，一個套接字[socket]與一個完成端口關聯了起來，然后就可繼續進行正常的Winsock操作了。然而，當一個事件發生的時候，此完成端口就將被操作系統加入一個隊列中。然后應用程序可以對核心層進行查詢以得到此完成端口。
問18：同步IO和異步IO的區別？
A. 同步
所謂同步，就是在發出一個功能調用時，在沒有得到結果之前，該調用就不返回。
按照這個定義，其實絕大多數函數都是同步調用（例如sin isdigit等）。
但是一般而言，我們在說同步、異步的時候，特指那些需要其他部件協作或者需要一定時間完成的任務。
最常見的例子就是 SendMessage。
該函數發送一個消息給某個窗口，在對方處理完消息之前，這個函數不返回。
當對方處理完畢以后，該函數才把消息處理函數所返回的值返回給調用者。
B. 異步
異步的概念和同步相對。
當一個異步過程調用發出后，調用者不會立刻得到結果。
實際處理這個調用的部件是在調用發出后，通過狀態、通知來通知調用者，或通過回調函數處理這個調用。
問19：解釋C++中靜態函數和靜態變量？
答：
(1)類靜態數據成員在編譯時創建并初始化：在該類的任何對象建立之前就存在，不屬于任何對象，而非靜態類成員變量則是屬于對象所有的。類靜態數據成員只有一個拷貝，為所有此類的對象所共享。
(2)類靜態成員函數屬于整個類，不屬于某個對象，由該類所有對象共享。
1、static 成員變量實現了同類對象間信息共享。
2、static 成員類外存儲，求類大小，并不包含在內。
3、static 成員是命名空間屬于類的全局變量，存儲在 data 區的rw段。
4、static 成員只能類外初始化。
5、可以通過類名訪問（無對象生成時亦可），也可以通過對象訪問。
1、靜態成員函數的意義，不在于信息共享，數據溝通，而在于管理靜態數據成員，完成對靜態數據成員的封裝。
2、靜態成員函數只能訪問靜態數據成員。原因：非靜態成員函數，在調用時 this指針時被當作參數傳進。而靜態成員函數屬于類，而不屬于對象，沒有 this 指針。
問20：說下你對內存的了解？
答：
1.棧 - 由編譯器自動分配釋放
2.堆 - 一般由程序員分配釋放，若程序員不釋放，程序結束時可能由OS回收
3.全局區(靜態區)，全局變量和靜態變量的存儲是放在一塊的，初始化的全局變量和靜態變量在一塊區域，未初始化的全局變量和未初始化的靜態變量在相鄰的另一塊區域。- 程序結束釋放
4.另外還有一個專門放常量的地方。- 程序結束釋放
5 程序代碼區，存放2進制代碼。
在函數體中定義的變量通常是在棧上，用malloc， calloc， realloc等分配內存的函數分配得到的就是在堆上。在所有函數體外定義的是全局量，加了static修飾符后不管在哪里都存放在全局區(靜態區)，在所有函數體外定義的static變量表示在該文件中有效，不能extern到別的文件用，在函數體內定義的static表示只在該函數體內有效。另外，函數中的"adgfdf"這樣的字符串存放在常量區。
面試題1：變量的聲明和定義有什么區別
為變量分配地址和存儲空間的稱為定義，不分配地址的稱為聲明。一個變量可以在多個地方聲明，但只能在一個地方定義。加入extern修飾的是變量的聲明，說明此變量將在文件以外或在文件后面部分定義。
說明：很多時候一個變量，只是聲明，不分配內存空間，知道具體使用時才初始化，分配內存空間，如外部變量。
面試題2：sizeof和strlen的區別
sizeof是一個操作符，strlen是庫函數。
sizeof的參數可以是數據的類型，也可以是變量，而strlen只能以結尾為‘\0‘的字符串作參數。
編譯器在編譯時就計算出了sizeof的結果。而strlen函數必須在運行時才能計算出來。并且sizeof計算的是數據類型占內存的大小，而strlen計算的是字符串實際的長度。
數組做sizeof的參數不退化，傳遞給strlen就退化為指針了。
注意：有些是操作符看起來像是函數，而有些函數名看起來又像操作符，這類容易混淆的名稱一定要加以區分，否則遇到數組名這類特殊數據類型作參數時就很容易出錯。最容易混淆為函數的操作符就是sizeof。
說明：指針是一種普通的變量，從訪問上沒有什么不同于其他變量的特性。其保存的數值是個整型數據，和整型變量不同的是，這個整型數據指向的是一段內存地址。
面試題3：寫一個“標準”宏MIN
#define min(a,b) ((a)<=(b)?(a):(b))
面試題4：一個指針可以是volatile嗎？
可以，因為指針和普通變量一樣，有時也有變化程序的不可控性。常見例：子中斷服務子程序修改一個指向一個buffer的指針時，必須用volatile來修飾這個指針。
面試題5：a 和 &a 有什么區別請寫出以下代碼的打印結果，主要目的是考察a和&a的區別。
#include<stdio.h>
void main( void )
{
int a[5]={1,2,3,4,5};
int *ptr=(int *)(&a+1);
printf("%d,%d",*(a+1),*(ptr-1));
return;
}
輸出結果：2，5。
注意：數組名a可以作數組的首地址，而&a是數組的指針。思考，將原式的int ptr=(int )(&a+1);改為int ptr=(int )(a+1);時輸出結果將是什么呢？
面試題6：簡述C、C++程序編譯的內存分配情況
C、C++中內存分配方式可以分為三種：
（1）從靜態存儲區域分配：
內存在程序編譯時就已經分配好，這塊內存在程序的整個運行期間都存在。速度快、不容易出錯，因為有系統會善后。例如全局變量，static變量等。
（2）在棧上分配：
在執行函數時，函數內局部變量的存儲單元都在棧上創建，函數執行結束時這些存儲單元自動被釋放。棧內存分配運算內置于處理器的指令集中，效率很高，但是分配的內存容量有限。
（3）從堆上分配：
即動態內存分配。程序在運行的時候用malloc或new申請任意大小的內存，程序員自己負責在何時用free或delete釋放內存。動態內存的生存期由程序員決定，使用非常靈活。如果在堆上分配了空間，就有責任回收它，否則運行的程序會出現內存泄漏，另外頻繁地分配和釋放不同大小的堆空間將會產生堆內碎塊。
一個C、C++程序編譯時內存分為5大存儲區：堆區、棧區、全局區、文字常量區、程序代碼區。
面試題7：簡述strcpy sprintf與mencpy的區別
三者主要有以下不同之處：
（1）操作對象不同，strcpy的兩個操作對象均為字符串，sprintf的操作源對象可以是多種數據類型，目的操作對象是字符串，memcpy 的兩個對象就是兩個任意可操作的內存地址，并不限于何種數據類型。
（2）執行效率不同，memcpy最高，strcpy次之，sprintf的效率最低。
（3）實現功能不同，strcpy主要實現字符串變量間的拷貝，sprintf主要實現其他數據類型格式到字符串的轉化，memcpy主要是內存塊間的拷貝。
說明：strcpy、sprintf與memcpy都可以實現拷貝的功能，但是針對的對象不同，根據實際需求，來選擇合適的函數實現拷貝功能。
面試題8：鏈表與數組的區別
數組和鏈表有以下幾點不同：
（1）存儲形式：數組是一塊連續的空間，聲明時就要確定長度。鏈表是一塊可不連續的動態空間，長度可變，每個結點要保存相鄰結點指針。
（2）數據查找：數組的線性查找速度快，查找操作直接使用偏移地址。鏈表需要按順序檢索結點，效率低。
（3）數據插入或刪除：鏈表可以快速插入和刪除結點，而數組則可能需要大量數據移動。
（4）越界問題：鏈表不存在越界問題，數組有越界問題。
說明：在選擇數組或鏈表數據結構時，一定要根據實際需要進行選擇。數組便于查詢，鏈表便于插入刪除。數組節省空間但是長度固定，鏈表雖然變長但是占了更多的存儲空間。
面試題9：簡述隊列和棧的異同
隊列和棧都是線性存儲結構，但是兩者的插入和刪除數據的操作不同，隊列是“先進先出”，棧是“后進先出”。
注意：區別棧區和堆區。堆區的存取是“順序隨意”，而棧區是“后進先出”。棧由編譯器自動分配釋放 ，存放函數的參數值，局部變量的值等。其操作方式類似于數據結構中的棧。堆一般由程序員分配釋放， 若程序員不釋放，程序結束時可能由OS回收。分配方式類似于鏈表。
它與本題中的堆和棧是兩回事。堆棧只是一種數據結構，而堆區和棧區是程序的不同內存存儲區域。
面試題10：編碼實現直接插入排序
直接插入排序編程實現如下：
#include <stdio.h>
int main()
{
int i,temp,p;
int array[10] = {2,6,1,9,4,7,5,8,3,0};
printf("Display this array:\n");
for(i=0;i<10;i++)
{
printf("%d ",array[ i]);
}
for(i=1;i<10;i++)
{
temp = array[ i];
p = i-1;
while(p >= 0 && temp < array[p])
{
array[p+1] = array[p];
p--;
}
array[p+1] = temp;
}
printf("\n");
printf("After sorting,this array is:\n");
for(i=0;i<10;i++)
{
printf("%d ",array[ i]);
}
printf("\n");
return 0;
}
面試題11：編碼實現冒泡排序
冒泡排序編程實現如下：
#include <stdio.h> #define LEN 10
int main()
{
int a,i,j;
int ARRAY[10]={23,1,4,9,6,17,24,56,98,72};
printf("\n");
printf("Display this array:\n");
for(a=0;a<10;a++)
{
printf("%d ",ARRAY[a]);
}
printf("\n");
for(j=0;j<10;j++)
{
for(i=0;i<LEN-j-1;i++)
{
int temp;
if(ARRAY[ i]>ARRAY[i+1])
{
temp=ARRAY[i+1];
ARRAY[i+1]=ARRAY[ i];
ARRAY[ i]=temp;
}
}
}
printf("\nAfter sorting,the array is:\n");
for(a=0;a<LEN;a++)
{
printf("%d ",ARRAY[a]);
}
printf("\n");
return 0;
}
面試題12：編碼實現直接選擇排序
選擇排序實現代碼如下：
#include <stdio.h>
int main()
{
int i,j,t;
int array[10]={2,7,1,8,5,9,3,4,0,6};
printf("\nDisplay this array:\n");
for(i=0;i<10;i++)
{
printf("%d ",array[ i]);
}
printf("\n");
for(i=1;i<=9;i++)
{
int t = i-1;
for(j=i;j<10;j++)
{
if(array[j]<array[t])
{
t=j;
}
}
if(t!=(i-1))
{
int temp = 0;
temp=array[i-1];
array[i-1]=array[t];
array[t]=temp;
}
}
printf("After sorting,this array is:\n");
for(i=0;i<10;i++)
{
printf("%d ",array[ i]);
}
printf("\n");
return 0;
}
注：對比冒泡排序和選擇排序之間的區別
區別在于：冒泡算法，每次比較如果發現較小的元素在后面，就交換兩個相鄰的元素。而選擇排序算法的改進在于：先并不急于調換位置，先從A[1]開始逐個檢查，看哪個數最小就記下該數所在的位置P，等一躺掃描完畢，再把A[P]和A[1]對調，這時A[1]到A[10]中最小的數據就換到了最前面的位置
所以，選擇排序每掃描一遍數組，只需要一次真正的交換，而冒泡可能需要很多次。比較的次數是一樣的。
面試題13：typedef和define有什么區別
（1）用法不同：typedef用來定義一種數據類型的別名，增強程序的可讀性。define主要用來定義常量，以及書寫復雜使用頻繁的宏。
（2）執行時間不同：typedef是編譯過程的一部分，有類型檢查的功能。define是宏定義，是預編譯的部分，其發生在編譯之前，只是簡單的進行字符串的替換，不進行類型的檢查。
（3）作用域不同：typedef有作用域限定。define不受作用域約束，只要是在define聲明后的引用都是正確的。
（4）對指針的操作不同：typedef和define定義的指針時有很大的區別。
注意：typedef定義是語句，因為句尾要加上分號。而define不是語句，千萬不能在句尾加分號。
面試題14：關鍵字const是什么
const用來定義一個只讀的變量或對象。主要優點：便于類型檢查、同宏定義一樣可以方便地進行參數的修改和調整、節省空間，避免不必要的內存分配、可為函數重載提供參考。
說明：const修飾函數參數，是一種編程規范的要求，便于閱讀，一看即知這個參數不能被改變，實現時不易出錯。
面試題15：static有什么作用
static在C中主要用于定義全局靜態變量、定義局部靜態變量、定義靜態函數。在C++中新增了兩種作用：定義靜態數據成員、靜態函數成員。
注意：因為static定義的變量分配在靜態區，所以其定義的變量的默認值為0，普通變量的默認值為隨機數，在定義指針變量時要特別注意。
面試題16：extern有什么作用
extern標識的變量或者函數聲明其定義在別的文件中，提示編譯器遇到此變量和函數時在其它模塊中尋找其定義。
面試題17：簡述指針常量與常量指針區別
指針常量是指定義了一個指針，這個指針的值只能在定義時初始化，其他地方不能改變。其實指針常量是唯一的，即NULL；常量指針是指定義了一個指針，這個指針指向一個只讀的對象，不能通過常量指針來改變這個對象的值。
指針常量強調的是指針的不可改變性，而常量指針強調的是指針對其所指對象的不可改變性。
注意：無論是指針常量還是常量指針，其最大的用途就是作為函數的形式參數，保證實參在被調用函數中的不可改變特性。
面試題18：如何避免“野指針”
“野指針”產生原因及解決辦法如下：
（1）指針變量聲明時沒有被初始化。解決辦法：指針聲明時初始化，可以是具體的地址值，也可讓它指向NULL。
（2）指針 p 被 free 或者 delete 之后，沒有置為 NULL。解決辦法：指針指向的內存空間被釋放后指針應該指向NULL。
（3）指針操作超越了變量的作用范圍。解決辦法：在變量的作用域結束前釋放掉變量的地址空間并且讓指針指向NULL。
注意：“野指針”的解決方法也是編程規范的基本原則，平時使用指針時一定要避免產生“野指針”，在使用指針前一定要檢驗指針的合法性。
面試題19：用C編寫一個死循環程序
while() {
}
其實還有
for(;;)
說明：很多種途徑都可實現同一種功能，但是不同的方法時間和空間占用度不同，特別是對于嵌入式軟件，處理器速度比較慢，存儲空間較小，所以時間和空間優勢是選擇各種方法的首要考慮條件。
面試題20：編碼實現某一變量某位清0或置1
給定一個整型變量a，寫兩段代碼，第一個設置a的bit 3，第二個清a的bit 3，在以上兩個操作中，要保持其他位不變。
筆者認為，在對ARM寄存器操作時會經常用到這一塊，所以要注意這塊：
#define BIT3 (0x1 << 3 ) Satic int a; //設置a的bit 3: void set_bit3( void )
{
a |= BIT3; //將a第3位置1
} //清a的bit 3 void set_bit3( void )
{
a &= ~BIT3; //將a第3位清零
}
說明：在置或清變量或寄存器的某一位時，一定要注意不要影響其他位。所以用加減法是很難實現的。
還有一個就是保留某位：
//保留第k位 void set_bit3(void)
{
a &= BIT3;
}
面試題21：a=3,b=5,不用第三變量temp,對a和b的值進行交換
如果有第三者temp,a和b交換非常方便：
temp = a; a = b; b =temp;
若無temp,可以這樣做：
a = a + b;
b = a - b;a = a - b;
當然，我們可以利用C語言的位運算符：
a = 3;b = 5; a ^= b;
b ^= a; a ^= b;
原理是a ^ b ^ b == a; a ^ b == b ^ a;
面試題22：宏定義的用法，看下面這個程序，求出結果
#include <stdio.h> #define S(a,b) a*b
int main(void)
{ int n = 3; int m = 5;
printf("%d",S(n+m,m+n));
return 0;
}
這道題容易出現的錯誤結果是64，得到這個結果肯定是這樣理解的（3+5）*（5+3）。其實并不是，大家要理解宏定義的概念，宏定義只是簡單的符號替換，而不做其他處理，所以這里得到的結果是
3+5*5+3=31.
大家看看運行結果：
fs@ubuntu:~/qiang/hanshu$ gcc -o 1 1.c
fs@ubuntu:~/qiang/hanshu$ ./1
31
要想得到正確結果，應該怎么樣呢？應該這樣改，define s(a,b) (a)*(b),這樣才是正確結果；
fs@ubuntu:~/qiang/hanshu$ gcc -o 1 1.c
fs@ubuntu:~/qiang/hanshu$ ./1
64
大家記住這句話，宏定義只是簡單的符號替換！
面試題23：
C語言中，運算對象必須是整型數的運算符的有（）
A、% B、/ C、%和/ D、*
答案：A
取余對象必須是整數型
面試題24：
以下程序執行的結果是
#include <stdio.h>] #define N 2 #define M N+1 #define NUM (M+1)*M/2
void main()
{
pritf("%d",NUM);
}
A、5 B、6 C、8 D、9
答案：C
注意宏定義的使用，此處NUM = （3+1）*2+1/2 為8
1.new、delete、malloc、free關系
delete會調用對象的析構函數,和new對應free只會釋放內存，new調用構造函數。malloc與free是C++/C語言的標準庫函數，new/delete是C++的運算符。它們都可用于申請動態內存和釋放內存。對于非內部數據類型的對象而言，光用maloc/free無法滿足動態對象的要求。對象在創建的同時要自動執行構造函數，對象在消亡之前要自動執行析構函數。由于malloc/free是庫函數而不是運算符，不在編譯器控制權限之內，不能夠把執行構造函數和析構函數的任務強加于malloc/free。因此C++語言需要一個能完成動態內存分配和初始化工作的運算符new，以及一個能完成清理與釋放內存工作的運算符delete。注意new/delete不是庫函數。
2.delete與 delete []區別
delete只會調用一次析構函數，而delete[]會調用每一個成員的析構函數。在More Effective C++中有更為詳細的解釋：“當delete操作符用于數組時，它為每個數組元素調用析構函數，然后調用operator delete來釋放內存。”delete與new配套，delete []與new []配套
MemTest *mTest1=new MemTest[10];
MemTest *mTest2=new MemTest;
Int *pInt1=new int [10];
Int *pInt2=new int;
delete[]pInt1; //-1-
delete[]pInt2; //-2-
delete[]mTest1;//-3-
delete[]mTest2;//-4-
在-4-處報錯。
這就說明：對于內建簡單數據類型，delete和delete[]功能是相同的。對于自定義的復雜數據類型，delete和delete[]不能互用。delete[]刪除一個數組，delete刪除一個指針。簡單來說，用new分配的內存用delete刪除；用new[]分配的內存用delete[]刪除。delete[]會調用數組元素的析構函數。內部數據類型沒有析構函數，所以問題不大。如果你在用delete時沒用括號，delete就會認為指向的是單個對象，否則，它就會認為指向的是一個數組。
3.C++有哪些性質（面向對象特點）
封裝，繼承和多態。
4.子類析構時要調用父類的析構函數嗎？
析構函數調用的次序是先派生類的析構后基類的析構，也就是說在基類的的析構調用的時候,派生類的信息已經全部銷毀了。定義一個對象時先調用基類的構造函數、然后調用派生類的構造函數；析構的時候恰好相反：先調用派生類的析構函數、然后調用基類的析構函數。
5.多態，虛函數，純虛函數
多態：是對于不同對象接收相同消息時產生不同的動作。C++的多態性具體體現在運行和編譯兩個方面：在程序運行時的多態性通過繼承和虛函數來體現；
在程序編譯時多態性體現在函數和運算符的重載上；
虛函數：在基類中冠以關鍵字 virtual 的成員函數。 它提供了一種接口界面。允許在派生類中對基類的虛函數重新定義。
純虛函數的作用：在基類中為其派生類保留一個函數的名字，以便派生類根據需要對它進行定義。作為接口而存在 純虛函數不具備函數的功能，一般不能直接被調用。
從基類繼承來的純虛函數，在派生類中仍是虛函數。如果一個類中至少有一個純虛函數，那么這個類被稱為抽象類（abstract class）。
抽象類中不僅包括純虛函數，也可包括虛函數。抽象類必須用作派生其他類的基類，而不能用于直接創建對象實例。但仍可使用指向抽象類的指針支持運行時多態性。
6.求下面函數的返回值（微軟）
int func(x)
{
int countx = 0;
while(x)
{
countx ++;
x = x&(x-1);
}
return countx;
}
假定x = 9999。 答案：8
思路：將x轉化為2進制，看含有的1的個數。
7.什么是“引用”？申明和使用“引用”要注意哪些問題？
答：引用就是某個目標變量的“別名”(alias)，對應用的操作與對變量直接操作效果完全相同。申明一個引用的時候，切記要對其進行初始化。引用聲明完畢后，相當于目標變量名有兩個名稱，即該目標原名稱和引用名，不能再把該引用名作為其他變量名的別名。聲明一個引用，不是新定義了一個變量，它只表示該引用名是目標變量名的一個別名，它本身不是一種數據類型，因此引用本身不占存儲單元，系統也不給引用分配存儲單元。不能建立數組的引用。
8.將“引用”作為函數參數有哪些特點？
（1）傳遞引用給函數與傳遞指針的效果是一樣的。這時，被調函數的形參就成為原來主調函數中的實參變量或對象的一個別名來使用，所以在被調函數中對形參變量的操作就是對其相應的目標對象（在主調函數中）的操作。
（2）使用引用傳遞函數的參數，在內存中并沒有產生實參的副本，它是直接對實參操作；而使用一般變量傳遞函數的參數，當發生函數調用時，需要給形參分配存儲單元，形參變量是實參變量的副本；如果傳遞的是對象，還將調用拷貝構造函數。因此，當參數傳遞的數據較大時，用引用比用一般變量傳遞參數的效率和所占空間都好。
（3）使用指針作為函數的參數雖然也能達到與使用引用的效果，但是，在被調函數中同樣要給形參分配存儲單元，且需要重復使用"*指針變量名"的形式進行運算，這很容易產生錯誤且程序的閱讀性較差；另一方面，在主調函數的調用點處，必須用變量的地址作為實參。而引用更容易使用，更清晰。
9.在什么時候需要使用“常引用”？
如果既要利用引用提高程序的效率，又要保護傳遞給函數的數據不在函數中被改變，就應使用常引用。常引用聲明方式：const 類型標識符 &引用名=目標變量名；
例1
int a ;
const int &ra=a;
ra=1; //錯誤
a=1; //正確
例2
string foo( );
void bar(string & s);
那么下面的表達式將是非法的：
bar(foo( ));
bar("hello world");
原因在于foo( )和"hello world"串都會產生一個臨時對象，而在C++中，這些臨時對象都是const類型的。因此上面的表達式就是試圖將一個const類型的對象轉換為非const類型，這是非法的。引用型參數應該在能被定義為const的情況下，盡量定義為const 。
10.將“引用”作為函數返回值類型的格式、好處和需要遵守的規則?
格式：類型標識符 &函數名（形參列表及類型說明）{ //函數體 }
好處：在內存中不產生被返回值的副本；（注意：正是因為這點原因，所以返回一個局部變量的引用是不可取的。因為隨著該局部變量生存期的結束，相應的引用也會失效，產生runtime error!
注意事項：
（1）不能返回局部變量的引用。這條可以參照Effective C++[1]的Item 31。主要原因是局部變量會在函數返回后被銷毀，因此被返回的引用就成為了"無所指"的引用，程序會進入未知狀態。
（2）不能返回函數內部new分配的內存的引用。這條可以參照Effective C++[1]的Item 31。雖然不存在局部變量的被動銷毀問題，可對于這種情況（返回函數內部new分配內存的引用），又面臨其它尷尬局面。例如，被函數返回的引用只是作為一個臨時變量出現，而沒有被賦予一個實際的變量，那么這個引用所指向的空間（由new分配）就無法釋放，造成memory leak。
（3）可以返回類成員的引用，但最好是const。這條原則可以參照Effective C++[1]的Item 30。主要原因是當對象的屬性是與某種業務規則（business rule）相關聯的時候，其賦值常常與某些其它屬性或者對象的狀態有關，因此有必要將賦值操作封裝在一個業務規則當中。如果其它對象可以獲得該屬性的非常量引用（或指針），那么對該屬性的單純賦值就會破壞業務規則的完整性。
（4）流操作符重載返回值申明為“引用”的作用：
流操作符<<和>>，這兩個操作符常常希望被連續使用，例如：cout << "hello" << endl; 因此這兩個操作符的返回值應該是一個仍然支持這兩個操作符的流引用。可選的其它方案包括：返回一個流對象和返回一個流對象指針。但是對于返回一個流對象，程序必須重新（拷貝）構造一個新的流對象，也就是說，連續的兩個<<操作符實際上是針對不同對象的！這無法讓人接受。對于返回一個流指針則不能連續使用<<操作符。因此，返回一個流對象引用是惟一選擇。這個唯一選擇很關鍵，它說明了引用的重要性以及無可替代性，也許這就是C++語言中引入引用這個概念的原因吧。
賦值操作符=。這個操作符象流操作符一樣，是可以連續使用的，例如：x = j = 10;或者(x=10)=100;賦值操作符的返回值必須是一個左值，以便可以被繼續賦值。因此引用成了這個操作符的惟一返回值選擇。
＃include<iostream.h>
int &put(int n);
int vals[10];
int error=-1;
void main()
{
put(0)=10; //以put(0)函數值作為左值，等價于vals[0]=10;
put(9)=20; //以put(9)函數值作為左值，等價于vals[9]=20;
cout<<vals[0];
cout<<vals[9];
}
int &put(int n)
{
if (n>=0 && n<=9 ) return vals[n];
else { cout<<"subscript error"; return error; }
}
（5）在另外的一些操作符中，卻千萬不能返回引用：+-*/ 四則運算符。它們不能返回引用，Effective C++[1]的Item23詳細的討論了這個問題。主要原因是這四個操作符沒有side effect，因此，它們必須構造一個對象作為返回值，可選的方案包括：返回一個對象、返回一個局部變量的引用，返回一個new分配的對象的引用、返回一個靜態對象引用。根據前面提到的引用作為返回值的三個規則，第2、3兩個方案都被否決了。靜態對象的引用又因為((a+b) == (c+d))會永遠為true而導致錯誤。所以可選的只剩下返回一個對象了。
11、結構與聯合有和區別？
(1). 結構和聯合都是由多個不同的數據類型成員組成, 但在任何同一時刻, 聯合中只存放了一個被選中的成員（所有成員共用一塊地址空間）, 而結構的所有成員都存在（不同成員的存放地址不同）。
(2). 對于聯合的不同成員賦值, 將會對其它成員重寫, 原來成員的值就不存在了, 而對于結構的不同成員賦值是互不影響的。
12、試寫出程序結果：
int a=4;
int &f(int x)
{ a=a+x;
return a;
}
int main(void)
{ int t=5;
cout<<f(t)<<endl; a = 9
f(t)=20; a = 20
cout<<f(t)<<endl; t = 5,a = 20 a = 25
t=f(t); a = 30 t = 30
cout<<f(t)<<endl; } t = 60
}
13.重載（overload)和重寫(overried，有的書也叫做“覆蓋”）的區別？
常考的題目。從定義上來說：
重載：是指允許存在多個同名函數，而這些函數的參數表不同（或許參數個數不同，或許參數類型不同，或許兩者都不同）。
重寫：是指子類重新定義父類虛函數的方法。
從實現原理上來說：
重載：編譯器根據函數不同的參數表，對同名函數的名稱做修飾，然后這些同名函數就成了不同的函數（至少對于編譯器來說是這樣的）。如，有兩個同名函數：function func(p:integer):integer;和function func(p:string):integer;。那么編譯器做過修飾后的函數名稱可能是這樣的：int_func、str_func。對于這兩個函數的調用，在編譯器間就已經確定了，是靜態的。也就是說，它們的地址在編譯期就綁定了（早綁定），因此，重載和多態無關！
重寫：和多態真正相關。當子類重新定義了父類的虛函數后，父類指針根據賦給它的不同的子類指針，動態的調用屬于子類的該函數，這樣的函數調用在編譯期間是無法確定的（調用的子類的虛函數的地址無法給出）。因此，這樣的函數地址是在運行期綁定的（晚綁定）。
14.有哪幾種情況只能用intialization list 而不能用assignment?
答案：當類中含有const、reference 成員變量；基類的構造函數都需要初始化表。
15. C++是不是類型安全的？
答案：不是。兩個不同類型的指針之間可以強制轉換（用reinterpret cast)。C#是類型安全的。
16. main 函數執行以前，還會執行什么代碼？
答案：全局對象的構造函數會在main 函數之前執行。
17. 描述內存分配方式以及它們的區別?
1） 從靜態存儲區域分配。內存在程序編譯的時候就已經分配好，這塊內存在程序的整個運行期間都存在。例如全局變量，static 變量。
2） 在棧上創建。在執行函數時，函數內局部變量的存儲單元都可以在棧上創建，函數執行結束時這些存儲單元自動被釋放。棧內存分配運算內置于處理器的指令集。
3） 從堆上分配，亦稱動態內存分配。程序在運行的時候用malloc 或new 申請任意多少的內存，程序員自己負責在何時用free 或delete 釋放內存。動態內存的生存期由程序員決定，使用非常靈活，但問題也最多。
18.分別寫出BOOL,int,float,指針類型的變量a 與“零”的比較語句。
答案：
BOOL : if ( !a ) or if(a)
int : if ( a == 0)
float : const EXPRESSION EXP = 0.000001
if ( a < EXP && a >-EXP)
pointer : if ( a != NULL) or if(a == NULL)
19.請說出const與#define 相比，有何優點？
答案：
const作用：定義常量、修飾函數參數、修飾函數返回值三個作用。被Const修飾的東西都受到強制保護，可以預防意外的變動，能提高程序的健壯性。
1） const 常量有數據類型，而宏常量沒有數據類型。編譯器可以對前者進行類型安全檢查。而對后者只進行字符替換，沒有類型安全檢查，并且在字符替換可能會產生意料不到的錯誤。
2） 有些集成化的調試工具可以對const 常量進行調試，但是不能對宏常量進行調試。
20.簡述數組與指針的區別？
數組要么在靜態存儲區被創建（如全局數組），要么在棧上被創建。指針可以隨時指向任意類型的內存塊。
(1)修改內容上的差別
char a[] = “hello”;
a[0] = ‘X’;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘X’; // 編譯器不能發現該錯誤，運行時錯誤
(2) 用運算符sizeof 可以計算出數組的容量（字節數）。sizeof(p),p 為指針得到的是一個指針變量的字節數，而不是p 所指的內存容量。C++/C 語言沒有辦法知道指針所指的內存容量，除非在申請內存時記住它。注意當數組作為函數的參數進行傳遞時，該數組自動退化為同類型的指針。
char a[] = "hello world";
char *p = a;
cout<< sizeof(a) << endl; // 12 字節
cout<< sizeof(p) << endl; // 4 字節
計算數組和指針的內存容量
void Func(char a[100])
{
cout<< sizeof(a) << endl; // 4 字節而不是100 字節
}
第21題： int (*s[10])(int) 表示的是什么？
int (*s[10])(int) 函數指針數組，每個指針指向一個int func(int param)的函數。
第22題：棧內存與文字常量區
char str1[] = "abc";
char str2[] = "abc";
const char str3[] = "abc";
const char str4[] = "abc";
const char *str5 = "abc";
const char *str6 = "abc";
char *str7 = "abc";
char *str8 = "abc";
cout << ( str1 == str2 ) << endl;//0 分別指向各自的棧內存
cout << ( str3 == str4 ) << endl;//0 分別指向各自的棧內存
cout << ( str5 == str6 ) << endl;//1指向文字常量區地址相同
cout << ( str7 == str8 ) << endl;//1指向文字常量區地址相同
結果是：0 0 1 1
解答：str1,str2,str3,str4是數組變量，它們有各自的內存空間；而str5,str6,str7,str8是指針，它們指向相同的常量區域。
第23題：將程序跳轉到指定內存地址
要對絕對地址0x100000賦值，我們可以用(unsigned int*)0x100000 = 1234;那么要是想讓程序跳轉到絕對地址是0x100000去執行，應該怎么做？
*((void (*)( ))0x100000 ) ( );
首先要將0x100000強制轉換成函數指針,即:
(void (*)())0x100000
然后再調用它:
*((void (*)())0x100000)();
用typedef可以看得更直觀些:
typedef void(*)() voidFuncPtr;
*((voidFuncPtr)0x100000)();
第24題：int id[sizeof(unsigned long)];這個對嗎？為什么？
答案:正確 這個 sizeof是編譯時運算符，編譯時就確定了 ,可以看成和機器有關的常量。
第25題：引用與指針有什么區別？
【參考答案】
1) 引用必須被初始化，指針不必。
2) 引用初始化以后不能被改變，指針可以改變所指的對象。
3) 不存在指向空值的引用，但是存在指向空值的指針。
第26題：const 與 #define 的比較 ，const有什么優點?
【參考答案】
（1） const 常量有數據類型，而宏常量沒有數據類型。編譯器可以對前者進行類型安全檢查。而對后者只進行字符替換，沒有類型安全檢查，并且在字符替換可能會產生意料不到的錯誤（邊際效應） 。
（2） 有些集成化的調試工具可以對 const 常量進行調試，但是不能對宏常量進行調試。
第27題：復雜聲明
void * ( * (*fp1)(int))[10];
float (*(* fp2)(int,int,int))(int);
int (* ( * fp3)())[10]();
分別表示什么意思？案】
1.void * ( * (*fp1)(int))[10]; fp1是一個指針，指向一個函數，這個函數的參數為int型，函數的返回值是一個指針，這個指針指向一個數組，這個數組有10個元素，每個元素是一個void*型指針。
2.float (*(* fp2)(int,int,int))(int); fp2是一個指針，指向一個函數，這個函數的參數為3個int型，函數的返回值是一個指針，這個指針指向一個函數，這個函數的參數為int型，函數的返回值是float型。
3.int (* ( * fp3)())[10](); fp3是一個指針，指向一個函數，這個函數的參數為空，函數的返回值是一個指針，這個指針指向一個數組，這個數組有10個元素，每個元素是一個指針，指向一個函數，這個函數的參數為空，函數的返回值是int型。
第28題：內存的分配方式有幾種?
【參考答案】
一、從靜態存儲區域分配。內存在程序編譯的時候就已經分配好，這塊內存在程序的整個運行期間都存在。例如全局變量。
二、在棧上創建。在執行函數時，函數內局部變量的存儲單元都可以在棧上創建，函數執行結束時這些存儲單元自動被釋放。棧內存分配運算內置于處理器的指令集中，效率很高，但是分配的內存容量有限。
三、從堆上分配，亦稱動態內存分配。程序在運行的時候用malloc或new申請任意多少的內存，程序員自己負責在何時用free或delete釋放內存。動態內存的生存期由我們決定，使用非常靈活，但問題也最多。
第29題：基類的析構函數不是虛函數，會帶來什么問題？
【參考答案】派生類的析構函數用不上，會造成資源的泄漏。
第30題：全局變量和局部變量有什么區別？是怎么實現的？操作系統和編譯器是怎么知道的？
【參考答案】
生命周期不同：
全局變量隨主程序創建和創建，隨主程序銷毀而銷毀；局部變量在局部函數內部，甚至局部循環體等內部存在，退出就不存在；
使用方式不同：通過聲明后全局變量程序的各個部分都可以用到；局部變量只能在局部使用；分配在棧區。
操作系統和編譯器通過內存分配的位置來知道的，全局變量分配在全局數據段并且在程序開始運行的時候被加載。局部變量則分配在堆棧里面 。
完整的Word格式文檔51黑下載地址：
C 面試.docx
(51.63 KB, 下載次數: 14)
2018-10-25 17:55 上傳
點擊文件名下載附件
C面試題及答案
|
