文章目錄
前言
new、delete、malloc、free關系
delete與 delete []區別
C和C++ 的共同點？不同之處？
繼承的優缺點
C++有哪些性質（面向對象特點）
子類析構時要調用父類的析構函數嗎？
多態，虛函數，純虛函數
求下面函數的返回值（微軟）
什么是“引用”？申明和使用“引用”要注意哪些問題？
將“引用”作為函數參數有哪些特點？
在什么時候需要使用“常引用”？
將“引用”作為函數返回值類型的格式的好處和需要遵守的規則?
“引用”與多態的關系？
“引用”與指針的區別是什么？
什么時候需要“引用”？
結構與聯合有和區別？
面關于“聯合”的題目的輸出？
關聯、聚合(Aggregation)以及組合(Composition)的區別？
面向對象的三個基本特征，并簡單敘述之？
重載（overload)和重寫(overried，有的書也叫做“覆蓋”）的區別？
多態的作用？
Ado與Ado.net的相同與不同？
New delete 與malloc free 的聯系與區別?
#define DOUBLE(x) x+x ，i = 5*DOUBLE(5)； i 是多少？
有哪幾種情況只能用intialization list 而不能用assignment?
C++是不是類型安全的？
main 函數執行以前，還會執行什么代碼？
描述內存分配方式以及它們的區別?
struct 和 class 的區別
當一個類A 中沒有任何成員變量與成員函數,這時sizeof(A)的值是多少？如果不是零，請解釋一下編譯器為什么沒有讓它為零。
在8086 匯編下，邏輯地址和物理地址是怎樣轉換的？（Intel）
比較C++中的4種類型轉換方式？
分別寫出BOOL,int,float,指針類型的變量a 與“零”的比較語句。
請說出const與#define 相比，有何優點？
簡述數組與指針的區別？
類成員函數的重載、覆蓋和隱藏區別？
求出兩個數中的較大者
如何打印出當前源文件的文件名以及源文件的當前行號？
main 主函數執行完畢后，是否可能會再執行一段代碼，給出說明？
如何判斷一段程序是由C 編譯程序還是由C++編譯程序編譯的？
文件中有一組整數，要求排序后輸出到另一個文件中
鏈表題：一個鏈表的結點結構
分析一下這段程序的輸出 (Autodesk)
寫一個函數找出一個整數數組中，第二大的數 （microsoft）
寫一個在一個字符串(n)中尋找一個子串(m)第一個位置的函數。
多重繼承的內存分配問題：
如何判斷一個單鏈表是有環的？（注意不能用標志位，最多只能用兩個額外指針）
指針找錯題
如果編寫一個標準strcpy函數
String 的具體實現
h頭文件中的ifndef/define/endif 的作用？
在C++ 程序中調用被C 編譯器編譯后的函數，為什么要加extern “C”？
幾道c筆試題(含參考答案)
Sony筆試題
請你分別畫出OSI的七層網絡結構圖和TCP/IP的五層結構圖。
請你詳細地解釋一下IP協議的定義，在哪個層上面？主要有什么作用？TCP與UDP呢 ？
請問交換機和路由器各自的實現原理是什么？分別在哪個層次上面實現的？
全局變量和局部變量有什么區別？是怎么實現的？操作系統和編譯器是怎么知道的 ？
8086是多少位的系統？在數據總線上是怎么實現的？
解釋局部變量、全局變量和靜態變量的含義。
論述含參數的宏與函數的優缺點。
Windows程序的入口是哪里？寫出Windows消息機制的流程。
C++里面是不是所有的動作都是main()引起的？如果不是，請舉例。
如何定義和實現一個類的成員函數為回調函數？
解釋堆和棧的區別。
C++里面如何聲明const void f(void)函數為C程序中的庫函數？
下列哪兩個是等同的
內聯函數在編譯時是否做參數類型檢查？
static有什么用途？（請至少說明兩種）
引用與指針有什么區別？
描述實時系統的基本特性
全局變量和局部變量在內存中是否有區別？如果有，是什么區別？
什么是平衡二叉樹？
堆棧溢出一般是由什么原因導致的？
什么函數不能聲明為虛函數？
冒泡排序算法的時間復雜度是什么？
寫出float x 與“零值”比較的if語句。
Internet采用哪種網絡協議？該協議的主要層次結構？
Internet物理地址和IP地址轉換采用什么協議？
IP地址的編碼分為哪倆部分？
用戶輸入M,N值，從1至N開始順序循環數數，每數到M輸出該數值，直至全部輸出。寫出C程序。
不能做switch()的參數類型是：
局部變量能否和全局變量重名？
如何引用一個已經定義過的全局變量？
全局變量可不可以定義在可被多個.C文件包含的頭文件中？為什么？
語句for( ；1 ；)有什么問題？它是什么意思？
do……while和while……do有什么區別？
請寫出下列代碼的輸出內容
static 全局變量、局部變量、函數與普通全局變量、局部變量、函數
設有以下說明和定義：
-1,2,7,28,,126請問28和126中間那個數是什么？為什么？
用兩個棧實現一個隊列的功能？要求給出算法和思路！
在c語言庫函數中將一個字符轉換成整型的函數是atool()嗎，這個函數的原型是什么？
對于一個頻繁使用的短小函數,在C語言中應用什么實現,在C++中應用什么實現?
用預處理指令#define 聲明一個常數，用以表明1年中有多少秒（忽略閏年問題）
寫一個“標準”宏MIN，這個宏輸入兩個參數并返回較小的一個。
預處理器標識#error的目的是什么？
嵌入式系統中經常要用到無限循環，你怎么樣用C編寫死循環呢？
用變量a給出下面的定義
關鍵字static的作用是什么？
關鍵字const是什么含意？
關鍵字volatile有什么含意 并給出三個不同的例子。
位操作（Bit manipulation）
下面的代碼輸出是什么，為什么？
C語言同意一些令人震驚的結構,下面的結構是合法的嗎，如果是它做些什么？
線形表a、b為兩個有序升序的線形表，編寫一程序，使兩個有序線形表合并成一個有序升序線形表h；
用遞歸算法判斷數組a[N]是否為一個遞增數組。
編寫算法，從10億個浮點數當中，選出其中最大的10000個。
編寫一unix程序，防止僵尸進程的出現.
可怕的題目終于來了
判斷字符串是否為回文
ASDL使用的是什么協議？并進行簡單描述？
Static 作用是什么
什么是預編譯,何時需要預編譯?
進程和線程的區別
插入排序和選擇排序
運算符優先級問題
字符串倒序
交換兩個數的宏定義
Itearator各指針的區別
C++中的class和struct的區別
有關重載函數
數據庫與T-SQL語言
關系模型的基本概念
SQL語言概述
C語言中結構化程序設計的三種基本控制結構
CVS是什么
三種基本的數據模型
設計模式：工廠模式 和 單例模式 介紹一下？
vector 和 list的區別？
1、概念：
1）Vector
2、List
2、區別：
3、應用
純虛函數是怎樣實現的？在編譯原理上講一下？
抽象類為什么不能實例化？
在函數后面加個const是怎么理解的？
進程間通信類型：
關于內存對齊的問題以及sizof()的輸出
winsock建立連接的主要實現步驟?
C++中為什么用模板類。
動態連接庫的兩種方式?
CSingleLock是干什么的。
編寫strcat函數(6分)
編寫類String 的構造函數、析構函數和賦值函數（25 分）
前言
本文參考《C++面試寶典》，增加部分知識點，并修正寶典中的部分錯誤以及補充部分參考回答。

new、delete、malloc、free關系
delete會調用對象的析構函數,和malloc對應free只會釋放內存；
new調用構造函數。
malloc與free是C++/C語言的標準庫函數，new/delete是C++的運算符。
它們都可用于申請動態內存和釋放內存。
對于非內部數據類型的對象而言，光用maloc/free無法滿足動態對象的要求。對象在創建的同時要自動執行構造函數，對象在消亡之前要自動執行析構函數。由于malloc/free是庫函數而不是運算符，不在編譯器控制權限之內，不能夠把執行構造函數和析構函數的任務強加于malloc/free。因此C++語言需要一個能完成動態內存分配和初始化工作的運算符new，以及一個能完成清理與釋放內存工作的運算符delete。注意new/delete不是庫函數。
參考回答：首先，new/delete是C++的關鍵字，而malloc/free是C語言的庫函數，后者使用必須指明申請內存空間的大小，對于類類型的對象，后者不會調用構造函數和析構函數

delete與 delete []區別
delete只會調用一次析構函數，而delete[]會調用每一個成員的析構函數。
在MoreEffective C++中有更為詳細的解釋：“當delete操作符用于數組時，它為每個數組元素調用析構函數，然后調用operatordelete來釋放內存。”，delete與New配套，delete[]與new []配套
如下例：

?MemTest*mTest1=newMemTest[10];
?MemTest*mTest2=newMemTest;
?int*pInt1=newint[10];
?int*pInt2=newint;
?delete[]pInt1; ?//-1-
?delete[]pInt2; ?//-2-
?delete[]mTest1;//-3-
?delete[]mTest2;//-4-
1
2
3
4
5
6
7
8
在-4-處報錯。

這就說明：對于內建簡單數據類型，delete和delete[]功能是相同的。對于自定義的復雜數據類型，delete和delete[]不能互用。delete[]刪除一個數組，delete刪除一個指針簡單來說，用new分配的內存用delete刪除用new[]分配的內存用delete[]刪除delete[]會調用數組元素的析構函數。內部數據類型沒有析構函數，所以問題不大。如果你在用delete時沒用括號，delete就會認為指向的是單個對象，否則，它就會認為指向的是一個數組。

C和C++ 的共同點？不同之處？
設計思想上：C++是面向對象的語言，而C是面向過程的結構化編程語言
語法上：
C++具有封裝、繼承和多態三種特性
C++相比C，增加多許多類型安全的功能，比如強制類型轉換、
C++支持范式編程，比如模板類、函數模板等
繼承的優缺點
優點：類繼承是在編譯時刻靜態定義的，且可直接使用，類繼承可以較方便地改變父類的實現。
缺點：

首先，因為繼承在編譯時刻就定義了，所以無法在運行時刻改變從父類繼承的實現。
其次，父類通常至少定義了子類的部分行為，父類的任何改變都可能影響子類的行為。如果繼承下來的實現不適合解決新的問題，則父類必須重寫或被其他更適合的類替換。這種依賴關系限制了靈活性并最終限制了復用性。
C++有哪些性質（面向對象特點）
封裝，繼承和多態。
在面向對象程序設計語言中，封裝是利用可重用成分構造軟件系統的特性，它不僅支持系統的可重用性，而且還有利于提高系統的可擴充性；消息傳遞可以實現發送一個通用的消息而調用不同的方法；封裝是實現信息隱蔽的一種技術，其目的是使類的定義和實現分離。

子類析構時要調用父類的析構函數嗎？
析構函數調用的次序是先派生類的析構后基類的析構，也就是說在基類的的析構調用的時候,派生類的信息已經全部銷毀了定義一個對象時先調用基類的構造函數、然后調用派生類的構造函數；析構的時候恰好相反：先調用派生類的析構函數、然后調用基類的析構函數JAVA無析構函數深拷貝和淺拷貝

多態，虛函數，純虛函數
多態：是對于不同對象接收相同消息時產生不同的動作。C++的多態性具體體現在運行和編譯兩個方面：在程序運行時的多態性通過繼承和虛函數來體現；
在程序編譯時多態性體現在函數和運算符的重載上
虛函數：在基類中冠以關鍵字 virtual 的成員函數。 它提供了一種接口界面。允許在派生類中對基類的虛函數重新定義。
純虛函數的作用：在基類中為其派生類保留一個函數的名字，以便派生類根據需要對它進行定義。作為接口而存在 純虛函數不具備函數的功能，一般不能直接被調用。
從基類繼承來的純虛函數，在派生類中仍是虛函數。如果一個類中至少有一個純虛函數，那么這個類被稱為抽象類（abstractclass）。
抽象類中不僅包括純虛函數，也可包括虛函數。l抽象類必須用作派生其他類的基類，而不能用于直接創建對象實例。但仍可使用指向抽象類的指針支持運行時多態性。

求下面函數的返回值（微軟）
int func(x)
{
? ? int countx = 0;
? ? while(x)
? ? {
? ? ? ? ? countx ++;
? ? ? ? ? x = x&(x-1);
? ? ?}
? ? return countx;
}
1
2
3
4
5
6
7
8
9
10
假定x = 9999。 答案：8

思路：將x轉化為2進制，看含有的1的個數。

什么是“引用”？申明和使用“引用”要注意哪些問題？
引用就是某個目標變量的“別名”(alias)，對應用的操作與對變量直接操作效果完全相同。
注意問題：
申明一個引用的時候，切記要對其進行初始化。
引用聲明完畢后，相當于目標變量名有兩個名稱，即該目標原名稱和引用名，不能再把該引用名作為其他變量名的別名。
聲明一個引用，不是新定義了一個變量，它只表示該引用名是目標變量名的一個別名，它本身不是一種數據類型，因此引用本身不占存儲單元，系統也不給引用分配存儲單元。
不能建立數組的引用。
將“引用”作為函數參數有哪些特點？
傳遞引用給函數與傳遞指針的效果是一樣的。這時，被調函數的形參就成為原來主調函數中的實參變量或對象的一個別名來使用，所以在被調函數中對形參變量的操作就是對其相應的目標對象（在主調函數中）的操作。
使用引用傳遞函數的參數，在內存中并沒有產生實參的副本，它是直接對實參操作；而使用一般變量傳遞函數的參數，當發生函數調用時，需要給形參分配存儲單元，形參變量是實參變量的副本；如果傳遞的是對象，還將調用拷貝構造函數。因此，當參數傳遞的數據較大時，用引用比用一般變量傳遞參數的效率和所占空間都好。
使用指針作為函數的參數雖然也能達到與使用引用的效果，但是，在被調函數中同樣要給形參分配存儲單元，且需要重復使用"*指針變量名"的形式進行運算，這很容易產生錯誤且程序的閱讀性較差；另一方面，在主調函數的調用點處，必須用變量的地址作為實參。而引用更容易使用，更清晰。
在什么時候需要使用“常引用”？
如果既要利用引用提高程序的效率，又要保護傳遞給函數的數據不在函數中被改變，就應使用常引用。常引用聲明方式：const類型標識符 &引用名=目標變量名；
例1

int a ;
const int &ra=a;
ra=1; //錯誤
a=1; //正確
1
2
3
4
例2

string foo( );
void bar(string & s);
1
2
那么下面的表達式將是非法的：

bar(foo( ));
bar("hello world");
1
2
原因在于foo( )和"helloworld"串都會產生一個臨時對象，而在C++中，這些臨時對象都是const類型的。因此上面的表達式就是試圖將一個const類型的對象轉換為非const類型，這是非法的。引用型參數應該在能被定義為const的情況下，盡量定義為const 。

將“引用”作為函數返回值類型的格式的好處和需要遵守的規則?
格式：類型標識符 &函數名（形參列表及類型說明）{//函數體 }

好處：在內存中不產生被返回值的副本；（注意：正是因為這點原因，所以返回一個局部變量的引用是不可取的。因為隨著該局部變量生存期的結束，相應的引用也會失效，產生runtimeerror!
注意事項：
不能返回局部變量的引用。這條可以參照EffectiveC++[1]的Item 31。主要原因是局部變量會在函數返回后被銷毀，因此被返回的引用就成為了"無所指"的引用，程序會進入未知狀態。
不能返回函數內部new分配的內存的引用。這條可以參照Effective C++[1]的Item 31。雖然不存在局部變量的被動銷毀問題，可對于這種情況（返回函數內部new分配內存的引用），又面臨其它尷尬局面。例如，被函數返回的引用只是作為一個臨時變量出現，而沒有被賦予一個實際的變量，那么這個引用所指向的空間（由new分配）就無法釋放，造成memory leak。
可以返回類成員的引用，但最好是const。這條原則可以參照Effective C++[1]的Item 30。主要原因是當對象的屬性是與某種業務規則（business rule）相關聯的時候，其賦值常常與某些其它屬性或者對象的狀態有關，因此有必要將賦值操作封裝在一個業務規則當中。如果其它對象可以獲得該屬性的非常量引用（或指針），那么對該屬性的單純賦值就會破壞業務規則的完整性。
流操作符重載返回值申明為“引用”的作用：
流操作符<<和>>，這兩個操作符常常希望被連續使用，
例如：
cout<< "hello" << endl;　
1
因此這兩個操作符的返回值應該是一個仍然支持這兩個操作符的流引用。可選的其它方案包括：返回一個流對象和返回一個流對象指針。但是對于返回一個流對象，程序必須重新（拷貝）構造一個新的流對象，也就是說，連續的兩個<<操作符實際上是針對不同對象的！這無法讓人接受。對于返回一個流指針則不能連續使用<<操作符。因此，返回一個流對象引用是惟一選擇。這個唯一選擇很關鍵，它說明了引用的重要性以及無可替代性，也許這就是C++語言中引入引用這個概念的原因吧。 賦值操作符=。這個操作符象流操作符一樣，是可以連續使用的，例如：x = j= 10;或者(x=10)=100;賦值操作符的返回值必須是一個左值，以便可以被繼續賦值。因此引用成了這個操作符的惟一返回值選擇。
例3
#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;
?? ?}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
在另外的一些操作符中，卻千萬不能返回引用：±*/四則運算符。它們不能返回引用，Effective C++[1]的Item23詳細的討論了這個問題。主要原因是這四個操作符沒有side effect，因此，它們必須構造一個對象作為返回值，可選的方案包括：返回一個對象、返回一個局部變量的引用，返回一個new分配的對象的引用、返回一個靜態對象引用。根據前面提到的引用作為返回值的三個規則，第2、3兩個方案都被否決了。靜態對象的引用又因為((a+b) == (c+d))會永遠為true而導致錯誤。所以可選的只剩下返回一個對象了。
“引用”與多態的關系？
引用是除指針外另一個可以產生多態效果的手段。這意味著，一個基類的引用可以指向它的派生類實例。
例4：

Class A;?
Class B :Class A
{
?? ?...
}; ?
B b;?
A& ref = b;
1
2
3
4
5
6
7
“引用”與指針的區別是什么？
指針有自己的一塊空間，而引用只是一個別名；
使用sizeof看一個指針的大小是4，而引用則是被引用對象的大小； + 指針可以被初始化為NULL，而引用必須被初始化且必須是一個已有對象 的引用；
作為參數傳遞時，指針需要被解引用才可以對對象進行操作，而直接對引 用的修改都會改變引用所指向的對象；
可以有const指針，但是沒有const引用；
指針在使用中可以指向其它對象，但是引用只能是一個對象的引用，不能 被改變；
指針可以有多級指針（**p），而引用至于一級；
指針和引用使用++運算符的意義不一樣；
如果返回動態內存分配的對象或者內存，必須使用指針，引用可能引起內存泄露。
指針通過某個指針變量指向一個對象后，對它所指向的變量間接操作。程序中使用指針，程序的可讀性差；而引用本身就是目標變量的別名，對引用的操作就是對目標變量的操作。此外，就是上面提到的對函數傳ref和pointer的區別。
什么時候需要“引用”？
流操作符<<和>>、賦值操作符=的返回值、拷貝構造函數的參數、賦值操作符=的參數、其它情況都推薦使用引用。

結構與聯合有和區別？
結構和聯合都是由多個不同的數據類型成員組成, 但在任何同一時刻, 聯合中只存放了一個被選中的成員（所有成員共用一塊地址空間）, 而結構的所有成員都存在（不同成員的存放地址不同）。
對于聯合的不同成員賦值,將會對其它成員重寫, 原來成員的值就不存在了, 而對于結構的不同成員賦值是互不影響的。
面關于“聯合”的題目的輸出？
a)

#include <stdio.h>
union
{
?? ?int i;
?? ?char x[2];
}a;

void main()
{
?? ?a.x[0] = 10;
?? ?a.x[1] = 1;
?? ?printf("%d",a.i);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
答案：266 (低位低地址，高位高地址，內存占用情況是Ox010A）

a.x[0]?? ?10
a.x[1]?? ?1
char占用一個字節，8位：
a.x[0]轉化為二進制就為00001010

0?? ?0?? ?0?? ?0?? ?1?? ?0?? ?1?? ?0
a.x[1]轉化為二進制就為00000001

0?? ?0?? ?0?? ?0?? ?0?? ?0?? ?0?? ?1
最終就是：0000 0001 0000 1010
十六進制為：0x010A
十進制為：266
b)

main()
{
?? ?union{ ? ? ? ? ? ? ? ? ? /*定義一個聯合*/
?? ??? ?int i;
?? ??? ?struct
?? ??? ??? ?{ ? ? ? ? ? ? /*在聯合中定義一個結構*/
?? ??? ??? ??? ?char first;
?? ??? ??? ??? ?char second;
?? ??? ??? ?}half;
?? ??? ?}number;
?? ?number.i=0x4241; ? ? ? ? /*聯合成員賦值*/
?? ?printf("%c%cn",number.half.first, mumber.half.second);
?? ?number.half.first='a'; ? /*聯合中結構成員賦值*/
?? ?number.half.second='b';
?? ?printf("%xn", number.i);
?? ?getch();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
答案： AB (0x41對應’A’,是低位；Ox42對應’B’,是高位）
6261 (number.i和number.half共用一塊地址空間）

關聯、聚合(Aggregation)以及組合(Composition)的區別？
涉及到UML中的一些概念：關聯是表示兩個類的一般性聯系，比如“學生”和“老師”就是一種關聯關系；聚合表示has-a的關系，是一種相對松散的關系，聚合類不需要對被聚合類負責，如下圖所示，用空的菱形表示聚合關系：從實現的角度講，聚合可以表示為:

class A?
{
?? ?...
} ?
class B
{?
?? ?A* a;
??? ?.....
}
1
2
3
4
5
6
7
8
9
而組合表示contains-a的關系，關聯性強于聚合：組合類與被組合類有相同的生命周期，組合類要對被組合類負責，采用實心的菱形表示組合關系：實現的形式是:

class A
{
?? ?...
}
class B
{
?? ?A a;
?? ?...
}
1
2
3
4
5
6
7
8
9
面向對象的三個基本特征，并簡單敘述之？
封裝：將客觀事物抽象成類，每個類對自身的數據和方法實行protection(private,protected,public)
繼承：廣義的繼承有三種實現形式：實現繼承（指使用基類的屬性和方法而無需額外編碼的能力）、可視繼承（子窗體使用父窗體的外觀和實現代碼）、接口繼承（僅使用屬性和方法，實現滯后到子類實現）。前兩種（類繼承）和后一種（對象組合=>接口繼承以及純虛函數）構成了功能復用的兩種方式。
多態：是將父對象設置成為和一個或更多的他的子對象相等的技術，賦值之后，父對象就可以根據當前賦值給它的子對象的特性以不同的方式運作。簡單的說，就是一句話：允許將子類類型的指針賦值給父類類型的指針。
重載（overload)和重寫(overried，有的書也叫做“覆蓋”）的區別？
常考的題目。從定義上來說：
重載：是指允許存在多個同名函數，而這些函數的參數表不同（或許參數個數不同，或許參數類型不同，或許兩者都不同）。
重寫：是指子類重新定義父類虛函數的方法。
從實現原理上來說：
重載：編譯器根據函數不同的參數表，對同名函數的名稱做修飾，然后這些同名函數就成了不同的函數（至少對于編譯器來說是這樣的）。如，有兩個同名函數：functionfunc(p:integer):integer;和functionfunc(p:string):integer;。那么編譯器做過修飾后的函數名稱可能是這樣的：int_func、str_func。對于這兩個函數的調用，在編譯器間就已經確定了，是靜態的。也就是說，它們的地址在編譯期就綁定了（早綁定），因此，重載和多態無關！
重寫：和多態真正相關。當子類重新定義了父類的虛函數后，父類指針根據賦給它的不同的子類指針，動態的調用屬于子類的該函數，這樣的函數調用在編譯期間是無法確定的（調用的子類的虛函數的地址無法給出）。因此，這樣的函數地址是在運行期綁定的（晚綁定）。
多態的作用？
主要是兩個：

隱藏實現細節，使得代碼能夠模塊化；擴展代碼模塊，實現代碼重用；
接口重用：為了類在繼承和派生的時候，保證使用家族中任一類的實例的某一屬性時的正確調用。
Ado與Ado.net的相同與不同？
除了“能夠讓應用程序處理存儲于DBMS中的數據“這一基本相似點外，兩者沒有太多共同之處。但是Ado使用OLE DB 接口并基于微軟的COM技術，而ADO.NET 擁有自己的ADO.NET 接口并且基于微軟的.NET體系架構。眾所周知.NET 體系不同于COM 體系，ADO.NET接口也就完全不同于ADO和OLE DB 接口，這也就是說ADO.NET和ADO是兩種數據訪問方式。ADO.net 提供對XML的支持。

New delete 與malloc free 的聯系與區別?
答案：都是在堆(heap)上進行動態的內存操作。用malloc函數需要指定內存分配的字節數并且不能初始化對象，new 會自動調用對象的構造函數。delete 會調用對象的destructor，而free 不會調用對象的destructor.

#define DOUBLE(x) x+x ，i = 5*DOUBLE(5)； i 是多少？
答案：i 為30。

有哪幾種情況只能用intialization list 而不能用assignment?
答案：當類中含有const、reference成員變量；基類的構造函數都需要初始化表。

C++是不是類型安全的？
答案：不是。兩個不同類型的指針之間可以強制轉換（用reinterpret cast)。C#是類型安全的。

main 函數執行以前，還會執行什么代碼？
答案：全局對象的構造函數會在main 函數之前執行。

描述內存分配方式以及它們的區別?
從靜態存儲區域分配。內存在程序編譯的時候就已經分配好，這塊內存在程序的整個運行期間都存在。例如全局變量，static變量。
在棧上創建。在執行函數時，函數內局部變量的存儲單元都可以在棧上創建，函數執行結束時這些存儲單元自動被釋放。棧內存分配運算內置于處理器的指令集。
從堆上分配，亦稱動態內存分配。程序在運行的時候用malloc 或new 申請任意多少的內存，程序員自己負責在何時用free 或delete 釋放內存。動態內存的生存期由程序員決定，使用非常靈活，但問題也最多。
struct 和 class 的區別
參考答案：在C++中，可以用struct和class定義類，都可以繼承。區別在于：struct的默認繼承權限和默認訪問權限是public，而class的默認繼承權限和默認訪問權限是private。
另外，class還可以定義模板類形參，比如template <class T, int i>。

當一個類A 中沒有任何成員變量與成員函數,這時sizeof(A)的值是多少？如果不是零，請解釋一下編譯器為什么沒有讓它為零。
sizeof(A) = 1。編譯器不允許一個類的大小為0。那是被編譯器插進去的一個char ，使得這個class的不同實體（object）在內存中配置獨一無二的地址。 也就是說這個char是用來標識類的不同對象的。肯定不是零。舉個反例，如果是零的話，聲明一個class A[10]對象數組，而每一個對象占用的空間是零，這時就沒辦法區分A[0],A[1]…了。

在8086 匯編下，邏輯地址和物理地址是怎樣轉換的？（Intel）
答案：通用寄存器給出的地址，是段內偏移地址，相應段寄存器地址*10H+通用寄存器內地址，就得到了真正要訪問的地址。

比較C++中的4種類型轉換方式？
C++中四種類型轉換是：static_cast, dynamic_cast, const_cast, reinterpret_cast

const_cast
用于將const變量轉為非const
static_cast
用于各種隱式轉換，比如非const轉const，void*轉指針等, static_cast能用于多態向上轉化，如果向下轉能成功但是不安全，結果未知；
dynamic_cast
用于動態類型轉換。只能用于含有虛函數的類，用于類層次間的向上和向下轉化。只能轉指針或引用。向下轉化時，如果是非法的對于指針返回NULL，對于引用拋異常。要深入了解內部轉換的原理。
向上轉換：指的是子類向基類的轉換
向下轉換：指的是基類向子類的轉換
它通過判斷在執行到該語句的時候變量的運行時類型和要轉換的類型是否相同來判斷是否能夠進行向下轉換。
reinterpret_cast
幾乎什么都可以轉，比如將int轉指針，可能會出問題，盡量少用；
分別寫出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)
1
2
3
4
5
請說出const與#define 相比，有何優點？
Const作用：定義常量、修飾函數參數、修飾函數返回值三個作用。被Const修飾的東西都受到強制保護，可以預防意外的變動，能提高程序的健壯性。

const 常量有數據類型，而宏常量沒有數據類型。編譯器可以對前者進行類型安全檢查。而對后者只進行字符替換，沒有類型安全檢查，并且在字符替換可能會產生意料不到的錯誤。
有些集成化的調試工具可以對const常量進行調試，但是不能對宏常量進行調試。
簡述數組與指針的區別？
數組?? ?指針
保存數據?? ?保存數據的地址
直接訪問數據?? ?間接訪問數據，首先獲得指針的內容，然后將其作為地址，從該地址中提取數據
隱式的分配和刪除?? ?通常用于動態的數據結構
通常用于固定數目且數據類型相同的元素?? ?通過Malloc分配內存，free釋放內存
自身即為數據名?? ?通常指向匿名數據，操作匿名函數
數組要么在靜態存儲區被創建（如全局數組），要么在棧上被創建。
指針可以隨時指向任意類型的內存塊。
(1)修改內容上的差別
char a[] = “hello”;
a[0] = ‘X’;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘X’; // 編譯器不能發現該錯誤，運行時錯誤
1
2
3
4
(2) 用運算符sizeof 可以計算出數組的容量（字節數）。sizeof§,p 為指針得到的是一個指針變量的字節數，而不是p 所指的內存容量。C++/C 語言沒有辦法知道指針所指的內存容量，除非在申請內存時記住它。注意當數組作為函數的參數進行傳遞時，該數組自動退化為同類型的指針。

char a[] = "hello world";
char *p = a;
cout<< sizeof(a) << endl; // 12 字節
cout<< sizeof(p) << endl; // 4 字節
1
2
3
4
計算數組和指針的內存容量

void Func(char a[100])
{
?? ?cout<< sizeof(a) << endl; // 4 字節而不是100字節
}
1
2
3
4
類成員函數的重載、覆蓋和隱藏區別？
成員函數被重載的特征：
（1）相同的范圍（在同一個類中）；
（2）函數名字相同；
（3）參數不同；
（4）virtual 關鍵字可有可無。
覆蓋是指派生類函數覆蓋基類函數，特征是：
（1）不同的范圍（分別位于派生類與基類）；
（2）函數名字相同；
（3）參數相同；
（4）基類函數必須有virtual 關鍵字。
“隱藏”是指派生類的函數屏蔽了與其同名的基類函數，規則如下：
（1）如果派生類的函數與基類的函數同名，但是參數不同。此時，不論有無virtual關鍵字，基類的函數將被隱藏（注意別與重載混淆）。
（2）如果派生類的函數與基類的函數同名，并且參數也相同，但是基類函數沒有virtual 關鍵字。此時，基類的函數被隱藏（注意別與覆蓋混淆）
求出兩個數中的較大者
There are two int variables:a and b, don’t use “if”, “? :”, “switch”or other judgement statements, find outthe biggest one of the two numbers.
答案：( ( a + b ) + abs( a - b ) ) / 2

如何打印出當前源文件的文件名以及源文件的當前行號？
答案：

cout << __FILE__ ;
cout<<__LINE__ ;
1
2
__FILE__和__LINE__是系統預定義宏，這種宏并不是在某個文件中定義的，而是由編譯器定義的。

main 主函數執行完畢后，是否可能會再執行一段代碼，給出說明？
答案：可以，可以用_onexit 注冊一個函數，它會在main之后執行int fn1(void), fn2(void),fn3(void), fn4 (void);

void main( void )
{
?? ?String str("zhanglin");
?? ?_onexit( fn1 );
?? ?_onexit( fn2 );
?? ?_onexit( fn3 );
?? ?_onexit( fn4 );
?? ?printf( "This is executed first.n" );
}
int fn1()
{
?? ?printf( "next.n" );
?? ?return 0;
}
int fn2()
{
?? ?printf( "executed " );
?? ?return 0;
}
int fn3()
{
?? ?printf( "is " );
?? ?return 0;
}
int fn4()
{
?? ?printf( "This " );
?? ?return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
The _onexit function is passed the address of a function (func) to be calledwhen the program terminates normally. Successive calls to _onexit create aregister of functions that are executed in LIFO (last-in-first-out) order. Thefunctions passed to _onexit cannot take parameters.
程序正常終止時，將向_onexit函數傳遞要調用的函數（func）的地址。 連續調用_onexit會創建以LIFO（后進先出）順序執行的功能的寄存器。 傳遞給_onexit的函數不能使用參數。

如何判斷一段程序是由C 編譯程序還是由C++編譯程序編譯的？
答案：

#ifdef __cplusplus
?? ?cout<<"c++";
#else
?? ?cout<<"c";
#endif
1
2
3
4
5
文件中有一組整數，要求排序后輸出到另一個文件中
答案：

#include<iostream>
#include<fstream>
#include <vector>

using namespace std;

void Order(vector<int> &data) //bubble sort
{
?? ?int count = data.size();
?? ?for (int i = 0; i < count; i++)
?? ?{
?? ??? ?for (int j = 0; j < count - i - 1; j++)
?? ??? ?{
?? ??? ??? ?if (data[j] > data[j + 1])
?? ??? ??? ?{

?? ??? ??? ??? ?int temp = data[j];
?? ??? ??? ??? ?data[j] = data[j + 1];
?? ??? ??? ??? ?data[j + 1] = temp;
?? ??? ??? ?}
?? ??? ?}
?? ?}
}

void main()
{
?? ?vector<int>data;
?? ?ifstream in("c:\data.txt");
?? ?if (!in)
?? ?{
?? ??? ?cout << "file error!";
?? ??? ?exit(1);
?? ?}
?? ?int temp;
?? ?while (!in.eof())
?? ?{
?? ??? ?in >> temp;
?? ??? ?data.push_back(temp);
?? ?}
?? ?in.close(); //關閉輸入文件流
?? ?Order(data);
?? ?ofstream out("c:\result.txt");
?? ?if (!out)
?? ?{
?? ??? ?cout << "file error!";
?? ??? ?exit(1);
?? ?}
?? ?for (int i = 0; i < data.size(); i++)
?? ??? ?out << data[i] << " ";
?? ?out.close(); //關閉輸出文件流
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
鏈表題：一個鏈表的結點結構
struct Node
{
int data ;
Node *next ;
};
typedef struct Node Node ;
1
2
3
4
5
6
(1)已知鏈表的頭結點head,寫一個函數把這個鏈表逆序 ( Intel)

Node *ReverseList(Node *head) //鏈表逆序
{
?? ?if (head == NULL || head->next == NULL)
?? ??? ?return head;
?? ?Node *p1 = head;
?? ?Node *p2 = p1->next;
?? ?Node *p3 = p2->next;
?? ?p1->next = NULL;
?? ?while (p3 != NULL)
?? ?{
?? ??? ?p2->next = p1;
?? ??? ?p1 = p2;
?? ??? ?p2 = p3;
?? ??? ?p3 = p3->next;
?? ?}
?? ?p2->next = p1;
?? ?head = p2;
?? ?return head;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
(2)已知兩個鏈表head1 和head2 各自有序，請把它們合并成一個鏈表依然有序。(保留所有結點，即便大小相同）

Node * Merge(Node *head1, Node *head2)
{
?? ?if (head1 == NULL)
?? ??? ?return head2;
?? ?if (head2 == NULL)
?? ??? ?return head1;
?? ?Node *head = NULL;
?? ?Node *p1 = NULL;
?? ?Node *p2 = NULL;
?? ?if (head1->data < head2->data)
?? ?{
?? ??? ?head = head1;
?? ??? ?p1 = head1->next;
?? ??? ?p2 = head2;
?? ?}
?? ?else
?? ?{
?? ??? ?head = head2;
?? ??? ?p2 = head2->next;
?? ??? ?p1 = head1;
?? ?}
?? ?Node *pcurrent = head;
?? ?while (p1 != NULL && p2 != NULL)
?? ?{
?? ??? ?if (p1->data <= p2->data)
?? ??? ?{
?? ??? ??? ?pcurrent->next = p1;
?? ??? ??? ?pcurrent = p1;
?? ??? ??? ?p1 = p1->next;
?? ??? ?}
?? ??? ?else
?? ??? ?{
?? ??? ??? ?pcurrent->next = p2;
?? ??? ??? ?pcurrent = p2;
?? ??? ??? ?p2 = p2->next;
?? ??? ?}
?? ?}
?? ?if (p1 != NULL)
?? ??? ?pcurrent->next = p1;
?? ?if (p2 != NULL)
?? ??? ?pcurrent->next = p2;
?? ?return head;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
(3)已知兩個鏈表head1 和head2 各自有序，請把它們合并成一個鏈表依然有序，這次要求用遞歸方法進行。(Autodesk)
答案：

Node * MergeRecursive(Node *head1, Node *head2)
{
?? ?if (head1 == NULL)
?? ??? ?return head2;
?? ?if (head2 == NULL)
?? ??? ?return head1;
?? ?Node *head = NULL;
?? ?if (head1->data < head2->data)
?? ?{
?? ??? ?head = head1;
?? ??? ?head->next = MergeRecursive(head1->next, head2);
?? ?}
?? ?else
?? ?{
?? ??? ?head = head2;
?? ??? ?head->next = MergeRecursive(head1, head2->next);
?? ?}
?? ?return head;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
分析一下這段程序的輸出 (Autodesk)
class B
{
public:
?? ?B()
?? ?{
?? ??? ?cout << "default constructor" << endl;
?? ?}
?? ?~B()
?? ?{
?? ??? ?cout << "destructed" << endl;
?? ?}
?? ?B(int i) :data(i) ? ?//B(int) works as aconverter ( int -> instance of ?B)
?? ?{
?? ??? ?cout << "constructed by parameter " << data << endl;
?? ?}
private:
?? ?int data;
};

B Play(B b)
{
?? ?return b;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
問題一：

int main(int argc, char* argv[])
{
?? ?B t1 = Play(5);
?? ?B t2 = Play(t1);
?? ?return 0;
}
//輸出
constructed by parameter 5
destructed //B(5)形參析構
destructed //t1形參析構
destructed //t2形參析構
destructed //t1形參析構
1
2
3
4
5
6
7
8
9
10
11
12
問題二：

int main(int argc, char* argv[])
{
?? ?B t1 = Play(5);
?? ?B t2 = Play(10);
?? ?return 0;
}
//輸出
constructed by parameter 5 //
destructed //B(5)形參析構
constructed by parameter 10
destructed // B(10)形參析構
destructed //t2形參析構
destructed //t1形參析構
1
2
3
4
5
6
7
8
9
10
11
12
13
寫一個函數找出一個整數數組中，第二大的數 （microsoft）
答案：

const int MINNUMBER = -32767;
int find_sec_max(int data[], int count)
{
?? ?int maxnumber = data[0];
?? ?int sec_max = MINNUMBER;
?? ?for (int i = 1; i < count; i++)
?? ?{
?? ??? ?if (data[i] > maxnumber)
?? ??? ?{
?? ??? ??? ?sec_max = maxnumber;
?? ??? ??? ?maxnumber = data[i];
?? ??? ?}
?? ??? ?else
?? ??? ?{
?? ??? ??? ?if (data[i] > sec_max)
?? ??? ??? ??? ?sec_max = data[i];
?? ??? ?}
?? ?}
?? ?return sec_max;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
寫一個在一個字符串(n)中尋找一個子串(m)第一個位置的函數。
KMP算法效率最好，時間復雜度是Ｏ(n+m),

//寫一個在一個字符串(n)中尋找一個子串(m)第一個位置的函數。
/*思路：
*/
#include <iostream>
#include <string>
using namespace std;
int Find(string str_long,string str_short)
{
? ? if(str_long.length()<str_short.length())
? ? {
? ? ? ? cout<<"error"<<endl;return 0;
? ? }
? ? string temp;
? ? char str_short_first=str_short[0];
? ? for(int i=0;i<str_long.length();i++)
? ? {
? ? ? ? if (str_long[i]==str_short_first)
? ? ? ? {
? ? ? ? ? ? temp.assign(str_long,i,str_short.length());
? ? ? ? ? ? if(temp==str_short)
? ? ? ? ? ? ? ? return ++i;
? ? ? ? ? ? else continue;
? ? ? ? }
? ? }
}
?
int main()
{
? ? string str_l;
? ? cout<<"請輸入第一個長字符串"<<endl;
? ? cin>>str_l;
? ? string str_s;
? ? cout<<"請輸入第一個短字符串"<<endl;
? ? cin>>str_s;
? ? cout<<Find(str_l,str_s)<<endl;
? ? return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
多重繼承的內存分配問題：
比如有class A : public class B, public class C {} 那么A的內存結構大致是怎么樣的？
這個是compiler-dependent的, 不同的實現其細節可能不同。如果不考慮有虛函數、虛繼承的話就相當簡單；否則的話，相當復雜。可以參考《深入探索C++對象模型

如何判斷一個單鏈表是有環的？（注意不能用標志位，最多只能用兩個額外指針）
思路：

bool check(const node* head)
{
?? ?//return false : 無環；true: 有環
?? ?//一種O（n）的辦法就是(搞兩個指針，一個每次遞增一步，一個每次遞增兩步，如果有環的話兩者必然重合，反之亦然)
}?
1
2
3
4
5
struct node
{
?? ?char val;
?? ?node* next;
}
bool check(node* head)
{
?? ?if (head == NULL)
?? ??? ?return false;
?? ?node *low = head, *fast = head->next;
?? ?while (fast != NULL && fast->next != NULL)
?? ?{
?? ??? ?low = low->next;
?? ??? ?fast = fast->next->next;
?? ??? ?if (low == fast)
?? ??? ??? ?return true;
?? ?}
?? ?return false;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
指針找錯題
分析這些面試題，本身包含很強的趣味性;而作為一名研發人員，通過對這些面試題的深入剖析則可進一步增強自身的內功。
試題1：
以下是引用片段：

void test1() ?//數組越界
{
?? ?char string[10];
?? ?char* str1 = "0123456789";
?? ?strcpy(string, str1);
}
1
2
3
4
5
6
試題2：　
以下是引用片段：

void test2()
{
?? ?char string[10], str1[10];
?? ?int i;
?? ?for (i = 0; i < 10; i++)
?? ?{
?? ??? ?str1 = 'a';
?? ?}
?? ?strcpy(string, str1);
}
1
2
3
4
5
6
7
8
9
10
試題3：　　
以下是引用片段：

void test3(char* str1)
{
?? ?char string[10];
?? ?if (strlen(str1) <= 10)
?? ?{
?? ??? ?strcpy(string, str1);
?? ?}
}
1
2
3
4
5
6
7
8
解答：

試題1：字符串str1需要11個字節才能存放下(包括末尾的’\0’)，而string只有10個字節的空間，strcpy會導致數組越界;
試題2：如果面試者指出字符數組str1不能在數組內結束可以給3分;如果面試者指出strcpy(string,str1)調用使得從 str1內存起復制到string內存起所復制的字節數具有不確定性可以給7分，在此基礎上指出庫函數strcpy工作方式的給10分;
試題3，if(strlen(str1) <= 10)應改為if(strlen(str1) <10)，因為strlen的結果未統計’\0’所占用的1個字節。剖析：考查對基本功的掌握
　　(1)字符串以’\0’結尾;
　　(2)對數組越界把握的敏感度;
　　(3)庫函數strcpy的工作方式，
如果編寫一個標準strcpy函數
總分值為10，下面給出幾個不同得分的答案：：

//2分 以下是引用片段
void strcpy(char *strDest, char *strSrc)
{
?? ?while ((*strDest++ = *strSrc++) != ‘\0’);
}
//4分　以下是引用片段：
void strcpy(char *strDest, const char *strSrc)
//將源字符串加const，表明其為輸入參數，加2分
{
?? ?while ((*strDest++ = *strSrc++) != ‘\0’);
}
//7分 以下是引用片段：
void strcpy(char *strDest, const char *strSrc)
{
?? ?//對源地址和目的地址加非0斷言，加3分
?? ?assert((strDest != NULL) && (strSrc != NULL));
?? ?while ((*strDest++ = *strSrc++) != ‘\0’);
}
//10分 以下是引用片段：
//為了實現鏈式操作，將目的地址返回，加3分!
char * strcpy(char *strDest, const char *strSrc)
{
?? ?assert((strDest != NULL) && (strSrc != NULL));
?? ?char *address = strDest;
?? ?while ((*strDest++ = *strSrc++) != ‘\0’);
?? ?return address;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
對strlen的掌握，它沒有包括字符串末尾的’\0’。
讀者看了不同分值的strcpy版本，應該也可以寫出一個10分的strlen函數了，完美的版本為：

int strlen(const char *str) //輸入參數const　以下是引用片段：
{
?? ?assert(strt != NULL); //斷言字符串地址非0
?? ?int len = 0; //注，一定要初始化。
?? ?while ((*str++) != '\0')
?? ?{
?? ??? ?len++;
?? ?}
?? ?return len;
}
1
2
3
4
5
6
7
8
9
10
找錯題：
試題1：以下是引用片段：

void GetMemory(char *p)
{
?? ?p = (char *)malloc(100);
}
void Test(void)
{
?? ?char *str = NULL;
?? ?GetMemory(str);
?? ?strcpy(str, "helloworld");
?? ?printf(str);
}
1
2
3
4
5
6
7
8
9
10
11
試題2：以下是引用片段：

char *GetMemory(void)
{
?? ?char p[] = "helloworld";
?? ?return p;
}
void Test(void)
{
?? ?char *str = NULL;
?? ?str = GetMemory();
?? ?printf(str);
}
1
2
3
4
5
6
7
8
9
10
11
試題3：以下是引用片段：

void GetMemory(char **p, int num)
{
?? ?*p = (char *)malloc(num);
}
void Test(void)
{
?? ?char *str = NULL;
?? ?GetMemory(&str, 100);
?? ?strcpy(str, "hello");
?? ?printf(str);
}
1
2
3
4
5
6
7
8
9
10
11
試題4：以下是引用片段：

void Test(void)
{
?? ?char *str = (char *)malloc(100);
?? ?strcpy(str, "hello");
?? ?free(str);
?? ?... //省略的其它語句
}
1
2
3
4
5
6
7
解答：

試題1傳入中GetMemory( char *p )函數的形參為字符串指針，在函數內部修改形參并不能真正的改變傳入形參的值，執行完
　　char *str = NULL;
　　GetMemory( str );
1
2
后的str仍然為NULL;

試題2中
　　char p[] = "helloworld";
　　return p;
1
2
的p[]數組為函數內的局部自動變量，在函數返回后，內存已經被釋放。這是許多程序員常犯的錯誤，其根源在于不理解變量的生存期。

試題3的GetMemory避免了試題1的問題，傳入GetMemory的參數為字符串指針的指針，但是在GetMemory中執行申請內存及賦值語句
　　*p = (char *) malloc( num );
1
后未判斷內存是否申請成功，應加上：

　　if ( *p == NULL )
　　{
　　...//進行申請內存失敗處理
　　}
1
2
3
4
試題4存在與試題3同樣的問題，在執行
　　char *str = (char *)malloc(100);
　　后未進行內存是否申請成功的判斷;另外，在free(str)后未置str為空，導致可能變成一個“野”指針，應加上：
　　str = NULL;
　　試題3的Test函數中也未對malloc的內存進行釋放。
　　對內存操作的考查主要集中在：
　　(1)指針的理解;
　　(2)變量的生存期及作用范圍;
　　(3)良好的動態內存申請和釋放習慣。
　　
再看看下面的一段程序有什么錯誤：　　
以下是引用片段：
swap(int* p1, int* p2)
{
?? ?int *p;
?? ?*p = *p1;
?? ?*p1 = *p2;
?? ?*p2 = *p;
}
1
2
3
4
5
6
7
在swap函數中，p是一個“野”指針，有可能指向系統區，導致程序運行的崩潰。在VC++中DEBUG運行時提示錯誤“AccessViolation”。該程序應該改為
以下是引用片段：

swap(int* p1, int* p2)
{
?? ?int p;
?? ?p = *p1;
?? ?*p1 = *p2;
?? ?*p2 = p;
}
1
2
3
4
5
6
7
String 的具體實現
已知String類定義如下：

class String
{
public:
?? ?String(const char *str = NULL); // 通用構造函數
?? ?String(const String &another); // 拷貝構造函數
?? ?~String(); // 析構函數
?? ?String & operater = (const String &rhs); // 賦值函數
private:
?? ?char *m_data; // 用于保存字符串
};
1
2
3
4
5
6
7
8
9
10
嘗試寫出類的成員函數實現。
答案：

String::String(const char *str)
{
?? ?if (str == NULL) //strlen在參數為NULL時會拋異常才會有這步判斷
?? ?{
?? ??? ?m_data = new char[1];
?? ??? ?m_data[0] = '\0';
?? ?}
?? ?else
?? ?{
?? ??? ?m_data = new char[strlen(str) + 1];
?? ??? ?strcpy(m_data, str);
?? ?}

}
String::String(const String &another)
{
?? ?m_data = new char[strlen(another.m_data) + 1];
?? ?strcpy(m_data, other.m_data);
}
String& String::operator =(const String &rhs)
{
?? ?if (this == &rhs)
?? ??? ?return *this;
?? ?delete[]m_data; //刪除原來的數據，新開一塊內存
?? ?m_data = new char[strlen(rhs.m_data) + 1];
?? ?strcpy(m_data, rhs.m_data);
?? ?return *this;
}

String::~String()
{
?? ?delete[]m_data;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
h頭文件中的ifndef/define/endif 的作用？
答：防止該頭文件被重復引用。
#include<file.h> 與 ＃include "file.h"的區別？
答：前者是從Standard Library的路徑尋找和引用file.h，而后者是從當前工作路徑搜尋并引用file.h。

在C++ 程序中調用被C 編譯器編譯后的函數，為什么要加extern “C”？
C++調用C函數需要extern C，因為C語言沒有函數重載。

幾道c筆試題(含參考答案)
1.What is displayed when f() is called given the code:

class Number {
public:
?? ?string type;

?? ?Number() : type(“void”) { }
?? ?explicit Number(short) : type(“short”) { }
?? ?Number(int) : type(“int”) { }
};
void Show(const Number& n) { cout << n.type; }
void f()
{
?? ?short s = 42;
?? ?Show(s);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
a) void
b) short
c) int
d) None of the above

Which is the correct output for the following code
double dArray[2] = { 4, 8 }, *p, *q;
p = &dArray[0];
q = p + 1;
cout << q – p << endl;
cout << (int)q - (int)p << endl;
1
2
3
4
5
a) 1 and 8
b) 8 and 4
c) 4 and 8
d) 8 and 1

第一個選C；
雖然傳入的是short類型，但是short類型的構造函數被生命被explicit，也就是只能顯示類型轉換，不能使用隱式類型轉換。
第二個選A；
第一個是指針加減，按照的是指向地址類型的加減，只跟類型位置有關，q和p指向的數據類型以實際數據類型來算差一個位置，因此是1。而第二個加減是實際指針值得加減，在內存中一個double類型占據8個字節，因此是8

Sony筆試題
1．完成下列程序
*
*.*.
*…*…*…
*…*…*…*…
*…*…*…*…*…
*…*…*…*…*…*…
*…*…*…*…*…*…*…
*…*…*…*…*…*…*…*…

#include <stdio.h>
#define N 8
int main()
{
?? ?int i;
?? ?int j;
?? ?int k;
?? ?-------------------------------------------------------- -
?? ??? ?| |
?? ??? ?| |
?? ??? ?| |
?? ?-------------------------------------------------------- -
?? ?return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
答案：

#include<iostream>
using namespace std;
void dian(int n)
{
?? ?while (n--)
?? ?{
?? ??? ?cout << ".";
?? ?}
}
void xing()
{
?? ?cout << "*";
}

int main()
{
?? ?cout << "輸入你需要輸出的行數:" << endl;
?? ?int line;
?? ?cin >> line;
?? ?for (int i = 1; i <= line; i++)
?? ?{
?? ??? ?int j = i;

?? ??? ?while (j--)
?? ??? ?{
?? ??? ??? ?xing();
?? ??? ??? ?dian(i - 1);

?? ??? ?}
?? ??? ?cout << endl;
?? ?}
?? ?return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
2．完成程序，實現對數組的降序排序

#include<stdio.h>
void sort(int *arr, int len);
int main()
{
?? ?int array[] = { 45，56，76，234，1，34，23，2，3 }；//數字任//意給出
?? ?sort(array, (sizeof(array) / sizeof(array[0])) - 1);
?? ?return 0;
}
void sort()
{
?? ?____________________________________
?? ??? ?| |
?? ??? ?| |
?? ?----------------------------------------------------
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
答案：

#include <stdio.h>

void sort(int *arr, int len);
int main(void) {
?? ?int array[10] = {45,56,76,234,1,34,23,2,3};
?? ?int i;
?? ?sort(array, (sizeof(array) / sizeof(array[0])) - 1);
?? ?for (i = 0; i < (sizeof(array) / sizeof(array[0])) - 1; i++)
?? ?{
?? ??? ?printf("%d \n", *(array + i));
?? ?}
?? ?return 0;
}
void sort(int *arr, int len)
{
?? ?int i;
?? ?int j;
?? ?int tmp;
?? ?for (i = 0; i < len; i++)
?? ?{
?? ??? ?for (j = i + 1; j < len; j++)
?? ??? ?{
?? ??? ??? ?if (*(arr + i) < *(arr + j))
?? ??? ??? ?{
?? ??? ??? ??? ?tmp = *(arr + i);
?? ??? ??? ??? ?*(arr + i) = *(arr + j);
?? ??? ??? ??? ?*(arr + j) = tmp;
?? ??? ??? ?}
?? ??? ?}
?? ?}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
3．費波那其數列，1，1，2，3，5……編寫程序求第十項。可以用遞歸，也可以用其
他方法，但要說明你選擇的理由。

#include <stdio.h>
int Pheponatch(int);
int main()
{
?? ?printf("The 10th is%d", Pheponatch(10));
?? ?return 0;
}
int Pheponatch(int N)
{
?? ?--------------------------------
?? ??? ?| |
?? ??? ?| |
?? ?--------------------------------
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
答案：

#include<stdio.h>
int Pheponatch(int);
int main()
{
?? ?printf("The 10th is%d", Pheponatch(10));
?? ?return 0;
}
int Pheponatch(int n)
{
? ?int n1=1;
? ?int n2=1;
? ?int result=0;
? ?if(n==1||n==2)result=1;
? ?else
? {
? ? ? for(int i=0;i<n-2;i++)
? ? {
? ? ? ?int temp=n2;
? ? ? ?n2=n1+n2;
? ? ? ?n1=temp;
? ? }
? ? ? ?result=n2;
? }
? ?return result;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
4．下列程序運行時會崩潰，請找出錯誤并改正，并且說明原因。

#include
#include
typedef struct
{
?? ?TNode* left;
?? ?TNode* right;
?? ?int value;
} TNode;
TNode* root = NULL;
void append(int N);
int main()
{
?? ?append(63);
?? ?append(45);
?? ?append(32);
?? ?append(77);
?? ?append(96);
?? ?append(21);
?? ?append(17); // Again, 數字任意給出
}
void append(int N)
{
?? ?TNode* NewNode = (TNode*)malloc(sizeof(TNode));
?? ?NewNode->value = N;
?? ?if (root == NULL)
?? ?{
?? ??? ?root = NewNode;
?? ??? ?return;
?? ?}
?? ?else
?? ?{
?? ??? ?TNode* temp;
?? ??? ?temp = root;
?? ??? ?while ((N >= temp.value&& temp.left != NULL) || (N != NULL))
?? ??? ?{
?? ??? ??? ?while (N >= temp.value&& temp.left != NULL)
?? ??? ??? ??? ?temp = temp.left;
?? ??? ??? ?while (N<temp = temp.right;
?? ??? ?}
?? ??? ?if (N >= temp.value)
?? ??? ??? ?temp.left = NewNode;
?? ??? ?else
?? ??? ??? ?temp.right = NewNode;
?? ??? ?return;
?? ?}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
答案：

//下列程序運行時會崩潰，請找出錯誤并改正，并且說明原因。
/*
此程序的功能是完成一個有序二叉樹的建立,使得左子樹結點的值小于根結點,
右子樹大于根結點. 題目程序中結構體定義的地方有誤,在TNode名字出現之前,
就在結構體內使用TNode,將導致編譯錯誤.另外題目中append函數中的所有temp的點號操作符都應改成->,
因為temp是個指針.至于題目中所說的程序在運行時崩潰出現在append函數中的對temp->left和temp->right操作時候,?
因為每創建一個新結點的時候都沒將left和right成員初始化為空指針,會導致append函數中的while循環訪問到非法內存,
從而導致程序崩潰. 為了方便測試,添加了函數print_tree打印樹的結點內容,
另外補充了一個函數free_tree來釋放動態分配的內存.修改后的程序如下:
*/
#include <iostream>
using namespace std;
//typedef struct{ ? //錯誤1 TNode名字出現前，就在結構內使用TNode將導致編譯錯誤
typedef struct TNode
{ //應該這樣寫
?? ?TNode* left;
? ? TNode* right;?
? ?int value;?
}TNode;
?
TNode* root=NULL;?
void append(int N);?
void free_tree(TNode *root);
void print_tree(TNode *root);
?
?
int main()?
{?
?? ?append(63);?
?? ?append(45);?
? ? append(32);?
?? ?append(77);?
?? ?append(96);?
?? ?append(21);?
?? ?append(17); // Again, 數字任意給出?
?? ?print_tree(root);
?? ?cout<<"\n memory released !\n";
?? ?free_tree(root);
? ? system("pause");
return 0;
}?
?
void append(int N)?
{
?? ?TNode* NewNode=(TNode *)malloc(sizeof(TNode));?
?? ?if (!NewNode)
?? ?{
?? ??? ?cout<<"memory alloc failure!\n";
?? ??? ?exit(1);
?? ?}
?
?? ?NewNode->value=N;?
?? ?//NewNode->left;
?? ?//NewNode->right; //錯誤2 沒有初始化新結點的left和right成員為空指針，
?? ? ? ? ? ? ? ? ? ? ?//導致append函數中while循環訪問到非法內存，從而導致運行時崩潰
?? ?NewNode->left=NULL;
?? ?NewNode->right=NULL;
?? ?if(root==NULL)?
?? ?{?
?? ??? ?root=NewNode;?
?? ??? ?return;
?? ?}?
?? ?else?
?? ?{?
?? ??? ?TNode* temp;?
?? ??? ?temp=root;?
?? ??? ?//while((N>=temp.value && temp.left!=NULL) || (N<temp. value && temp. right!=NULL))?
?? ??? ?//錯誤3 temp是指針，則下面引用成員應該使用->而不是.(點)
?? ??? ?while((N>=temp->value && temp->left!=NULL) || (N<temp->value&&temp->right!=NULL))?
?? ??? ?{
?? ??? ??? ? ? while(N>=temp->value && temp->left!=NULL)?
?? ??? ??? ??? ? ? temp=temp->left;?
?? ??? ??? ? ? while(N<temp->value && temp->right!=NULL)
?? ??? ??? ??? ? ? temp=temp->right;?
?? ??? ?}?
?
?? ??? ?if(N>=temp->value)?
?? ??? ??? ?temp->left=NewNode;?
?? ??? ?else?
?? ??? ??? ?temp->right=NewNode;?
?? ??? ?return;?
?? ?}
}?
?
?
//釋放內存函數
void free_tree(TNode *root){
?? ?if (!root->left && !root->right)
?? ?{
?? ??? ?free(root);
?? ??? ?return;
?? ?}
?? ?if (root->left)
?? ?{
?? ??? ?free_tree(root->left);
?? ?}
?? ?else{
?? ??? ?free_tree(root->right);
?? ?}
}
?
?
//打印函數
void print_tree(TNode *root){
?? ?if (!root->left && !root->right)
?? ?{
?? ??? ?cout<<root->value<<" ";
?? ??? ?return;
?? ?}
?? ?if (root->right)
?? ??? ?print_tree(root->right);
?
?? ??? ?cout<<root->value<<" ";
?
?? ?if (root->left)
?? ?{
?? ??? ?print_tree(root->left);
?? ?}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
請你分別畫出OSI的七層網絡結構圖和TCP/IP的五層結構圖。

OSI七層模型及其包含的協議如下:

物理層: 通過媒介傳輸比特,確定機械及電氣規范,傳輸單位為bit，主要包括的協議為：IEE802.3 CLOCK RJ45
數據鏈路層: 將比特組裝成幀和點到點的傳遞,傳輸單位為幀,主要包括的協議為MAC VLAN PPP
網絡層：負責數據包從源到宿的傳遞和網際互連，傳輸單位為包,主要包括的協議為IP ARP ICMP
+傳輸層：提供端到端的可靠報文傳遞和錯誤恢復，傳輸單位為報文,主要包括的協議為TCP UDP
會話層：建立、管理和終止會話，傳輸單位為SPDU，主要包括的協議為RPC NFS
表示層: 對數據進行翻譯、加密和壓縮,傳輸單位為PPDU，主要包括的協議為JPEG ASII
應用層: 允許訪問OSI環境的手段,傳輸單位為APDU，主要包括的協議為FTP HTTP DNS
TCP/IP 4層模型包括：
網絡接口層：MAC VLAN
網絡層:IP ARP ICMP
傳輸層:TCP UDP
應用層:HTTP DNS SMTP
請你詳細地解釋一下IP協議的定義，在哪個層上面？主要有什么作用？TCP與UDP呢 ？
參考答案：IP處在互連網絡層。負責提供基本的數據封包傳送功能，讓每一塊數據包都能夠到達目的主機（但不檢查是否被正確接收）。
TCP與UDP在傳輸層。它提供了節點間的數據傳送，應用程序之間的通信服務，主要功能是數據格式化、數據確認和丟失重傳等。如傳輸控制協議（TCP）、用戶數據報包議（UDP）等，TCP和UDP給數據包加入傳輸數據并把它傳輸到下一層中，這一層負責傳送數據，并且確定數據已被送達并接收。

請問交換機和路由器各自的實現原理是什么？分別在哪個層次上面實現的？
交換機屬于OSI第二層即數據鏈路層設備。它根據MAC地址尋址，通過站表選擇路由，站表的建立和維護由交換機自動進行。路由器屬于OAI第三層即網絡層設備，它根據IP地址進行尋址，通過路由表路由協議產生。交換機最大的好處是快速，路由器最大的好處是控制能力強。

全局變量和局部變量有什么區別？是怎么實現的？操作系統和編譯器是怎么知道的 ？
作用域不同：全局變量的作用域為整個程序，而局部變量的作用域為當前函數或循環等
內存存儲方式不同：全局變量存儲在全局數據區中，局部變量存儲在棧區
生命期不同：全局變量的生命期和主程序一樣，隨程序的銷毀而銷毀，局部變量在函數內部或循環內部，隨函數的退出或循環退出就不存在了
使用方式不同：全局變量在聲明后程序的各個部分都可以用到，但是局部變量只能在局部使用。函數內部會優先使用局部變量再使用全局變量。
全局變量在數據段,而局部變量在棧,局部 變量在函數結束時內存空間就被系統收回,所以要返回的數組或字符串不要用局部變量定義.extren和在main()函數外定義的變量都稱為全局變量,操 作系統和編譯器從定義變量為變量分配內存時,從變量的定義和存儲區域來分別局部變量和全局變量

8086是多少位的系統？在數據總線上是怎么實現的？
8086微處理器共有4個16位的段寄存器，在尋址內存單元時，用它們直接或間接地存放段地址。
　　代碼段寄存器CS：存放當前執行的程序的段地址。
　　數據段寄存器DS：存放當前執行的程序所用操作數的段地址。
　　堆棧段寄存器SS：存放當前執行的程序所用堆棧的段地址。
　　附加段寄存器ES：存放當前執行程序中一個輔助數據段的段地址。

由cs:ip構成指令地址，ss:sp構成堆棧的棧頂地址指針。DS和ES用作數據段和附加段的段地址（段起始地址或段值）
8086／8088微處理器的存儲器管理

地址線（碼）與尋址范圍：N條地址線 尋址范圍=2N
8086有20地址線 尋址范圍為1MB 由00000H～FFFFFH
8086微處理器是一個16位結構，用戶可用的寄存器均為16位：尋址64KB
8086／8088采用分段的方法對存儲器進行管理。具體做法是：把1MB的存儲器空間分成若干段，每段容量為64KB，每段存儲器的起始地址必須是一個能被16整除的地址碼，即在20位的二進制地址碼中最低4位必須是“0”。每個段首地址的高16位二進制代碼就是該段的段號(稱段基地址)或簡稱段地址，段號保存在段寄存器中。我們可對段寄存器設置不同的值來使微處理器的存儲器訪問指向不同的段。
段內的某個存儲單元相對于該段段首地址的差值，稱為段內偏移地址(也叫偏移量)用16位二進制代碼表示。
物理地址是由8086／8088芯片地址引線送出的20位地址碼，它用來參加存儲器的地址譯碼，最終讀／寫所訪問的一個特定的存儲單元。
邏輯地址由某段的段地址和段內偏移地址(也叫偏移量)兩部分所組成。寫成：
段地址：偏移地址(例如，1234H：0088H)。
在硬件上起作用的是物理地址，物理地址＝段基地址×10H十偏移地址
聯想筆試題
　　1．設計函數 int atoi(char *s)。

#include<iostream>

int atoi(char *s)
{
?? ?int num = 0, f = 1, i = 0;

?? ?if (s[0] == '-')
?? ?{
?? ??? ?f = -1;
?? ??? ?i = 1;
?? ?}
?? ?if (s[0] == '+')
?? ?{
?? ??? ?f = 1;
?? ??? ?i = 1;
?? ?}

?? ?while (s[i] != '\0')
?? ?{
?? ??? ?if(s[i]<'0' || s[i]>'9')
?? ??? ??? ?break;
?? ??? ?if (s[i] == '.')
?? ??? ??? ?break;
?? ??? ?else
?? ??? ?{
?? ??? ??? ?num = num * 10 + s[i] - '0';
?? ??? ??? ?i++;
?? ??? ?}
?? ?}

?? ?return num * f;
}

void main()
{
?? ?char ch[] = "+1313.377";
?? ?cout << atoi(ch) << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
2．int i=(j=4,k=8,l=16,m=32); printf(“%d”, i); 輸出是多少？
首先
int i=(j=4);
等同于：
int j = 4;
int i = j;
而int i=(j=4,k=8,l=16,m=32);
則等同于：
int j=4, k=8, l=16, m=32;
int i = j;
int i = k;
int i = l;
int i = m;
z最后i = m =32，故輸出為32

解釋局部變量、全局變量和靜態變量的含義。
局部變量
在一個函數內部定義的變量是內部變量，它只在本函數范圍內有效，也就是說只有在本函數內才能使用它們，在此函數以外時不能使用這些變量的，它們稱為局部變量；
說明：

主函數main中定義的變量也只在主函數中有效，而不因為在主函數中定義而在整個文件或程序中有效
不同函數中可以使用名字相同的變量，它們代表不同的對象，互不干擾
形式參數也使局部變量
在一個函數內部，可以在復合語句中定義變量，這些變量只在本符合語句中有效
全局變量
在函數外定義的變量是外部變量，外部變量是全局變量，全局變量可以為本文件中其它函數所共用，它的有效范圍從定義變量的位置開始到本源文件結束；
說明：

設全局變量的作用：增加了函數間數據聯系的渠道
建議不再必要的時候不要使用全局變量，因為:
a.全局變量在程序的全部執行過程中都占用存儲單元；
b.它使函數的通用性降低了c.使用全局變量過多，會降低程序的清晰性
如果外部變量在文件開頭定義，則在整個文件范圍內都可以使用該外部變量，如果不再文件開頭定義，按上面規定作用范圍只限于定義點到文件終了。如果在定義點之前的函數想引用該外部變量，則應該在該函數中用關鍵字extern作外部變量說明
4.如果在同一個源文件中，外部變量與局部變量同名，則在局部變量的作用范圍內，外部變量不起作用；
靜態變量
在程序運行期間分配固定的存儲空間的變量，叫做靜態變量

論述含參數的宏與函數的優缺點。
函數調用時，先求出實參表達式的值，然后帶入形參。而使用帶參的宏只是進行簡單的字符替換。
函數調用是在程序運行時處理的，分配臨時的內存單元；而宏展開則是在編譯時進行的，在展開時并不分配內存單元，不進行值的傳遞處理，也沒有“返回值”的概念。
對函數中的實參和形參都要定義類型，二者的類型要求一致，如不一致，應進行類型轉換；而宏不存在類型問題，宏名無類型，它的參數也無類型，只是一個符號代表，展開時帶入指定的字符即可。宏定義時，字符串可以是任何類型的數據。
調用函數只可得到一個返回值，而用宏可以設法得到幾個結果。
使用宏次數多時，宏展開后源程序長，因為每展開一次都使程序增長，而函數調用不使源程序變長。
宏替換不占運行時間，只占編譯時間；而函數調用則占運行時間（分配單元、保留現場、值傳遞、返回）。
一般來說，用宏來代表簡短的表達式比較合適。
內聯函數和宏很類似，而區別在于，宏是由預處理器對宏進行替代，而內聯函數是通過編譯器控制來實現的。而且內聯函數是真正的函數，只是在需要用到的時候，內聯函數像宏一樣的展開，所以取消了函數的參數壓棧，減少了調用的開銷。你可以象調用函數一樣來調用內聯函數，而不必擔心會產生于處理宏的一些問題。
當然，內聯函數也有一定的局限性。就是函數中的執行代碼不能太多了，如果，內聯函數的函數體過大，一般的編譯器會放棄內聯方式，而采用普通的方式調用函數。這樣，內聯函數就和普通函數執行效率一樣了。
內聯函數是不能為虛函數的，但樣子上寫成了內聯的，即隱含的內聯方式。在某種情況下，雖然有些函數我們聲明為了所謂“內聯”方式，但有時系統也會把它當作普通的函數來處理，這里的虛函數也一樣，雖然同樣被聲明為了所謂“內聯”方式,但系統會把它當然非內聯的方式來處理。

普天C++筆試題
　　1．實現雙向鏈表刪除一個節點P，在節點P后插入一個節點，寫出這兩個函數。

#include <stdio.h>
#include <stdlib.h>
#define N ? 10
typedef struct node
{
?? ?int data;
?? ?struct node *next;
?? ?struct node *front;
}ElemSN;

ElemSN *createLink(int *num);
ElemSN *DeleteNode(ElemSN *head, ElemSN *s);
ElemSN *insertNode(ElemSN *head, ElemSN *s, ElemSN *pa);

void outPut(ElemSN *head);

void main()
{
?? ?int num[10] = { 1,2,3,4,5,6,7,8,9,10 };
?? ?ElemSN *s, *h, *head, *q, *pa;
?? ?s = (ElemSN*)malloc(sizeof(ElemSN));//注意要先分配空間才能用啊
?? ?s->data = 5;
?? ?s->front = NULL;
?? ?s->next = NULL;
?? ?pa = (ElemSN*)malloc(sizeof(ElemSN));
?? ?pa->data = 100;
?? ?pa->front = NULL;
?? ?pa->next = NULL;
?? ?h = createLink(num);
?? ?printf("鏈表建立完如下:\n");
?? ?outPut(h);
?? ?printf("刪除掉元素5以后鏈表如下:\n");
?? ?head = DeleteNode(h, s);
?? ?outPut(head);
?? ?printf("插入元素后鏈表如下:\n");
?? ?h = createLink(num);
?? ?q = insertNode(h, s, pa);
?? ?outPut(q);
}

ElemSN *createLink(int *num)
{
?? ?int i;
?? ?ElemSN *h, *p, *q;
?? ?//建立頭結點
?? ?q = h = (ElemSN*)malloc(sizeof(ElemSN));
?? ?h->data = num[0];
?? ?h->next = h->front = NULL;

?? ?//依次建立其余節點
?? ?for (i = 1; i < N; i++)
?? ?{
?? ??? ?p = (ElemSN*)malloc(sizeof(ElemSN));
?? ??? ?p->data = num[i];
?? ??? ?p->next = NULL;
?? ??? ?p->front = q;
?? ??? ?q->next = p;
?? ??? ?q = p;
?? ?}
?? ?return h;
}

ElemSN *DeleteNode(ElemSN *head, ElemSN *s)
{
?? ?ElemSN *p, *h, *q;
?? ?p = h = head;
?? ?q = NULL;
?? ?for (; p->data != s->data; q = p, p = p->next);
?? ?if (p == head)
?? ?{
?? ??? ?h = p->next;
?? ??? ?h->front = NULL;
?? ??? ?p->next = NULL;
?? ??? ?free(p);
?? ?}
?? ?else
?? ?{
?? ??? ?q->next = p->next;
?? ??? ?p->next->front = q;
?? ??? ?p->next = p->front = NULL;
?? ??? ?free(p);
?? ?}
?? ?return h;
}

ElemSN *insertNode(ElemSN *head, ElemSN *s, ElemSN *pa)
{
?? ?ElemSN *h, *p;
?? ?h = head;

?? ?for (p = head; (p != NULL) && (p->data != s->data); p = p->next);
?? ?//插入分為頭結點和其他節點
?? ?if (p == NULL)
?? ?{
?? ??? ?return NULL;
?? ?}
?? ?if (p == head)
?? ?{
?? ??? ?pa->next = h;
?? ??? ?h->front = pa;
?? ?}
?? ?else
?? ?{
?? ??? ?pa->next = p->next;
?? ??? ?p->next->front = pa;
?? ??? ?pa->front = p;
?? ??? ?p->next = pa;
?? ?}
?? ?return h;
}

void outPut(ElemSN *head)
{
?? ?ElemSN *p = head;
?? ?while (p != NULL)
?? ?{
?? ??? ?printf("%d-->", *p);
?? ??? ?p = p->next;
?? ?}
?? ?printf("\n");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
2．寫一個函數，將其中的\t都轉換成4個空格。

char*convert(char*strDest, const char*strSrc, int length)
{
?? ?char*p = strDest;
?? ?int i = 0;
?? ?while (*strSrc && i < length)
?? ?{
?? ??? ?if (*strSrc == '\t')
?? ??? ?{
?? ??? ??? ?for (int j = 0; j < 4; j++)
?? ??? ??? ??? ?*p++ = ' ';
?? ??? ?}
?? ??? ?else
?? ??? ??? ?*p++ = *strSrc;
?? ??? ?strSrc++;
?? ??? ?i++;
?? ?}
?? ?*p = '\0';//這里的結束符必須加上，否則可能會出現亂碼情況
?? ?return strDest;
}

int main()
{
?? ?const char *str1 = "abc\tde\tfg";
?? ?int len = strlen(str1);
?? ?char*str2 = new char;//這個地方需要注意的，必須動態分配，要不會指向空指針！！不能這樣定義的char *str2;
?? ?//就在這個地方我開始找了很長時間的錯，動態分配內存真的很重要！！！
?? ?str2 = convert(str2, str1, len);
?? ?cout << str2 << endl;
?? ?system("pause");
?? ?return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
運行效果圖：

Windows程序的入口是哪里？寫出Windows消息機制的流程。
Windows程序的入口是WinMain()函數。
Windows應用程序消息處理機制：

操作系統接收應用程序的窗口消息，將消息投遞到該應用程序的消息隊列中
應用程序在消息循環中調用GetMessage函數從消息隊列中取出一條一條的消息，取出消息后，應用程序可以對消息進行一些預處理。
應用程序調用DispatchMessage，將消息回傳給操作系統。
系統利用WNDCLASS結構體的lpfnWndProc成員保存的窗口過程函數的指針調用窗口過程，對消息進行處理
C++里面是不是所有的動作都是main()引起的？如果不是，請舉例。
不是
對于C++程序而言：

第一：靜態變量、全局變量、全局對象的分配早在main（）函數之前已經完成了；
第二：系統會為某個啟動的程序分配地址空間,創建進程和主線程,并為main()指供參數(如果有的話),然后才轉到main()執行；
第三：是C/C++的運行時啟動函數：wWinMainCRTStartup 引起的，main函數也接受這個函數的調用。所以并不是所有的動作都是由main()引起的，只是編譯器是由main()開始執行的，main()只不過是一個約定的函數入口，在main()函數中的顯示代碼執行之前，會調用一個由編譯器是生成的_main()函數，而_main()函數會進行所有全局對象的構造及初始化工作。如：
class A();
A a;
int main()
{
?? ?//main func
}
1
2
3
4
5
6
程序在執行時，因為會首先初始化全局變量，當這個變量是一個對象時，則會首先調用該對象的構造函數，所以上例中，a的構造函數先執行，然后再執行main()函數，C++中并非所有的動作都是main()函數引起的
引申：怎樣在main()函數退出以后再執行一段代碼？
全局變量。當程序退出時，全局變量必須銷毀，自然會調用全局對象的析構函數，所以剩下的就同構造函數一樣了

如何定義和實現一個類的成員函數為回調函數？
回調函數定義
就是被調用者回頭調用的函數，它是通過函數指針調用的函數。如果把函數的指針（地址）作為參數傳遞給另一個函數，當這個指針被用為調用它所所指向的函數時，此時，就可以稱它為回調函數。
進一步解釋
回調函數不是由該函數的實現方直接調用的，而是在特定的事件或條件發生時由另外的一方調用的，用于對該事件或條件進行響應。
使用回調函數實際上就是在調用某個函數（通常是API函數）時，將自己的一個函數（這個函數為回調函數）的地址作為參數傳遞給那個被調用的函數。而被調用函數在需要的時候，利用傳遞的地址調用回調函數。
回調函數由程序員自己調用，當需要調用另一個函數時，這個函數的其中一個參數就是這個回調函數名。系統在必要的時候會調用程序員寫的回調函數，這樣就可以在回調函數里完成要做的事了。
回調函數實現
（1）聲明
（2）定義
（3）設置觸發條件，就是在函數中把回調函數名作為一個參數，以便系統調用。
舉例

typedef void(*FunPtr)(void);
//定義回調函數
class A
{
public:
?? ?//回調函數，必須是聲明為static
?? ?static void callBackFun(void)
?? ?{
?? ??? ?...
?? ?}
};
//設置觸發條件
void Funtype(FunPtr p)
{
?? ?p();
}
void main(void)
{
?? ?Functype(A::callBackFun);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
回調函數和API對比

相同點：
回調函數與應用程序接口（API）很相似，都是跨層調用的函數
不同點：
API是低層提供給高層的調用，一般這個函數對高層都是已知的。
回調函數是高層提供給低層的調用，對于低層它是未知的，必須由高層進行安裝，這個安裝函數就是一個低層提供的API，安裝后低層不是道這個回調的名字，但它通過一個函數指針來保存這個回調函數，在需要調用時，只需引用這個函數指針和相關的參數指針。
解釋堆和棧的區別。
1、棧由編譯器自動分配釋放空間；堆 一般由程序員分配釋放。
2、棧使用的是一級緩存， 它們通常都是被調用時處于存儲空間中，調用完畢立即釋放；堆則是存放在二級緩存中，生命周期由虛擬機的垃圾回收算法來決定。”

C++里面如何聲明const void f(void)函數為C程序中的庫函數？
extern “C” const void f(void);

下列哪兩個是等同的
int b;
A const int* a = &b;
B const* int a = &b;
C const int* const a = &b;
D int const* const a = &b;
1
2
3
4
5
int const *a 和 const int *a 意義相同，作用等價 同理，本題C、D意義相同。
const int *a 這里const 修飾的是int，而int定義的是一個整值
int *const a 這里const修飾的是 a ，a代表的是一個指針地址 因此不能賦給a其他的地址值，但可以修改a指向的值。
const int * const a 這個代表a所指向的對象的值以及它的地址本身都不能被改變
所以：
第一個const int a, b(即a)的值不能改變，a的值可以改變；
第二個是語法錯誤；
第三個第四個a、b的值都不能改變；
另外，int * const a,a的值不能改變，*a的值可以改變。
最后得出答案：C和D相同

內聯函數在編譯時是否做參數類型檢查？
A、不做檢查，和宏一樣
B、做類型檢查
C、和編譯器相關
先說宏和函數的區別：

宏做的是簡單的字符串替換(注意是字符串的替換,不是其他類型參數的替換),而函數的參數的傳遞,參數是有數據類型的,可以是各種各樣的類型.
宏的參數替換是不經計算而直接處理的,而函數調用是將實參的值傳遞給形參,既然說是值,自然是計算得來的.
宏在編譯之前進行,即先用宏體替換宏名,然后再編譯的,而函數顯然是編譯之后,在執行時,才調用的.因此,宏占用的是編譯的時間,而函數占用的是執行時的時間.
宏的參數是不占內存空間的,因為只是做字符串的替換,而函數調用時的參數傳遞則是具體變量之間的信息傳遞,形參作為函數的局部變量,顯然是占用內存的.
函數的調用是需要付出一定的時空開銷的,因為系統在調用函數時,要保留現場,然后轉入被調用函數去執行,調用完,再返回主調函數,此時再恢復現場,這些操作,顯然在宏中是沒有的.
內聯函數與宏的區別：
1.內聯函數在運行時可調試，而宏定義不可以;
2.編譯器會對內聯函數的參數類型做安全檢查或自動類型轉換（同普通函數），而宏定義則不會；
3.內聯函數可以訪問類的成員變量，宏定義則不能；
4.在類中聲明同時定義的成員函數，自動轉化為內聯函數。　
答案：B

大唐電信
　　DTT筆試題
　　考試時間一小時，第一部分是填空和選擇：
　　1．數列6，10，18，32，“？”，問“？”是幾？
　　2．某人出70買進一個x，80賣出，90買回，100賣出，這樁買賣怎么樣？
　　3．月球繞地球一圈，至少要多少時間？
　　4．7個人用7小時挖了7米的溝，以同樣的速度在50小時挖50米的溝要多少人？
　　5．魚頭長9，魚尾等于魚頭加半個魚身，魚身等于魚頭加魚尾，問魚全長多少？
　　6．一個小姐買了一塊手表，回家發現手表比她家的表慢了兩分鐘，晚上看新聞的時候又發現她家的表比新聞里的時間慢了兩分鐘，則 。
　　A 手表和新聞里的時間一樣
　　B 手表比新聞里的時間慢
　　C 手表比新聞里的時間快
　　7．王先生看到一則招聘啟事，發現兩個公司除了以下條件不同外，其他條件都相同
　　A 半年年薪50萬，每半年漲5萬
　　B 一年年薪100萬，每一年漲20萬
　　王先生想去一家待遇比較優厚的公司，他會去哪家？
　　10．問哪個袋子里有金子？
　　A袋子上的標簽是這樣寫的：B袋子上的話是對的，金子在A袋子。
　　B袋子上的標簽是這樣寫的：A袋子上的話是錯的，金子在A袋子里。
　　11．3個人住酒店30塊錢，經理找回5塊錢，服務生從中藏了2塊錢，找給每人1塊錢，
3×（10?1）+2=29，問這是怎么回事？
　　12．三篇寫作，均為書信形式。
　　（1）一片中文的祝賀信，祝賀某男當了某公司xx
　　（2）兩篇英文的，一是說有事不能應邀，派別人去；另一篇是討債的，7天不給錢就
走人（主要考business letter格式）。

大唐面試試題
　　1．什么是中斷？中斷發生時CPU做什么工作？
　　2．CPU在上電后，進入操作系統的main()之前必須做什么工作？
　　3．簡述ISO OSI的物理層Layer1，鏈路層Layer2，網絡層Layer3的任務。
　　4．有線電話和無線電話有何區別？無線電話特別需要注意的是什么？
　　5.軟件開發五個主要step是什么？
　　6．你在開發軟件的時候，這5個step分別占用的時間百分比是多少？
　　7．makefile文件的作用是什么？
　　8．UNIX顯示文件夾中，文件名的命令是什么？能使文件內容顯示在屏幕的命令是什么？
　　9．（選做）手機用戶在從一個基站漫游到另一個基站的過程中，都會發生什么?

網通筆試題
　　選擇題（每題5分，只有一個正確答案）
　　1．中國1號信令協議屬于 的協議。
　　A ccs B cas C ip D atm
　　2．isdnpri協議全稱是 。
　　A 綜合業務模擬網基速協議
　　B 綜合業務模擬網模擬協議
　　C 綜合業務數字網基率協議
　　D 綜合業務數字網基次協議
　　3．路由協議中， 協議是用距離作為向量的。
　　A ospf B bgp C is-is D rip
　　4．中國智能網中，ssp與scp間最上層的ss7協議是 。
　　A incs B is41b C is41c D inap
　　5．dtmf全稱是 。
　　A 雙音多頻 B多音雙頻C多音三頻 D三音多頻
　　6．計算機的基本組成部分中，不包含下面設備的是 。
　　A cpu B輸入設備 C存儲器D接口
　　7．脈沖編碼調制的簡稱是 。
　　A pcm B pam C (delta)M D atm
　　8．普通電話線接口專業稱呼是 。
　　A rj11 B rj45 C rs232 D bnc
　　9．現有的公共數據網都采用 。
　　A電路交換技術 B報文交換技術
　　C語音插空 D分組交換
　　10．ss7協議中的制止市忙消息簡寫為 。
　　A stb B slb C sub D spb
　　簡答題（每題10分）
　　1．簡述普通電話與IP電話的區別。
　　2．簡述隨路信令與公路信令的根本區別。
　　3．說明掩碼的主要作用。
　　4．ss7協議中，有三大要素決定其具體定位，哪三大要素？
　　5．描述ss7的基本通話過程。
　　6．簡述通信網的組成結構。
　　7．面向連接與面向非連接各有何利弊？
　　8．寫出愛爾蘭的基本計算公式。
　　9．數據網主要有哪些設備？
　　10．中國一號協議是如何在被叫號碼中插入主叫號碼的？

東信筆試題目
　　筆試：30分鐘。
　　1．壓控振蕩器的英文縮寫。
　　2．動態隨機存儲器的英文縮寫。
　　3．選擇電阻時要考慮什么？
　　4．單片機上電后沒有運轉，首先要檢查什么？
　　5．計算機的基本組成部分及其各自的作用。
　　6．怎樣用D觸發器、與或非門組成二分頻電路？

static有什么用途？（請至少說明兩種）
答案一

在函數體，一個被聲明為靜態的變量在這一函數被調用過程中維持其值不變。
在模塊內（但在函數體外），一個被聲明為靜態的變量可以被模塊內所用函數訪問，但不能被模塊外其它函數訪問。它是一個本地的全局變量。
在模塊內，一個被聲明為靜態的函數只可被這一模塊內的其它函數調用。那就是，這個函數被限制在聲明它的模塊的本地范圍內使用
答案二：
在C語言中，static主要定義全局靜態變量，定義局部靜態變量，定義靜態函數
一、 定義全局靜態變量 ：在全局變量前面加上關鍵字static，該全局變量變成了全局靜態變量。全局靜態變量有以下特點：
（1） 在全局數據區內分配內存
（2） 如果沒有初始化，其默認值為0
（3） 該變量在本文件內從定義開始到文件結束可見
二、 定義局部靜態變量：在局部靜態變量前面加上關鍵字static，該局部變量便成了靜態局部變量。靜態局部變量有以下特點:
（1） 該變量在全局數據區分配內存
（2） 如果不顯示初始化，那么將被隱式初始化為0
（3） 它始終駐留在全局數據區，直到程序運行結束
（4） 其作用域為局部作用域，當定義它的函數或語句塊結束時，其作用域隨之結束。
三、 定義靜態函數：在函數的返回類型加上static關鍵字，函數即被定義成靜態函數。靜態函數有以下特點：
（1） 靜態函數只能在本源文件中使用
（2） 在文件作用域中聲明的inline函數默認為static
說明：靜態函數只是一個普通的全局函數，只不過受static限制，他只能在文件坐在的編譯單位內使用，不能呢個在其他編譯單位內使用。
在C++語言中新增了兩種作用：定義靜態數據成員或靜態函數成員
（1） 定義靜態數據成員。靜態數據成員有如下特點：
（1） 內存分配：在程序的全局數據區分配
（2） 初始化和定義：靜態數據成員定義時要分配空間，所以不能在類聲明中定義
（3） 靜態成員函數。靜態成員函數與類相聯系，不與類的對象相聯系。靜態成員函數不能訪問非靜態數據成員。原因很簡單，非靜態數據成員屬于特定的類實例，主要用于對靜態數據成員的操作。
（4） 靜態成員函數和靜態數據成員都沒有this指針。

答案三：
1、全局靜態變量
在全局變量前加上關鍵字static，全局變量就定義成一個全局靜態變量。
靜態存儲區，在整個程序運行期間一直存在。
初始化：未經初始化的全局靜態變量會被自動初始化為0（自動對象的值是任意的，除非他被顯式初始化）。
作用域：全局靜態變量在聲明他的文件之外是不可見的，準確地說是從定義之處開始，到文件結尾。
2、局部靜態變量
在局部變量之前加上關鍵字static，局部變量就成為一個局部靜態變量。
內存中的位置：靜態存儲區。
初始化：未經初始化的全局靜態變量會被自動初始化為0（自動對象的值是任意的，除非他被顯式初始化）。
作用域：作用域仍為局部作用域，當定義它的函數或者語句塊結束的時候，作用域結束。但是當局部靜態變量離開作用域后，并沒有銷毀，而是仍然駐留在內存當中，只不過我們不能再對它進行訪問，直到該函數再次被調用，并且值不變。
3.、靜態函數
在函數返回類型前加static，函數就定義為靜態函數。函數的定義和聲明在默認情況下都是extern的，但靜態函數只是在聲明他的文件當中可見，不能被其他文件所用。
函數的實現使用static修飾，那么這個函數只可在本cpp內使用，不會同其他cpp中的同名函數引起沖突。
warning：不要再頭文件中聲明static的全局函數，不要在cpp內聲明非static的全局函數，如果你要在多個cpp中復用該函數，就把它的聲明提到頭文件里去，否則cpp內部聲明需加上static修飾。
4.、類的靜態成員
在類中，靜態成員可以實現多個對象之間的數據共享，并且使用靜態數據成員還不會破壞隱藏的原則，即保證了安全性。因此，靜態成員是類的所有對象中共享的成員，而不是某個對象的成員。對多個對象來說，靜態數據成員只存儲一處，供所有對象共用。
5.、類的靜態函數
靜態成員函數和靜態數據成員一樣，它們都屬于類的靜態成員，它們都不是對象成員。因此，對靜態成員的引用不需要用對象名。
在靜態成員函數的實現中不能直接引用類中說明的非靜態成員，可以引用類中說明的靜態成員（這點非常重要）。如果靜態成員函數中要引用非靜態成員時，可通過對象來引用。從中可看出，調用靜態成員函數使用如下格式：<類名>::<靜態成員函數名>(<參數表>);

引用與指針有什么區別？
指針有自己的一塊空間，而引用只是一個別名；
使用sizeof看一個指針的大小是4，而引用則是被引用對象的大小；
指針可以被初始化為NULL，而引用必須被初始化且必須是一個已有對象 的引用；
作為參數傳遞時，指針需要被解引用才可以對對象進行操作，而直接對引 用的修改都會改變引用所指向的對象；
可以有const指針，但是沒有const引用；
指針在使用中可以指向其它對象，但是引用只能是一個對象的引用，不能 被改變；
指針可以有多級指針（**p），而引用至于一級；
指針和引用使用++運算符的意義不一樣；
如果返回動態內存分配的對象或者內存，必須使用指針，引用可能引起內存泄露。
描述實時系統的基本特性
特定時間內完成特定的任務，實時性與可靠性。
所謂“實時操作系統”，實際上是指操作系統工作時，其各種資源可以根據需要隨時進行動態分配。由于各種資源可以進行動態分配，因此其處理事務的能力較強、速度較快。
應該說，實時操作系統是在早期的操作系統基礎上發展起來的，早期的操作系統的各種資源都是事先已經分配好的，工作期間這些資源不能再重新進行分配。因此其處理事務的能力較差、速度較慢，現在則稱之為“非實時操作系統”。但“非實時操作系統”誕生時，其功能、性能等在當時也是非常強的，人們在未認識到更好的操作系統之前并不將其這樣稱呼。將來如果新的、功能更強的、實時性能更高的操作系統出現，也許現在稱之為“實時”的操作系統則可能將讓位于新的“實時操作系統”了。從這方面講“實時操作系統”是一個相對的概念的。

全局變量和局部變量在內存中是否有區別？如果有，是什么區別？
生存周期不同
全局變量:全局區(靜態區)(static)：全局變量和靜態變量是存儲在一起的，初始化過的全局變量和靜態變量在同一塊區域，未初始化的全局變量和靜態變量存放在一塊相鄰的區域內。此區域由系統在程序結束后釋放 局部變量： 放在堆棧中。由編譯器自動分配釋放，存放函數的參數值，局部變量的值等。其操作方式類似于數據結構中的棧
作用范圍不同
全局變量具有全局作用域。全局變量只需在一個源文件中定義，就可以作用于所有的源文件。當然，其他不包含全局變量定義的源文件需要用extern 關鍵字再次聲明這個全局變量。 局部變量也只有局部作用域，它是自動對象(auto)，它在程序運行期間不是一直存在，而是只在函數執行期間存在，函數的一次調用執行結束后，變量被撤銷，其所占用的內存也被收回。
靜態變量分為 全局靜態變量(常稱為全局變量)和局部靜態變量(static修飾的變量)
什么是平衡二叉樹？
答 、左右子樹都是平衡二叉樹 且左右子樹的深度差值的絕對值不大于1。

堆棧溢出一般是由什么原因導致的？
答 、1.沒有回收垃圾資源
2.層次太深的遞歸調用

什么函數不能聲明為虛函數？
什么樣的函數不能聲明為虛函數？
1）不能被繼承的函數。
2）不能被重寫的函數。

1.普通函數（不能被覆蓋）
2.友元函數（C++不支持友元函數繼承）
3.內聯函數（編譯期間展開，虛函數是在運行期間綁定）
4.構造函數（沒有對象不能使用構造函數，先有構造函數后有虛函數，虛函數是對對象的動作）
5.靜態成員函數（只有一份大家共享)

1）普通函數
普通函數不屬于成員函數，是不能被繼承的。普通函數只能被重載，不能被重寫，因此聲明為虛函數沒有意義。因為編譯器會在編譯時綁定函數。
而多態體現在運行時綁定。通常通過基類指針指向子類對象實現多態。
2）友元函數
友元函數不屬于類的成員函數，不能被繼承。對于沒有繼承特性的函數沒有虛函數的說法。
3）構造函數
首先說下什么是構造函數，構造函數是用來初始化對象的。假如子類可以繼承基類構造函數，那么子類對象的構造將使用基類的構造函數，而基類構造函數并不知道子類的有什么成員，顯然是不符合語義的。從另外一個角度來講，多態是通過基類指針指向子類對象來實現多態的，在對象構造之前并沒有對象產生，因此無法使用多態特性，這是矛盾的。因此構造函數不允許繼承。
4）內聯成員函數
我們需要知道內聯函數就是為了在代碼中直接展開，減少函數調用花費的代價。也就是說內聯函數是在編譯時展開的。而虛函數是為了實現多態，是在運行時綁定的。因此顯然內聯函數和多態的特性相違背。
5）靜態成員函數
首先靜態成員函數理論是可繼承的。但是靜態成員函數是編譯時確定的，無法動態綁定，不支持多態，因此不能被重寫，也就不能被聲明為虛函數。

冒泡排序算法的時間復雜度是什么？
答 、O(n^2)

寫出float x 與“零值”比較的if語句。
答 、if(x>0.000001&&x<-0.000001)

Internet采用哪種網絡協議？該協議的主要層次結構？
答 、tcp/ip
應用層/傳輸層/網絡層/數據鏈路層/物理層

Internet物理地址和IP地址轉換采用什么協議？
答 、ARP (Address Resolution Protocol)（地址解析協議）

IP地址的編碼分為哪倆部分？
答 、IP地址由兩部分組成，網絡號和主機號。不過是要和“子網掩碼”按位與之后才能區分哪些是網絡位哪些是主機位。

用戶輸入M,N值，從1至N開始順序循環數數，每數到M輸出該數值，直至全部輸出。寫出C程序。
思路：循環鏈表，用取余操作做

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
typedef struct node
{
?? ?int data;
?? ?node* next;
}node;

void CreatList(node*& head, node*& tail, int n)
{
?? ?if (n < 1)
?? ?{
?? ??? ?head = tail = NULL;
?? ??? ?return;
?? ?}
?? ?head = new node();
?? ?head->data = 1;
?? ?head->next = NULL;
?? ?node* p = head;
?? ?for (int i = 2; i < n + 1; i++)
?? ?{
?? ??? ?p->next = new node();
?? ??? ?p = p->next;
?? ??? ?p->data = i;
?? ??? ?p->next = NULL;
?? ?}
?? ?tail = p;
?? ?tail->next = head;
}

void Print(node*& head)
{
?? ?node* p = head;
?? ?printf("創建出來的鏈表為：");
?? ?while (p && p->next != head)
?? ?{
?? ??? ?printf("%d->", p->data);
?? ??? ?p = p->next;
?? ?}
?? ?if (p)
?? ?{
?? ??? ?printf("%d\n", p->data);
?? ?}
}

void CountPrint(node*& head, node*& tail, int m)
{
?? ?node* pre = tail;
?? ?node* cur = head;
?? ?int cnt = m;
?? ?printf("取到的M值為： ");
?? ?while (cur && cur->next != cur)
?? ?{
?? ??? ?if (cnt != 1)
?? ??? ?{
?? ??? ??? ?cnt--;
?? ??? ??? ?pre = cur;
?? ??? ??? ?cur = cur->next;
?? ??? ?}
?? ??? ?else
?? ??? ?{
?? ??? ??? ?printf("%d, ", cur->data);
?? ??? ??? ?pre->next = cur->next;
?? ??? ??? ?delete cur;
?? ??? ??? ?cur = pre->next;
?? ??? ??? ?cnt = m;
?? ??? ?}
?? ?}
?? ?if (cur)
?? ?{
?? ??? ?printf("%d\n", cur->data);
?? ??? ?delete cur;
?? ??? ?head = tail = NULL;
?? ?}
}

int main()
{
?? ?node* head;
?? ?node* tail;
?? ?int m;
?? ?int n;
?? ?printf("請輸入N的值：");
?? ?scanf_s("%d", &n);
?? ?printf("請輸入M的值：");
?? ?scanf_s("%d", &m);
?? ?CreatList(head, tail, n);
?? ?Print(head);
?? ?CountPrint(head, tail, m);
?? ?system("pause");
?? ?return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
運行效果圖：

不能做switch()的參數類型是：
答 、switch的參數不能為實型。

局部變量能否和全局變量重名？
答、能，局部會屏蔽全局。要用全局變量，需要使用"::"
局部變量可以與全局變量同名，在函數內引用這個變量時，會用到同名的局部變量，而不會用到全局變量。對于有些編譯器而言，在同一個函數內可以定義多個同名的局部變量，比如在兩個循環體內都定義一個同名的局部變量，而那個局部變量的作用域就在那個循環體內

如何引用一個已經定義過的全局變量？
答 、可以用引用頭文件的方式，也可以用extern關鍵字，如果用引用頭文件方式來引用某個在頭文件中聲明的全局變理，假定你將那個變寫錯了，那么在編譯期間會報錯，如果你用extern方式引用時，假定你犯了同樣的錯誤，那么在編譯期間不會報錯，而在連接期間報錯

全局變量可不可以定義在可被多個.C文件包含的頭文件中？為什么？
答 、可以，在不同的C文件中以static形式來聲明同名全局變量。
可以在不同的C文件中聲明同名的全局變量，前提是其中只能有一個C文件中對此變量賦初值，此時連接不會出錯

語句for( ；1 ；)有什么問題？它是什么意思？
答 、死循環或者說無限循環。和while(1)相同。

do……while和while……do有什么區別？
答 、前一個循環一遍再判斷，后一個判斷以后再循環

請寫出下列代碼的輸出內容
#include<stdio.h>
void main()
{
?? ?int a, b, c, d;
?? ?a = 10;
?? ?b = a++;
?? ?c = ++a;
?? ?d = 10 * a++;
?? ?printf("b, c, d: %d, %d, %d", b, c, d);
?? ?return;
}
1
2
3
4
5
6
7
8
9
10
11
運行效果圖：

答 、10，12，120

static 全局變量、局部變量、函數與普通全局變量、局部變量、函數
static全局變量與普通的全局變量有什么區別？static局部變量和普通局部變量有什么區別？static函數與普通函數有什么區別？
答 、全局變量(外部變量)的說明之前再冠以static 就構成了靜態的全局變量。全局變量本身就是靜態存儲方式， 靜態全局變量當然也是靜態存儲方式。 這兩者在存儲方式上并無不同。這兩者的區別雖在于非靜態全局變量的作用域是整個源程序， 當一個源程序由多個源文件組成時，非靜態的全局變量在各個源文件中都是有效的。 而靜態全局變量則限制了其作用域， 即只在定義該變量的源文件內有效， 在同一源程序的其它源文件中不能使用它。由于靜態全局變量的作用域局限于一個源文件內，只能為該源文件內的函數公用， 因此可以避免在其它源文件中引起錯誤。
從以上分析可以看出， 把局部變量改變為靜態變量后是改變了它的存儲方式即改變了它的生存期。把全局變量改變為靜態變量后是改變了它的作用域， 限制了它的使用范圍。
static函數與普通函數作用域不同。僅在本文件。只在當前源文件中使用的函數應該說明為內部函數(static)，內部函數應該在當前源文件中說明和定義。對于可在當前源文件以外使用的函數，應該在一個頭文件中說明，要使用這些函數的源文件要包含這個頭文件
static全局變量與普通的全局變量有什么區別：static全局變量只初使化一次，防止在其他文件單元中被引用;
static局部變量和普通局部變量有什么區別：static局部變量只被初始化一次，下一次依據上一次結果值；
static函數與普通函數有什么區別：static函數在內存中只有一份，普通函數在每個被調用中維持一份拷貝程序的局部變量存在于（堆棧）中，全局變量存在于（靜態區 ）中，動態申請數據存在于（ 堆）中。
設有以下說明和定義：
typedef union
{?
?? ?long i;?
?? ?int k[5];
?? ?char c;?
} DATE;//4

struct data?
{?
?? ?int cat; //4
?? ?DATE cow;//8
?? ?double dog;//8
}too;
DATE max;

void main()
{
?? ?printf("結構體cat size:%d\n", sizeof(too.cat));
?? ?printf("結構體cow size:%d\n", sizeof(too.cow));
?? ?printf("結構體dog size:%d\n", sizeof(too.dog));
?? ?printf("結構體size:%d\n", sizeof(too));
?? ?printf("聯合體max size:%d\n", sizeof(max));
?? ?printf("最終結果:%d", sizeof(too) + sizeof(max));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
執行效果圖：

則語句 printf("%d",sizeof(too)+sizeof(max));的執行結果是？
答 、結果是：52_。DATE是一個union, 變量公用空間. 里面最大的變量類型是int[5],占用20個字節. 所以它的大小是20
data是一個struct, 每個變量分開占用空間.依次為int4 + DATE20 + double8 =32.
所以結果是 20 + 32 = 52.
當然…在某些16位編輯器下, int可能是2字節,那么結果是 int2 + DATE10 + double8 =20

-1,2,7,28,126請問28和126中間那個數是什么？為什么？
答 、應該是4^3-1=63
規律是n^3-1(當n為偶數0，2，4)
n^3+1(當n為奇數1，3，5)

用兩個棧實現一個隊列的功能？要求給出算法和思路！
答 、設2個棧為A,B,一開始均為空.
入隊:
將新元素push入棧A;
出隊:
(1)判斷棧B是否為空；
(2)如果不為空，則將棧A中所有元素依次pop出并push到棧B；
(3)將棧B的棧頂元素pop出；
這樣實現的隊列入隊和出隊的平攤復雜度都還是O(1), 比上面的幾種方法要好。

在c語言庫函數中將一個字符轉換成整型的函數是atool()嗎，這個函數的原型是什么？
答 、函數名: atol
功 能: 把字符串轉換成長整型數
用 法: long atol(const char *nptr);
程序例:

#include<stdio.h>
#include<iostream>
using namespace std;
int char2int(const char *str)
{
?? ?int value = 0;
?? ?int neg = 0;
?? ?switch (*str)
?? ?{
?? ?case '-':
?? ??? ?neg = 1;
?? ??? ?/* 這里沒有break */
?? ?case '+':
?? ??? ?str++;
?? ??? ?break;
?? ?}
?? ?while (*str >= '0' && *str <= '9')
?? ?{
?? ??? ?value *= 10;
?? ??? ?value += *str - '0';
?? ??? ?str++;
?? ?}
?? ?return value;
}

long char2long(const char *s)
{
?? ?long r = 0;
?? ?int neg = 0;
?? ?switch (*s)
?? ?{
?? ?case '-':
?? ??? ?neg = 1;
?? ??? ?/* 這里沒有break */
?? ?case '+':
?? ??? ?s++;
?? ??? ?break;
?? ?}
?? ?while (*s >= '0' && *s <= '9')
?? ?{
?? ??? ?int n = *s++ - '0';
?? ??? ?if (neg)
?? ??? ??? ?n = -n;
?? ??? ?r = r * 10 + n;
?? ?}
?? ?return r;
}

int main(void)
{
?? ?long l,i;
?? ?const char *str = "9876543210";
?? ?i = char2int(str);
?? ?l = char2long(str);
?? ?printf("string = %s long =%ld\n", str, l);
?? ?printf("string = %s integer =%d\n", str, i);
?? ?return(0);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
對于一個頻繁使用的短小函數,在C語言中應用什么實現,在C++中應用什么實現?
答 、c用宏定義，c++用inline

用預處理指令#define 聲明一個常數，用以表明1年中有多少秒（忽略閏年問題）
#defineSECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在這想看到幾件事情：
1). #define 語法的基本知識（例如：不能以分號結束，括號的使用，等等）
2). 懂得預處理器將為你計算常數表達式的值，因此，直接寫出你是如何計算一年中有多少秒而不是計算出實際的值，是更清晰而沒有代價的。
3). 意識到這個表達式將使一個16位機的整型數溢出-因此要用到長整型符號L,告訴編譯器這個常數是的長整型數。
4). 如果你在你的表達式中用到UL（表示無符號長整型），那么你有了一個好的起點。記住，第一印象很重要。

寫一個“標準”宏MIN，這個宏輸入兩個參數并返回較小的一個。
#define MIN(A,B) ((A)<= (B) (A) : (B))
這個測試是為下面的目的而設的：

標識#define在宏中應用的基本知識。這是很重要的，因為直到嵌入(inline)操作符變為標準C的一部分，宏是方便產生嵌入代碼的唯一方法，
對于嵌入式系統來說，為了能達到要求的性能，嵌入代碼經常是必須的方法。
三重條件操作符的知識。這個操作符存在C語言中的原因是它使得編譯器能產生比if-then-else更優化的代碼，了解這個用法是很重要的。
懂得在宏中小心地把參數用括號括起來
我也用這個問題開始討論宏的副作用，例如：當你寫下面的代碼時會發生什么事？
least = MIN(*p++, b);
預處理器標識#error的目的是什么？
編譯程序時，只要遇到 #error 就會跳出一個編譯錯誤，既然是編譯錯誤，要它干嘛呢？其目的就是保證程序是按照你所設想的那樣進行編譯的。

嵌入式系統中經常要用到無限循環，你怎么樣用C編寫死循環呢？
這個問題用幾個解決方案。我首選的方案是：

while(1)
{
}
1
2
3
一些程序員更喜歡如下方案：

for (; ; )
{
}
1
2
3
這個實現方式讓我為難，因為這個語法沒有確切表達到底怎么回事。如果一個應試者給出這個作為方案，我將用這個作為一個機會去探究他們這樣做的
基本原理。如果他們的基本答案是：“我被教著這樣做，但從沒有想到過為什么。”這會給我留下一個壞印象。
第三個方案是用 goto

Loop:
...
goto Loop;
1
2
3
應試者如給出上面的方案，這說明或者他是一個匯編語言程序員（這也許是好事）或者他是一個想進入新領域的BASIC/FORTRAN程序員。

用變量a給出下面的定義
a) 一個整型數（An integer）
b) 一個指向整型數的指針（A pointer to an integer）
c) 一個指向指針的的指針，它指向的指針是指向一個整型數（A pointer to a pointer toan integer）
d) 一個有10個整型數的數組（Anarray of 10 integers）
e) 一個有10個指針的數組，該指針是指向一個整型數的（Anarray of 10 pointers to integers）
f) 一個指向有10個整型數數組的指針（Apointer to an array of 10 integers）
g) 一個指向函數的指針，該函數有一個整型參數并返回一個整型數（A pointer to a functionthat takes an integer as an argument and returns an integer）
h) 一個有10個指針的數組，該指針指向一個函數，該函數有一個整型參數并返回一個整型數（An array of ten pointers to functions that take an integer
argument and returnan integer ）

答案是：

a) int a; // Aninteger
b) int *a; // Apointer to an integer
c) int **a; // Apointer to a pointer to an integer
d) int a[10]; // Anarray of 10 integers
e) int *a[10]; // Anarray of 10 pointers to integers
f) int (*a)[10]; // Apointer to an array of 10 integers
g) int (*a)(int); //A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int);// An array of 10 pointers to functions that take an integer argument andreturn an integer

人們經常聲稱這里有幾個問題是那種要翻一下書才能回答的問題，我同意這種說法。當我寫這篇文章時，為了確定語法的正確性，我的確查了一下書。
但是當我被面試的時候，我期望被問到這個問題（或者相近的問題）。因為在被面試的這段時間里，我確定我知道這個問題的答案。應試者如果不知道
所有的答案（或至少大部分答案），那么也就沒有為這次面試做準備，如果該面試者沒有為這次面試做準備，那么他又能為什么出準備呢？

關鍵字static的作用是什么？
這個簡單的問題很少有人能回答完全。在C語言中，關鍵字static有三個明顯的作用：

在函數體，一個被聲明為靜態的變量在這一函數被調用過程中維持其值不變。
在模塊內（但在函數體外），一個被聲明為靜態的變量可以被模塊內所用函數訪問，但不能被模塊外其它函數訪問。它是一個本地的全局變量。
在模塊內，一個被聲明為靜態的函數只可被這一模塊內的其它函數調用。那就是，這個函數被限制在聲明它的模塊的本地范圍內使用。
關鍵字const是什么含意？
1）使用Const關鍵字的地方是為了說明這個參數為常量，是不應該被修改的。
2）合理使用const 可以是編譯器自然的保護那些不希望被修改的參數，防止被無意的代碼修改。
3）通過給優化器一些有用的信息，使用關鍵字const也許是代碼更加緊湊。
下面的聲明都是什么意思？
1）const int a;
2）int const a;
3）const int *a;
4）int * const a;
5）int const * a const;

1） a是一個常整數；
2） a是一個常整數；
3） a是一個指向常整形的指針
4） a是一個指向整型的常指針；
5） a是一個指向常整型的常指針；

關鍵字volatile有什么含意 并給出三個不同的例子。
一個定義為volatile的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到這個變量時必須每次都小心地重新讀取這個變量的值，而不是使用保存在寄存器里的備份。下面是volatile變量的幾個例子：

1). 并行設備的硬件寄存器（如：狀態寄存器）
2). 一個中斷服務子程序中會訪問到的非自動變量(Non-automatic variables)
3). 多線程應用中被幾個任務共享的變量

1). 一個參數既可以是const還可以是volatile嗎？解釋為什么。
2). 一個指針可以是volatile 嗎？解釋為什么。
3). 下面的函數有什么錯誤：

int square(volatileint *ptr)
{
?? ?return *ptr * *ptr;
}
1
2
3
4
下面是答案：
1). 是的。一個例子是只讀的狀態寄存器。它是volatile因為它可能被意想不到地改變。它是const因為程序不應該試圖去修改它。
2). 是的。盡管這并不很常見。一個例子是當一個中服務子程序修該一個指向一個buffer的指針時。
3). 這段代碼的有個惡作劇。這段代碼的目的是用來返指針ptr指向值的平方，但是，由于ptr指向一個volatile型參數，編譯器將產生類似下面的代碼：

int square(volatileint *ptr)
{
?? ?int a,b;
?? ?a = *ptr;
?? ?b = *ptr;
?? ?return a * b;
}
1
2
3
4
5
6
7
由于*ptr的值可能被意想不到地該變，因此a和b可能是不同的。結果，這段代碼可能返不是你所期望的平方值！正確的代碼如下：

long square(volatile int *ptr)
{
?? ?int a;
?? ?a = *ptr;
?? ?return a * a;
}
1
2
3
4
5
6
位操作（Bit manipulation）
下面的代碼輸出是什么，為什么？
void foo(void)
{
?? ?unsigned int a = 6;
?? ?int b = -20;
?? ?(a + b > 6)puts("> 6") : puts("<= 6");
}
1
2
3
4
5
6
這個問題測試你是否懂得C語言中的整數自動轉換原則，我發現有些開發者懂得極少這些東西。不管如何，這無符號整型問題的答案是輸出是“>6”。原因是當表達式中存在有符號類型和無符號類型時所有的操作數都自動轉換為無符號類型。因此-20變成了一個非常大的正整數，所以該表達式計算出的結果大于6。這一點對于應當頻繁用到無符號數據類型的嵌入式系統來說是豐常重要的。如果你答錯了這個問題，你也就到了得不到這份工作的邊緣。

C語言同意一些令人震驚的結構,下面的結構是合法的嗎，如果是它做些什么？
int a = 5, b = 7, c;
c = a+++b;
這個問題將做為這個測驗的一個愉快的結尾。不管你相不相信，上面的例子是完全合乎語法的。問題是編譯器如何處理它？水平不高的編譯作者實際上會爭論這個問題，根據最處理原則，編譯器應當能處理盡可能所有合法的用法。因此，上面的代碼被處理成：
c = a++ + b;
因此, 這段代碼持行后a= 6, b = 7, c = 12。
如果你知道答案，或猜出正確答案，做得好。如果你不知道答案，我也不把這個當作問題。我發現這個問題的最大好處是:這是一個關于代碼編寫風格，代碼的可讀性，代碼的可修改性的好的話題

線形表a、b為兩個有序升序的線形表，編寫一程序，使兩個有序線形表合并成一個有序升序線形表h；
#include<stdio.h>
#include<malloc.h>

struct Node
{
?? ?int data;
?? ?Node *next;
};

void Create(Node **root)
{
?? ?Node *p, *q;
?? ?int count;

?? ?if (NULL == *root)
?? ??? ?return;
?? ?p = *root;
?? ?printf("請輸入節點的個數:");
?? ?scanf_s("%d", &count);
?? ?for (int i = 0; i < count; i++)
?? ?{
?? ??? ?q = (Node*)malloc(sizeof(Node));
?? ??? ?printf("請輸入節點數據:");
?? ??? ?scanf_s("%d", &(q->data));
?? ??? ?p->next = q;
?? ??? ?p = q;
?? ??? ?p->next = NULL;
?? ?}
}

Node * Combine(Node *root1, Node *root2)
{
?? ?Node *root3 = (Node*)malloc(sizeof(Node));
?? ?Node *p1, *p2, *p3;
?? ?p1 = root1->next;
?? ?p2 = root2->next;
?? ?p3 = root3;
?? ?while (p1 != NULL && p2 != NULL)
?? ?{
?? ??? ?if (p1->data < p2->data)
?? ??? ?{
?? ??? ??? ?p3->next = p1;
?? ??? ??? ?p3 = p3->next;
?? ??? ??? ?p1 = p1->next;

?? ??? ?}
?? ??? ?else
?? ??? ?{
?? ??? ??? ?p3->next = p2;
?? ??? ??? ?p3 = p3->next;
?? ??? ??? ?p2 = p2->next;
?? ??? ?}
?? ?}
?? ?while (p1 == NULL && p2 != NULL)
?? ?{
?? ??? ?p3->next = p2;
?? ??? ?p3 = p3->next;
?? ??? ?p2 = p2->next;
?? ?}
?? ?while (p2 == NULL && p1 != NULL)
?? ?{
?? ??? ?p3->next = p1;
?? ??? ?p3 = p3->next;
?? ??? ?p1 = p1->next;
?? ?}
?? ?return root3;
}

int main()
{
?? ?Node *root1, *root2, *Combine_Root;
?? ?Node *p, *q;
?? ?root1 = (Node*)malloc(sizeof(Node));
?? ?root2 = (Node*)malloc(sizeof(Node));
?? ?Create(&root1);
?? ?Create(&root2);
?? ?Combine_Root = Combine(root1, root2);
?? ?for (p = Combine_Root->next; p != NULL; p = p->next)
?? ??? ?printf("%d", p->data);
?? ?free(root1);
?? ?free(root2);
?? ?for (p = Combine_Root; p != NULL; )
?? ?{
?? ??? ?q = p;
?? ??? ?p = p->next;
?? ??? ?free(q);
?? ?}
?? ?return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
用遞歸算法判斷數組a[N]是否為一個遞增數組。
思路：遞歸的方法，記錄當前最大的，并且判斷當前的是否比這個還大，大則繼續，否則返回false結束：

#include<stdio.h>

bool charge(int p[], int n)
{
?? ?if (n == 1)
?? ??? ?return true;
?? ?else
?? ?{
?? ??? ?if (p[n - 1] > p[n - 2])
?? ??? ?{
?? ??? ??? ?return charge(p, n - 1);
?? ??? ?}
?? ??? ?else
?? ??? ??? ?return false;
?? ?}
}

int main()
{
?? ?int a[5] = { 1,2,3,4,5 };
?? ?bool flag = false;
?? ?flag = charge(a, 5);
?? ?if (flag)
?? ??? ?printf("yes\n");
?? ?else
?? ??? ?printf("false\n");
?? ?system("pause");
?? ?return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
編寫算法，從10億個浮點數當中，選出其中最大的10000個。
用外部排序，在《數據結構》書上有《計算方法導論》在找到第n大的數的算法上加工

編寫一unix程序，防止僵尸進程的出現.
同學的4道面試題，應聘的職位是搜索引擎工程師，后兩道超級難，（希望大家多給一些算發）
1.給兩個數組和他們的大小，還有一動態開辟的內存，求交集，把交集放到動態內存dongtai，并且返回交集個數
long jiaoji(longa[],long b[],long alength,long blength,long* dongtai[])
2.單連表的建立，把’a’–'z’26個字母插入到連表中，并且倒敘，還要打印！
方法1：

typedef struct val
{
?? ?int date_1;
?? ?struct val *next;
}*p;

void main()
{
?? ?char c;
?? ?for (c = 122; c >= 97; c--)
?? ?{
?? ??? ?p.date = c;
?? ??? ?p = p->next;
?? ?}
?? ?p.next = NULL;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
方法2：

void main()
{
?? ?node *p = NULL;
?? ?node *q = NULL;
?? ?node *head = (node*)malloc(sizeof(node));
?? ?head->data = ''; head->next = NULL;
?? ?node *first = (node*)malloc(sizeof(node));
?? ?first->data = 'a'; first->next = NULL; head->next = first;
?? ?p = first;
?? ?int longth = 'z' - 'b';
?? ?int i = 0;
?? ?while (i <= longth)
?? ?{
?? ??? ?node *temp = (node*)malloc(sizeof(node));
?? ??? ?temp->data = 'b' + i; temp->next = NULL; q = temp;
?? ??? ?head->next = temp; temp->next = p; p = q;
?? ??? ?i++;
?? ?}
?? ?print(head);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
可怕的題目終于來了
象搜索的輸入信息是一個字符串，統計300萬輸入信息中的最熱門的前十條，我們每次輸入的一個字符串為不超過255byte,內存使用只有1G,
請描述思想，寫出算發（c語言），空間和時間復雜度，
7.國內的一些帖吧，如baidu,有幾十萬個主題，假設每一個主題都有上億的跟帖子，怎么樣設計這個系統速度最好，請描述思想，寫出算發（c語言），空間和時間復雜度，

#include <string.h>
void main(void)
{
?? ?char ?*src = "hello,world";
?? ?char ?*dest = NULL;
?? ?dest = (char ?*)malloc(strlen(src));
?? ?int ?len = strlen(str);
?? ?char ?*d = dest;
?? ?char ?*s = src[len];
?? ?while (len-- != 0)
?? ??? ?d++ = s--;
?? ?printf("%s", dest);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
找出錯誤！！

#include ? "string.h"
#include"stdio.h"
#include"malloc.h"
void main(void)
{
?? ?char ? *src = "hello,world";
?? ?char ?*dest = NULL;
?? ?dest = (char ?*)malloc(sizeof(char)*(strlen(src) + 1));
?? ?int ?len = strlen(src);
?? ?char ?*d = dest;
?? ?char ?*s = src + len - 1;
?? ?while (len-- != 0)
?? ??? ?*d++ = *s--;
?? ?*d = '\0';
?? ?printf("%s", dest);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
判斷字符串是否為回文
bool IsSymmetry(const char* p)
{
?? ?assert(p != NULL);
?? ?const char* q = p;
?? ?int len = 0;
?? ?while (*q++ != '\0')
?? ?{
?? ??? ?len++;
?? ?}
?? ?bool bSign = true;
?? ?q = p + len - 1;
?? ?if (0 < len)
?? ?{
?? ??? ?for (int i = 0; i < len / 2; i++)
?? ??? ?{
?? ??? ??? ?if (*p++ != *q--) { bSign = false; break; };
?? ??? ?}
?? ?}
?? ?if (bSign == true)
?? ?{
?? ??? ?printf("Yes!\n");
?? ?}
?? ?else
?? ?{
?? ??? ?printf("No!\n");
?? ?}
?? ?return bSign;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
ASDL使用的是什么協議？并進行簡單描述？
全稱Point to Point Protocol over Ethernet，意思是基于以太網的點對點協議。實質是以太網和撥號網絡之間的一個中繼協議，所以在網絡中，它的物理結構與原來的LAN接入方式沒有任何變化，只是用戶需要在保持原接入方式的基礎上，安裝一個PPPoE客戶端（這個是通用的）。之所以采用該方式給小區計時/計流量用戶，是方便計算時長和流量。此類用戶在使用上比包月用戶增加了PPPoE虛擬撥號的過程。電信的ADSL接入也是需要安裝使用PPPoE。

Static 作用是什么
全局靜態變量
在全局變量前加上關鍵字static，全局變量就定義成一個全局靜態變量.
靜態存儲區，在整個程序運行期間一直存在。
初始化：未經初始化的全局靜態變量會被自動初始化為0（自動對象的值是任意的，除非他被顯式初始化）；
作用域：全局靜態變量在聲明他的文件之外是不可見的，準確地說是從定義之處開始，到文件結尾。
局部靜態變量
在局部變量之前加上關鍵字static，局部變量就成為一個局部靜態變量。
內存中的位置：靜態存儲區
初始化：未經初始化的全局靜態變量會被自動初始化為0（自動對象的值是任意的，除非他被顯式初始化）；
作用域：作用域仍為局部作用域，當定義它的函數或者語句塊結束的時候，作用域結束。但是當局部靜態變量離開作用域后，并沒有銷毀，而是仍然駐留在內存當中，只不過我們不能再對它進行訪問，直到該函數再次被調用，并且值不變；
靜態函數
在函數返回類型前加static，函數就定義為靜態函數。函數的定義和聲明在默認情況下都是extern的，但靜態函數只是在聲明他的文件當中可見，不能被其他文件所用。
函數的實現使用static修飾，那么這個函數只可在本cpp內使用，不會同其他cpp中的同名函數引起沖突；
warning：不要再頭文件中聲明static的全局函數，不要在cpp內聲明非static的全局函數，如果你要在多個cpp中復用該函數，就把它的聲明提到頭文件里去，否則cpp內部聲明需加上static修飾；
類的靜態成員
在類中，靜態成員可以實現多個對象之間的數據共享，并且使用靜態數據成員還不會破壞隱藏的原則，即保證了安全性。因此，靜態成員是類的所有對象中共享的成員，而不是某個對象的成員。對多個對象來說，靜態數據成員只存儲一處，供所有對象共用
類的靜態函數
靜態成員函數和靜態數據成員一樣，它們都屬于類的靜態成員，它們都不是對象成員。因此，對靜態成員的引用不需要用對象名。
在靜態成員函數的實現中不能直接引用類中說明的非靜態成員，可以引用類中說明的靜態成員（這點非常重要）。如果靜態成員函數中要引用非靜態成員時，可通過對象來引用。從中可看出，調用靜態成員函數使用如下格式：<類名>::<靜態成員函數名>(<參數表>);
什么是預編譯,何時需要預編譯?
預編譯又稱為預處理,是做些代碼文本的替換工作。處理#開頭的指令,比如拷貝#include包含的文件代碼，#define宏定義的替換,條件編譯等，就是為編譯做的預備工作的階段，主要處理#開始的預編譯指令，預編譯指令指示了在程序正式編譯前就由編譯器進行的操作，可以放在程序中的任何位置。
c編譯系統在對程序進行通常的編譯之前，先進行預處理。c提供的預處理功能主要有以下三種：1）宏定義　2）文件包含　3）條件編譯
１、總是使用不經常改動的大型代碼體。
２、程序由多個模塊組成，所有模塊都使用一組標準的包含文件和相同的編譯選項。在這種情況下，可以將所有包含文件預編譯為一個預編譯頭。

進程和線程的區別
什么是進程（Process）：普通的解釋就是，進程是程序的一次執行，而什么是線程（Thread），線程可以理解為進程中的執行的一段程序片段。在一個多任務環境中下面的概念可以幫助我們理解兩者間的差別：
進程間是獨立的，這表現在內存空間，上下文環境；線程運行在進程空間內。 一般來講（不使用特殊技術）進程是無法突破進程邊界存取其他進程內的存儲空間；而線程由于處于進程空間內，所以同一進程所產生的線程共享同一內存空間。 同一進程中的兩段代碼不能夠同時執行，除非引入線程。線程是屬于進程的，當進程退出時該進程所產生的線程都會被強制退出并清除。線程占用的資源要少于進程所占用的資源。 進程和線程都可以有優先級。在線程系統中進程也是一個線程。可以將進程理解為一個程序的第一個線程。

線程是指進程內的一個執行單元,也是進程內的可調度實體與進程的區別:
(1)地址空間:進程內的一個執行單元;進程至少有一個線程;它們共享進程的地址空間;而進程有自己獨立的地址空間;
(2)進程是資源分配和擁有的單位,同一個進程內的線程共享進程的資源
(3)線程是處理器調度的基本單位,但進程不是.
(4)二者均可并發執行.

參考回答：
1）進程是cpu資源分配的最小單位，線程是cpu調度的最小單位。
2）進程有獨立的系統資源，而同一進程內的線程共享進程的大部分系統資源,包括堆、代碼段、數據段，每個線程只擁有一些在運行中必不可少的私有屬性，比如tcb,線程Id,棧、寄存器。
3）一個進程崩潰，不會對其他進程產生影響；而一個線程崩潰，會讓同一進程內的其他線程也死掉。
4）進程在創建、切換和銷毀時開銷比較大，而線程比較小。進程創建的時候需要分配系統資源，而銷毀的的時候需要釋放系統資源。進程切換需要分兩步：切換頁目錄、刷新TLB以使用新的地址空間；切換內核棧和硬件上下文（寄存器）；而同一進程的線程間邏輯地址空間是一樣的，不需要切換頁目錄、刷新TLB。
5）進程間通信比較復雜，而同一進程的線程由于共享代碼段和數據段，所以通信比較容易。

插入排序和選擇排序
插入排序基本思想：（假定從大到小排序）依次從后面拿一個數和前面已經排好序的數進行比較，比較的過程是從已經排好序的數中最后一個數開始比較，如果比這個數，繼續往前面比較，直到找到比它大的數，然后就放在它的后面，如果一直沒有找到，肯定這個數已經比較到了第一個數，那就放到第一個數的前面。那么一般情況下，對于采用插入排序法去排序的一組數，可以先選 取第一個數做為已經排好序的一組數。然后把第二個放到正確位置。

選擇排序(Selection Sort)是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再從剩余未排序元素中繼續尋找最小元素,然后放到排序序列末尾。以此類推,直到所有元素均排序完畢。

運算符優先級問題
能正確表示a和b同時為正或同時為負的邏輯表達式是(D )。
A、(a>=0||b>=0)＆＆(a<0||b<0)
B、(a>=0＆＆b>=0)&&(a<0&＆b<0)
C、(a+b>0)＆＆(a+b<=0)
D、a*b>0

以下關于運算符優先順序的描述中正確的是?。
A、關系運算符<算術運算符<賦值運算符<邏輯與運算符
B、邏輯與運算符<關系運算符<算術運算符<賦值運算符
C、賦值運算符<邏輯與運算符<關系運算符<算術運算符
D、算術運算符<關系運算符<賦值運算符<邏輯與運算符

字符串倒序
寫一個函數將"tom is cat" 倒序打印出來，即 “cat is tom”

#include <stdio.h>
#define SPACE ' '

void main()
{
?? ?const char* str = "Tom is cat"; // 字符串
?? ?char* p1 = (char *)str + strlen(str) - 1;
?? ?char* p2 = p1+1; // 開始時，p1,p2都指向字符串結尾處
?? ?char t = 0; // 臨時變量，用來保存被臨時替換為ENDL的字符
?? ?while (str != p1--)
?? ?{
?? ??? ?if (SPACE == *p1)?
?? ??? ?{
?? ??? ??? ?// p1+1指向單詞的第一個字母,p2指向單詞的結尾,此時輸出這個單詞
?? ??? ??? ?for (int i = 1; p1 + i != p2; ++i)
?? ??? ??? ?{
?? ??? ??? ??? ?cout << *(p1 + i);
?? ??? ??? ?}
?? ??? ??? ?cout << ' ';
?? ??? ??? ?p2 = p1;
?? ??? ?}
?? ??? ?if (str == p1)
?? ??? ?{
?? ??? ??? ?for (int i = 0; p1 + i != p2; ++i)
?? ??? ??? ?{
?? ??? ??? ??? ?cout << *(p1 + i);
?? ??? ??? ?}
?? ??? ??? ?cout << endl;
?? ??? ?}
?? ?}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
1)寫一個遞歸函數將內存中的字符串翻轉"abc"->“cba”

void str_reverse(char* p1, char* p2)
{
?? ?if (p1 == p2)
?? ??? ?return;
?? ?*p1 = (*p1) + (*p2);
?? ?*p2 = (*p1) - (*p2);
?? ?*p1 = (*p1) - (*p2);
?? ?if (p1 == p2 - 1)
?? ??? ?return;
?? ?else
?? ??? ?str_reverse(++p1, --p2);
}
void main()
{
?? ?char ptest[] = "abcdefg";
?? ?str_reverse(ptest, ptest + strlen(ptest) -1);
?? ?printf(ptest);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2)寫一個函數將"tom is cat" 將內存中的字符串翻轉，即 “cat istomm”

#include <stdio.h>
#define SPACE ' '
#define ENDL '\0'
char s[] = "The quick brown fox jumps over the lazy dog";
void str_reverse(char* p1, char* p2)
{
?? ?if (p1 == p2)
?? ??? ?return;
?? ?*p1 = (*p1) + (*p2);
?? ?*p2 = (*p1) - (*p2);
?? ?*p1 = (*p1) - (*p2);
?? ?if (p1 == p2 - 1)
?? ??? ?return;
?? ?else
?? ??? ?str_reverse(++p1, --p2);
}
void str_word_reverse(char* str)
{
?? ?char *q1 = str, *q2 = str, *t;
?? ?while (*q1 == SPACE)
?? ??? ?q1++;
?? ?if (*q1 == ENDL)
?? ??? ?return; //!
?? ?else
?? ??? ?q2 = q1 + 1;
?? ?while ((*q2 != SPACE) && (*q2 != ENDL))
?? ??? ?q2++;
?? ?t = q2--;
?? ?str_reverse(q1, q2);
?? ?if (*t == ENDL)
?? ??? ?return;
?? ?else
?? ??? ?str_word_reverse(t);
}

int main(int a, char** b)
{
?? ?printf("%s\n", s);
?? ?str_reverse(s, s + strlen(s) - 1);
?? ?printf("%s\n", s);
?? ?str_word_reverse(s);
?? ?printf("%s\n", s);
?? ?return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
Output:

The quick brown foxjumps over the lazy dog
god yzal eht revo spmuj xof nworb kciuq ehT
dog lazy the over jumps fox brown quick The

今天同學又問一道題,和上面有些類似，但是要求更嚴格了一些：
寫一個遞歸函數將內存中的字符串翻轉"abc"->“cba”,并且函數原型已確定：void reverse(char* p)
其實，要求越多，思路越確定，我的解如下：

#include <stdio.h>
#include <string.h>
char s[] = "0123456789";
#define ENDL '\0'
void reverse(char* p)
{
?? ?//這是這種方法的關鍵，使用static為的是能用str_reverse的思路，但是不好
?? ?static char* x = 0;
?? ?if (x == 0)
?? ??? ?x = p;
?? ?char* q = x + strlen(p) - 1;
?? ?if (p == q)
?? ??? ?return;
?? ?*q = (*p) ^ (*q);
?? ?*p = (*p) ^ (*q);
?? ?*q = (*p) ^ (*q);
?? ?if (q == p + 1)
?? ??? ?return;
?? ?reverse(++p);
}

//這種方法就直觀多了，但是當字符串很長的時候就很低效
void reverse2(char* p)
{
?? ?if (*(p + 1) == ENDL)
?? ??? ?return;
?? ?char* o = p + strlen(p) - 1;
?? ?char t = *o;
?? ?for (; o != p; o--)
?? ??? ?*o = *(o - 1);
?? ?*p = t;
?? ?reverse2(p + 1);
}

int main(int c, char**argv)
{
?? ?reverse2(s);
?? ?printf("%s\n", s);
?? ?return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
交換兩個數的宏定義
交換兩個參數值的宏定義為：

#define SWAP(a,b) (a)=(a)+(b);(b)=(a)-(b);(a)=(a)-(b);
1
Itearator各指針的區別
游標和指針
我說過游標是指針，但不僅僅是指針。游標和指針很像，功能很像指針，但是實際上，游標是通過重載一元的”*”和”->”來從容器中間接地返回一個值。將這些值存儲在容器中并不是一個好主意，因為每當一個新值添加到容器中或者有一個值從容器中刪除，這些值就會失效。在某種程度上，游標可以看作是句柄（handle）。通常情況下游標（iterator）的類型可以有所變化，這樣容器也會有幾種不同方式的轉變：
iterator——對于除了vector以外的其他任何容器，你可以通過這種游標在一次操作中在容器中朝向前的方向走一步。這意味著對于這種游標你只能使用“++”操作符。而不能使用“–”或“+=”操作符。而對于vector這一種容器，你可以使用“+=”、“—”、“++”、“-=”中的任何一種操作符和“<”、“<=”、“>”、“>=”、“==”、“!=”等比較運算符。

C++中的class和struct的區別
從語法上，在C++中（只討論C++中）。class和struct做類型定義時只有兩點區別：
（一）默認繼承權限。如果不明確指定，來自class的繼承按照private繼承處理，來自struct的繼承按照public繼承處理；
（二）成員的默認訪問權限。class的成員默認是private權限，struct默認是public權限。
除了這兩點，class和struct基本就是一個東西。語法上沒有任何其它區別。

不能因為學過C就總覺得連C++中struct和class都區別很大，下面列舉的說明可能比較無聊，因為struct和class本來就是基本一樣的東西，無需多說。但這些說明可能有助于澄清一些常見的關于struct和class的錯誤認識：
（1）都可以有成員函數；包括各類構造函數，析構函數，重載的運算符，友元類，友元結構，友元函數，虛函數，純虛函數，靜態函數；
（2）都可以有一大堆public/private/protected修飾符在里邊；
（3）雖然這種風格不再被提倡，但語法上二者都可以使用大括號的方式初始化：
A a = {1, 2, 3};不管A是個struct還是個class，前提是這個類/結構足夠簡單，比如所有的成員都是public的，所有的成員都是簡單類型，沒有顯式聲明的構造函數。
（4）都可以進行復雜的繼承甚至多重繼承，一個struct可以繼承自一個class，反之亦可；一個struct可以同時繼承5個class和5個struct，雖然這樣做不太好。
（5）如果說class的設計需要注意OO的原則和風格，那么沒任何理由說設計struct就不需要注意。
（6）再次說明，以上所有說法都是指在C++語言中，至于在C里的情況，C里是根本沒有“class”，而C的struct從根本上也只是個包裝數據的語法機制。

最后，作為語言的兩個關鍵字，除去定義類型時有上述區別之外，另外還有一點點：“class”這個關鍵字還用于定義模板參數，就像“typename”。但關鍵字“struct”不用于定義模板參數。

關于使用大括號初始化
class和struct如果定義了構造函數的話，都不能用大括號進行初始化
如果沒有定義構造函數，struct可以用大括號初始化。
如果沒有定義構造函數，且所有成員變量全是public的話，可以用大括號初始化。
關于默認訪問權限
class中默認的成員訪問權限是private的，而struct中則是public的。
關于繼承方式
class繼承默認是private繼承，而struct繼承默認是public繼承。
關于模版
在模版中，類型參數前面可以使用class或typename，如果使用struct，則含義不同，struct后面跟的是“non-type template parameter”，而class或typename后面跟的是類型參數。
class中有個默認的this指針，struct沒有
不同點：構造函數，析構函數 this 指針
有關重載函數
返回值類型不同構不成重載
參數參數順序不同能構成重載
c++函數同名不同返回值不算重載！函數重載是忽略返回值類型的。
成員函數被重載的特征有：

相同的范圍（在同一個類中）；
函數名字相同；
參數不同；
virtual關鍵字可有可無。
成員函數中 有無const (函數后面)也可判斷是否重載
數據庫與T-SQL語言
關系數據庫是表的集合，它是由一個或多個關系模式定義。SQL語言中的數據定義功能包括對數據庫、基本表、視圖、索引的定義。

關系模型的基本概念
關系數據庫以關系模型為基礎，它有以下三部分組成：
●數據結構——模型所操作的對象、類型的集合
●完整性規則——保證數據有效、正確的約束條件
●數據操作——對模型對象所允許執行的操作方式
關系（Relation）是一個由行和列組成的二維表格，表中的每一行是一條記錄（Record），每一列是記錄的一個字段（Field）。表中的每一條記錄必須是互斥的，字段的值必須具有原子性。

SQL語言概述
SQL（結構化查詢語言）是關系數據庫語言的一種國際標準，它是一種非過程化的語言。通過編寫SQL，我們可以實現對關系數據庫的全部操作。
●數據定義語言（DDL）——建立和管理數據庫對象
●數據操縱語言（DML）——用來查詢與更新數據
●數據控制語言（DCL）——控制數據的安全性
1
2
3
4
起來是一個很簡單的問題，每一個使用過RDBMS的人都會有一個概念。
事務處理系統的典型特點是具備ACID特征。ACID指的是Atomic（原子的）、Consistent（一致的）、Isolated（隔離的）以及Durable（持續的），它們代表著事務處理應該具備的四個特征：

原子性：組成事務處理的語句形成了一個邏輯單元，不能只執行其中的一部分
一致性：在事務處理執行之前和之后，數據是一致的。
隔離性：一個事務處理對另一個事務處理沒有影響。
持續性：當事務處理成功執行到結束的時候，其效果在數據庫中被永久紀錄下來。
C語言中結構化程序設計的三種基本控制結構
順序結構
選擇結構
循環結構

CVS是什么
cvs（Concurrent Version System） 是一個版本控制系統。使用它，可以記錄下你的源文件的歷史。
例如，修改軟件時可能會不知不覺混進一些 bug，而且可能過了很久你才會察覺到它們的存在。有了 cvs，你可以很容易地恢復舊版本，并從中看出到底是哪個修改導致了這個bug。有時這是很有用的。
CVS服務器端對每個文件維護著一個修訂號,每次對文件的更新，都會使得文件的修訂號加1。在客戶端中也對每個文件維護著一個修訂號,CVS通過這兩個修訂號的關系，來進行Update,Commit和發現沖突等操作操作

三種基本的數據模型
按照數據結構類型的不同，將數據模型劃分為層次模型、網狀模型和關系模型。

設計模式：工廠模式 和 單例模式 介紹一下？
工程模式即將對象創建過程封裝即為工廠模式。
單例模式即整個類只有一個對象，并且不允許顯示創建。

vector 和 list的區別？
1、概念：
1）Vector
連續存儲的容器，動態數組，在堆上分配空間
底層實現：數組
兩倍容量增長：
vector 增加（插入）新元素時，如果未超過當時的容量，則還有剩余空間，那么直接添加到最后（插入指定位置），然后調整迭代器。
如果沒有剩余空間了，則會重新配置原有元素個數的兩倍空間，然后將原空間元素通過復制的方式初始化新空間，再向新空間增加元素，最后析構并釋放原空間，之前的迭代器會失效。
性能：
訪問：O(1)
插入：在最后插入（空間夠）：很快
在最后插入（空間不夠）：需要內存申請和釋放，以及對之前數據進行拷貝。
在中間插入（空間夠）：內存拷貝
在中間插入（空間不夠）：需要內存申請和釋放，以及對之前數據進行拷貝。
刪除：在最后刪除：很快
在中間刪除：內存拷貝
適用場景：經常隨機訪問，且不經常對非尾節點進行插入刪除。
2、List
動態鏈表，在堆上分配空間，每插入一個元數都會分配空間，每刪除一個元素都會釋放空間。
底層：雙向鏈表
性能：
訪問：隨機訪問性能很差，只能快速訪問頭尾節點。
插入：很快，一般是常數開銷
刪除：很快，一般是常數開銷
適用場景：經常插入刪除大量數據
2、區別：
1）vector底層實現是數組；list是雙向 鏈表。
2）vector支持隨機訪問，list不支持。
3）vector是順序內存，list不是。
4）vector在中間節點進行插入刪除會導致內存拷貝，list不會。
5）vector一次性分配好內存，不夠時才進行2倍擴容；list每次插入新節點都會進行內存申請。
6）vector隨機訪問性能好，插入刪除性能差；list隨機訪問性能差，插入刪除性能好。

3、應用
vector擁有一段連續的內存空間，因此支持隨機訪問，如果需要高效的隨即訪問，而不在乎插入和刪除的效率，使用vector。
list擁有一段不連續的內存空間，如果需要高效的插入和刪除，而不關心隨機訪問，則應使用list。

純虛函數是怎樣實現的？在編譯原理上講一下？
在類內部添加一個虛擬函數表指針，該指針指向一個虛擬函數表，該虛擬函數表包含了所有的虛擬函數的入口地址，每個類的虛擬函數表都不一樣，在運行階段可以循此脈絡找到自己的函數入口。
純虛函數相當于占位符，先在虛函數表中占一個位置由派生類實現后再把真正的函數指針填進去。除此之外和普通的虛函數沒什么區別。

抽象類為什么不能實例化？
抽象類中的純虛函數沒有具體的實現，所以沒辦法實例化。

在函數后面加個const是怎么理解的？
在函數后面加個const一般在類的成員函數中使用，表示這個函數不修改數據成員的值。
另：void set_prt_val(int val)const {*ptr= val}理解：指針ptr指向的內容不是類的數據成員，所以這可這么寫：*ptr = val；但這個指針在這個函數中不能修改。如果寫成這樣：ptr = &i（假設i是另外一個整形變量）就不對了，因為改變了指針的內容。

進程間通信類型：
（1）環境變量、文件描述符 一般Unix環境下的父進程執行fork（），生成的子進程擁有了父進程當前設置的環境變量以及文件描述符；由于通信是一個單向的、一次性的通信，隨后的父進程以及子進程后續的內容不能再能共享；
（2）命令行參數 大多數用戶都使用過ShellExec相關的命令，此API可以打開新的進程，并可以通過接口里的輸入參數進行信息共享；同樣，他也是一個單項、一次性的通信；
（3）管道 使用文件和寫方式訪問公用的數據結構；管道分為匿名管道和命名管道，前者是用作關聯進程間用，后者為無關聯的進程使用；前者通過文件描述符或文件句柄提供對命名管道的訪問，后者需要知道管道名稱才能讀寫管道；一般來講，讀寫的內容是字節流，需要轉換為有意義的結構才有意義；
（4）共享內存 進程需要可以被其他進程訪問瀏覽的進程塊；進程間共享內存的關系與函數間共享全局變量的關系類似
（5）DDE動態數據交互
線程間通信類型：
（1）全局數據；
（2）全局變量；
（3）全局數據結構；
（4）線程間通信的參數：pThread_create這類API接口中的參數

關于內存對齊的問題以及sizof()的輸出
答：編譯器自動對齊的原因：為了提高程序的性能，數據結構（尤其是棧）應該盡可能地在自然邊界上對齊。原因在于，為了訪問未對齊的內存，處理器需要作兩次內存訪問；然而，對齊的內存訪問僅需要一次訪問。

winsock建立連接的主要實現步驟?
答：
TCP:服務器端：1.socket()建立套接字，2將套接字綁定到本地地址和端口上，綁定（bind）3.將套接字設為監聽模式，準備接收客戶端，監聽（listen）;4.等待客戶端請求到來，請求到來后，連接請求，并返回一個新的對應此連接的套接字，accept（）5.用返回的套接字和客戶端進行通訊（send/recv）;6.返回并等待另一客戶請求。7.關閉套接字。
客戶端：1.socket()建立套接字2.向服務器發出連接請求，（connect）2。和服務器進行通信，send()和recv（）,在套接字上寫讀數據，直至數據交換完畢;4closesocket()關閉套接字。
UDP:1服務器端：1.創建套接字（socekt）2.將套接字綁定到本地地址和端口上（bind);3.等待接收數據（recvfrom）;4.closesocket()關閉套接字。

客戶端:1.創建套接字（socekt）2,向服務器端發送數據（sendto）3.closesocket()關閉套接字。

C++中為什么用模板類。
答：(1)可用來創建動態增長和減小的數據結構
（2）它是類型無關的，因此具有很高的可復用性。
（3）它在編譯時而不是運行時檢查數據類型，保證了類型安全
（4）它是平臺無關的，可移植性
（5）可用于基本數據類型

動態連接庫的兩種方式?
答：調用一個DLL中的函數有兩種方法：
1．載入時動態鏈接（load-time dynamiclinking），模塊非常明確調用某個導出函數，使得他們就像本地函數一樣。這需要鏈接時鏈接那些函數所在DLL的導入庫，導入庫向系統提供了載入DLL時所需的信息及DLL函數定位。
2．運行時動態鏈接（run-time dynamiclinking），運行時可以通過LoadLibrary或LoadLibraryEx函數載入DLL。DLL載入后，模塊可以通過調用GetProcAddress獲取DLL函數的出口地址，然后就可以通過返回的函數指針調用DLL函數了。如此即可避免導入庫文件了。

CSingleLock是干什么的。
答：同步多個線程對一個數據類的同時訪問

編寫strcat函數(6分)
已知strcat函數的原型是char *strcat (char strDest, const charstrSrc);
其中strDest 是目的字符串，strSrc 是源字符串。
（1）不調用C++/C 的字符串庫函數，請編寫函數strcat
答：
VC源碼：

char * __cdecl strcat(char * dst, const char * src)
{
?? ?assert((dst != NULL) && (src != NULL));
?? ?char * cp = dst;
?? ?while (*cp)
?? ??? ?cp++; /* find end of dst */
?? ?while ( (*cp++ = *src++) != '\0'); /* Copy src to end of dst */
?? ?return dst; /* return dst */
}
1
2
3
4
5
6
7
8
9
（2）strcat能把strSrc的內容連接到strDest，為什么還要char * 類型的返回值？
答：方便賦值給其他變量

編寫類String 的構造函數、析構函數和賦值函數（25 分）
已知類String 的原型為：

class String
{
public:
?? ?String(const char *str = NULL); // 普通構造函數
?? ?String(const String &other); // 拷貝構造函數
?? ?~String(void); // 析構函數
?? ?String & operate = (const String &other); // 賦值函數
private:
?? ?char *m_data; // 用于保存字符串
};
1
2
3
4
5
6
7
8
9
10
請編寫String 的上述4 個函數。
標準答案：

String::String(const char *str)
{
?? ?if (str == NULL) //strlen在參數為NULL時會拋異常才會有這步判斷
?? ?{
?? ??? ?m_data = new char[1];
?? ??? ?m_data[0] = '\0';
?? ?}
?? ?else
?? ?{
?? ??? ?m_data = new char[strlen(str) + 1];
?? ??? ?strcpy(m_data, str);
?? ?}

}
String::String(const String &another)
{
?? ?m_data = new char[strlen(another.m_data) + 1];
?? ?strcpy(m_data, other.m_data);
}
String& String::operator =(const String &rhs)
{
?? ?if (this == &rhs)
?? ??? ?return *this;
?? ?delete[]m_data; //刪除原來的數據，新開一塊內存
?? ?m_data = new char[strlen(rhs.m_data) + 1];
?? ?strcpy(m_data, rhs.m_data);
?? ?return *this;
}

String::~String()
{
?? ?delete[]m_data;
}

————————————————
版權聲明：本文為CSDN博主「SunkingYang」的原創文章，遵循CC 4.0 BY-SA版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/y601500359/article/details/105262815

總結

以上是生活随笔為你收集整理的C/C++面试宝典2020版(最新版)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。