文章源位址：http://blog.sina.com.cn/s/blog_5cd8e3230100b4ll.html
主要是收集以備以後查找友善
<1>
1.介紹一下STL，詳細說明STL如何實作vector。
Answer:
STL (标準模版庫，Standard Template Library)它由容器算法疊代器組成。
STL有以下的一些優點：
可以友善容易地實作搜尋資料或對資料排序等一系列的算法；
調試程式時更加安全和友善；
即使是人們用STL在UNIX平台下寫的代碼你也可以很容易地了解（因為STL是跨平台的）。
vector實質上就是一個動态數組，會根據資料的增加,動态的增加數組空間。
2.如果用VC開發程式，常見這麼幾個錯誤，C2001,c2005,c2011,這些錯誤的原因是什麼。
Answer:
在學習VC++的過程中，遇到的LNK2001錯誤的錯誤消息主要為：
unresolved external symbol “symbol”（不确定的外部“符号”）。
如果連接配接程式不能在所有的庫和目标檔案内找到所引用的函數、變量或标簽，将産生此錯誤消息。
一般來說，發生錯誤的原因有兩個：一是所引用的函數、變量不存在、拼寫不正确或者使用錯誤；其次可能使用了不同版本的連接配接庫。
程式設計中經常能遇到LNK2005錯誤——重複定義錯誤，其實LNK2005錯誤并不是一個很難解決的錯誤.
3.繼承和委派有什麼分别，在決定使用繼承或者委派的時候需要考慮什麼。
在OOD,OOP中，組合優于繼承.
當然多态的基礎是繼承，沒有繼承多态無從談起。
當對象的類型不影響類中函數的行為時，就要使用模闆來生成這樣一組類。
當對象的類型影響類中函數的行為時，就要使用繼承來得到這樣一組類.
4.指針和引用有什麼分别；如果傳引用比傳指針安全，為什麼？如果我使用常量指針難道不行嗎？
(1) 引用在建立的同時必須初始化，即引用到一個有效的對象；而指針在定義的時候不必初始化，可以在定義後面的任何地方重新指派．
(2) 不存在ＮＵＬＬ引用，引用必須與合法的存儲單元關聯;而指針則可以是NULL.
(3) 引用一旦被初始化為指向一個對象，它就不能被改變為另一個對象的引用；而指針在任何時候都可以改變為指向另一個對象．給引用指派并不是改變它和原始對象的綁定關系．
(4) 引用的建立和銷毀并不會調用類的拷貝構造函數
(5) 語言層面，引用的用法和對象一樣；在二進制層面，引用一般都是通過指針來實作的，隻不過編譯器幫我們完成了轉換.
不存在空引用，并且引用一旦被初始化為指向一個對象，它就不能被改變為另一個對象的引用，顯得很安全。
const 指針仍然存在空指針，并且有可能産生野指針.
總的來說：引用既具有指針的效率，又具有變量使用的友善性和直覺性．
5.參數傳遞有幾種方式；實作多态參數傳遞采用什麼方式，如果沒有使用某種方式原因是什麼；
傳值，傳指針或者引用
6.結合一個項目說明你怎樣應用設計模式的理念。
設計模式更多考慮是擴充和重用，而這兩方面很多情況下，往往會被忽略。
不過，我不建議濫用設計模式，以為它有可能使得簡單問題複雜化.
7.介紹一下你對設計模式的了解。（這個過程中有很多很細節的問題随機問的）
設計模式概念是由建築設計師Christopher Alexander提出:"每一個模式描述了一個在我們周圍不斷重複發生的問題,以及該問題的解決方案的核心.這樣,你就能一次又一次地使用該方案而不必做重複勞動."上述定義是對設計模式的廣義定義.将其應用到面向對象軟體的領域内,就形成了對設計模式的狹義定義.
可以簡單的認為:設計模式就是解決某個特定的面向對象軟體問題的特定方法， 并且已經上升到理論程度。
架構與設計模式的差別:
1,設計模式和架構針對的問題域不同.設計模式針對面向對象的問題域;架構針對特定業務的問題域
2,設計模式比架構更為抽象.設計模式在碰到具體問題後,才能産生代碼;架構已經可以用代碼表示
3,設計模式是比架構更小的體系結構元素.架構中可以包括多個設計模式
設計模式就像國術中基本的招式.将這些招式合理地縱組合起來,就形成套路(架構)，架構是一種半成品.
8.C++和C定義結構的分别是什麼。
C language 的結構僅僅是資料的結合
C plus plus的struct 和 class 其實具備幾乎一樣的功能，隻是預設的通路屬性不一樣而已。
9.構造函數可否是虛汗數，為什麼？析構函數呢，可否是純虛的呢？
構造函數不能為虛函數，要構造一個對象，必須清楚地知道要構造什麼，否則無法構造一個對象。
析構函數可以為純虛函數。
10.拷貝構造函數相關問題，深拷貝，淺拷貝，臨時對象等。
深拷貝意味着拷貝了資源和指針，而淺拷貝隻是拷貝了指針，沒有拷貝資源
這樣使得兩個指針指向同一份資源，造成對同一份析構兩次，程式崩潰。
臨時對象的開銷比局部對象小些。
11.結合1個你認為比較能展現OOP思想的項目，用UML來描述。(最好這個項目繼承，多态，虛函數都有展現）這個問題大概會占面試時間的一半，并且會問很多問題，一不小心可能會被問住）。
。。。
12.基類的有1個虛函數，子類還需要申明為virtual嗎？為什麼。
不申明沒有關系的。
不過，我總是喜歡顯式申明，使得代碼更加清晰。
13.C也可以通過精心封裝某些函數功能實作重用，那C++的類有什麼優點嗎，難道僅僅是為實作重用。
并不僅僅是這樣的。
OOD，OOP從根本上改變了程式設計模式和設計思想，具備重大和深遠的意義。
類的三大最基本的特征：封裝，繼承，多态.
14.C++特點是什麼，如何實作多态？畫出基類和子類在記憶體中的互相關系。
多态的基礎是繼承，需要虛函數的支援，簡單的多态是很簡單的。
子類繼承父類大部分的資源，不能繼承的有構造函數，析構函數，拷貝構造函數，operator=函數，友元函數等等
15.為什麼要引入抽象基類和純虛函數？
主要目的是為了實作一種接口的效果。
16.介紹一下模闆和容器。如何實作？（也許會讓你當場舉例實作）
模闆可以說比較古老了，但是目前的泛型程式設計實質上就是模闆程式設計。
它展現了一種通用和泛化的思想。
STL有7種主要容器：vector,list,deque,map,multimap,set,multiset.
17.你如何了解MVC。簡單舉例來說明其應用。
MVC模式是observer 模式的一個特例,典型的有MFC裡面的文檔視圖架構。
18.多重繼承如何消除向上繼承的二義性。
使用虛拟繼承即可.
<2>
1. 以下三條輸出語句分别輸出什麼？[C易]
char str1[] = "abc";
char str2[] = "abc";
const char str3[] = "abc";
const char str4[] = "abc";
const char* str5 = "abc";
const char* str6 = "abc";
cout << boolalpha << ( str1==str2 ) << endl; // 輸出什麼？
cout << boolalpha << ( str3==str4 ) << endl; // 輸出什麼？
cout << boolalpha << ( str5==str6 ) << endl; // 輸出什麼？
2. 非C++内建型别 A 和 B，在哪幾種情況下B能隐式轉化為A？[C++中等]
答：
a. class B : public A { ……} // B公有繼承自A，可以是間接繼承的
b. class B { operator A( ); } // B實作了隐式轉化為A的轉化
c. class A { A( const B& ); } // A實作了non-explicit的參數為B（可以有其他帶預設值的參數）構造函數
d. A& operator= ( const A& ); // 指派操作，雖不是正宗的隐式類型轉換，但也可以勉強算一個
3. 以下代碼中的兩個sizeof用法有問題嗎？[C易]
void UpperCase( char str[] ) // 将 str 中的小寫字母轉換成大寫字母
{
for( size_t i=0; i<sizeof(str)/sizeof(str[0]); ++i )
if( 'a'<=str[i] && str[i]<='z' )
str[i] -= ('a'-'A' );
}
char str[] = "aBcDe";
cout << "str字元長度為: " << sizeof(str)/sizeof(str[0]) << endl;
UpperCase( str );
cout << str << endl;
<3>
1.求下面函數的傳回值（微軟）
int func(x)
{
int countx = 0;
while(x)
{
countx ++;
x = x&(x-1);
}
return countx;
}
假定x = 9999。 答案：8
思路：将x轉化為2進制，看含有的1的個數。
2. 什麼是“引用”？申明和使用“引用”要注意哪些問題？
答：引用就是某個目标變量的“别名”(alias)，對應用的操作與對變量直接操作效果完全相同。申明一個引用的時候，切記要對其進行初始化。引用聲明完畢後，相當于目标變量名有兩個名稱，即該目标原名稱和引用名，不能再把該引用名作為其他變量名的别名。聲明一個引用，不是新定義了一個變量，它隻表示該引用名是目标變量名的一個别名，它本身不是一種資料類型，是以引用本身不占存儲單元，系統也不給引用配置設定存儲單元。不能建立數組的引用。
3. 将“引用”作為函數參數有哪些特點？
（1）傳遞引用給函數與傳遞指針的效果是一樣的。這時，被調函數的形參就成為原來主調函數中的實參變量或對象的一個别名來使用，是以在被調函數中對形參變量的操作就是對其相應的目标對象（在主調函數中）的操作。
（2）使用引用傳遞函數的參數，在記憶體中并沒有産生實參的副本，它是直接對實參操作；而使用一般變量傳遞函數的參數，當發生函數調用時，需要給形參配置設定存儲單元，形參變量是實參變量的副本；如果傳遞的是對象，還将調用拷貝構造函數。是以，當參數傳遞的資料較大時，用引用比用一般變量傳遞參數的效率和所占空間都好。
（3）使用指針作為函數的參數雖然也能達到與使用引用的效果，但是，在被調函數中同樣要給形參配置設定存儲單元，且需要重複使用"*指針變量名"的形式進行運算，這很容易産生錯誤且程式的閱讀性較差；另一方面，在主調函數的調用點處，必須用變量的位址作為實參。而引用更容易使用，更清晰。
4. 在什麼時候需要使用“常引用”？
如果既要利用引用提高程式的效率，又要保護傳遞給函數的資料不在函數中被改變，就應使用常引用。常引用聲明方式：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 。
5. 将“引用”作為函數傳回值類型的格式、好處和需要遵守的規則?
格式：類型辨別符 &函數名（形參清單及類型說明）{ //函數體 }
好處：在記憶體中不産生被傳回值的副本；（注意：正是因為這點原因，是以傳回一個局部變量的引用是不可取的。因為随着該局部變量生存期的結束，相應的引用也會失效，産生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;指派操作符的傳回值必須是一個左值，以便可以被繼續指派。是以引用成了這個操作符的惟一傳回值選擇。
例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; }
}
（5）在另外的一些操作符中，卻千萬不能傳回引用：+-*/ 四則運算符。它們不能傳回引用，Effective C++[1]的Item23詳細的讨論了這個問題。主要原因是這四個操作符沒有side effect，是以，它們必須構造一個對象作為傳回值，可選的方案包括：傳回一個對象、傳回一個局部變量的引用，傳回一個new配置設定的對象的引用、傳回一個靜态對象引用。根據前面提到的引用作為傳回值的三個規則，第2、3兩個方案都被否決了。靜态對象的引用又因為((a+b) == (c+d))會永遠為true而導緻錯誤。是以可選的隻剩下傳回一個對象了。
6.引用與多态的關系？
引用是除指針外另一個可以産生多态效果的手段。這意味着，一個基類的引用可以指向它的派生類執行個體。
例4
Class A; Class B : Class A{...}; B b; A& ref = b;
7. 引用與指針的差別是什麼？
指針通過某個指針變量指向一個對象後，對它所指向的變量間接操作。程式中使用指針，程式的可讀性差；而引用本身就是目标變量的别名，對引用的操作就是對目标變量的操作。此外，就是上面提到的對函數傳ref和pointer的差別。
8. 什麼時候需要“引用”？
流操作符<<和>>、指派操作符=的傳回值、拷貝構造函數的參數、指派操作符=的參數、其它情況都推薦使用引用。
以上 2-8 參考：http://blog.csdn.net/wfwd/archive/2006/05/30/763551.aspx
9. 結構與聯合有和差別？
1. 結構和聯合都是由多個不同的資料類型成員組成, 但在任何同一時刻, 聯合中隻存放了一個被選中的成員（所有成員共用一塊位址空間）, 而結構的所有成員都存在（不同成員的存放位址不同）。
2. 對于聯合的不同成員指派, 将會對其它成員重寫, 原來成員的值就不存在了, 而對于結構的不同成員指派是互不影響的。
10. 下面關于“聯合”的題目的輸出？
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);
}
答案：266 (低位低位址，高位高位址，記憶體占用情況是Ox010A）
b)
main()
{
union{
int i;
struct{
char first;
char second;
}half;
}number;
number.i=0x4241;
printf("%c%c\n", number.half.first, mumber.half.second);
number.half.first='a';
number.half.second='b';
printf("%x\n", number.i);
getch();
}
答案： AB (0x41對應'A',是低位；Ox42對應'B',是高位）
6261 (number.i和number.half共用一塊位址空間）
11. 已知strcpy的函數原型：char *strcpy(char *strDest, const char *strSrc)其中strDest 是目的字元串，strSrc 是源字元串。不調用C++/C 的字元串庫函數，請編寫函數 strcpy。
答案：
char *strcpy(char *strDest, const char *strSrc)
{
if ( strDest == NULL || strSrc == NULL)
return NULL ;
if ( strDest == strSrc)
return strDest ;
char *tempptr = strDest ;
while( (*strDest++ = *strSrc++) != ‘\0’)
;
return tempptr ;
}
12. 已知String類定義如下：
class String
{
public:
String(const char *str = NULL); // 通用構造函數
String(const String &another); // 拷貝構造函數
~ String(); // 析構函數
String & operater =(const String &rhs); // 指派函數
private:
char *m_data; // 用于儲存字元串
};
嘗試寫出類的成員函數實作。
答案：
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 ;
}
13. .h頭檔案中的ifndef/define/endif 的作用？
答：
防止該頭檔案被重複引用。
14. #include<file.h> 與 #include "file.h"的差別？
答：
前者是從Standard Library的路徑尋找和引用file.h，而後者是從目前工作路徑搜尋并引用file.h。
15.在C++ 程式中調用被C 編譯器編譯後的函數，為什麼要加extern “C”？
首先，作為extern是C/C++語言中表明函數和全局變量作用範圍（可見性）的關鍵字，該關鍵字告訴編譯器，其聲明的函數和變量可以在本子產品或其它子產品中使用。
通常，在子產品的頭檔案中對本子產品提供給其它子產品引用的函數和全局變量以關鍵字extern聲明。例如，如果子產品B欲引用該子產品A中定義的全局變量和函數時隻需包含子產品A的頭檔案即可。這樣，子產品B中調用子產品A中的函數時，在編譯階段，子產品B雖然找不到該函數，但是并不會報錯；它會在連接配接階段中從子產品A編譯生成的目标代碼中找到此函數
extern "C"是連接配接申明(linkage declaration),被extern "C"修飾的變量和函數是按照C語言方式編譯和連接配接的,來看看C++中對類似C的函數是怎樣編譯的：
作為一種面向對象的語言，C++支援函數重載，而過程式語言C則不支援。函數被C++編譯後在符号庫中的名字與C語言的不同。例如，假設某個函數的原型為：
void foo( int x, int y );
該函數被C編譯器編譯後在符号庫中的名字為_foo，而C++編譯器則會産生像_foo_int_int之類的名字（不同的編譯器可能生成的名字不同，但是都采用了相同的機制，生成的新名字稱為“mangled name”）。
_foo_int_int這樣的名字包含了函數名、函數參數數量及類型資訊，C++就是靠這種機制來實作函數重載的。例如，在C++中，函數void foo( int x, int y )與void foo( int x, float y )編譯生成的符号是不相同的，後者為_foo_int_float。
同樣地，C++中的變量除支援局部變量外，還支援類成員變量和全局變量。使用者所編寫程式的類成員變量可能與全局變量同名，我們以"."來區分。而本質上，編譯器在進行編譯時，與函數的處理相似，也為類中的變量取了一個獨一無二的名字，這個名字與使用者程式中同名的全局變量名字不同。
未加extern "C"聲明時的連接配接方式
假設在C++中，子產品A的頭檔案如下：
// 子產品A頭檔案 moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
int foo( int x, int y );
#endif
在子產品B中引用該函數：
// 子產品B實作檔案 moduleB.cpp
#include "moduleA.h"
foo(2,3);
實際上，在連接配接階段，連接配接器會從子產品A生成的目标檔案moduleA.obj中尋找_foo_int_int這樣的符号！
加extern "C"聲明後的編譯和連接配接方式
加extern "C"聲明後，子產品A的頭檔案變為：
// 子產品A頭檔案 moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
extern "C" int foo( int x, int y );
#endif
在子產品B的實作檔案中仍然調用foo( 2,3 )，其結果是：
（1）子產品A編譯生成foo的目标代碼時，沒有對其名字進行特殊處理，采用了C語言的方式；
（2）連接配接器在為子產品B的目标代碼尋找foo(2,3)調用時，尋找的是未經修改的符号名_foo。
如果在子產品A中函數聲明了foo為extern "C"類型，而子產品B中包含的是extern int foo( int x, int y ) ，則子產品B找不到子產品A中的函數；反之亦然。
是以，可以用一句話概括extern “C”這個聲明的真實目的（任何語言中的任何文法特性的誕生都不是随意而為的，來源于真實世界的需求驅動。我們在思考問題時，不能隻停留在這個語言是怎麼做的，還要問一問它為什麼要這麼做，動機是什麼，這樣我們可以更深入地了解許多問題）：實作C++與C及其它語言的混合程式設計。
明白了C++中extern "C"的設立動機，我們下面來具體分析extern "C"通常的使用技巧：
extern "C"的慣用法
（1）在C++中引用C語言中的函數和變量，在包含C語言頭檔案（假設為cExample.h）時，需進行下列處理：
extern "C"
{
#include "cExample.h"
}
而在C語言的頭檔案中，對其外部函數隻能指定為extern類型，C語言中不支援extern "C"聲明，在.c檔案中包含了extern "C"時會出現編譯文法錯誤。
C++引用C函數例子工程中包含的三個檔案的源代碼如下：
#ifndef C_EXAMPLE_H
#define C_EXAMPLE_H
extern int add(int x,int y);
#endif
#include "cExample.h"
int add( int x, int y )
{
return x + y;
}
// c++實作檔案，調用add：cppFile.cpp
extern "C"
{
#include "cExample.h"
}
int main(int argc, char* argv[])
{
add(2,3);
return 0;
}
如果C++調用一個C語言編寫的.DLL時，當包括.DLL的頭檔案或聲明接口函數時，應加extern "C" { }。
（2）在C中引用C++語言中的函數和變量時，C++的頭檔案需添加extern "C"，但是在C語言中不能直接引用聲明了extern "C"的該頭檔案，應該僅将C檔案中将C++中定義的extern "C"函數聲明為extern類型。
C引用C++函數例子工程中包含的三個檔案的源代碼如下：
//C++頭檔案 cppExample.h
#ifndef CPP_EXAMPLE_H
#define CPP_EXAMPLE_H
extern "C" int add( int x, int y );
#endif
//C++實作檔案 cppExample.cpp
#include "cppExample.h"
int add( int x, int y )
{
return x + y;
}
extern int add( int x, int y );
int main( int argc, char* argv[] )
{
add( 2, 3 );
return 0;
}
15題目的解答請參考《C++中extern “C”含義深層探索》注解：
16. 關聯、聚合(Aggregation)以及組合(Composition)的差別？
涉及到UML中的一些概念：關聯是表示兩個類的一般性聯系，比如“學生”和“老師”就是一種關聯關系；聚合表示has-a的關系，是一種相對松散的關系，聚合類不需要對被聚合類負責，如下圖所示，用空的菱形表示聚合關系：
從實作的角度講，聚合可以表示為:
class A {...} class B { A* a; .....}
而組合表示contains-a的關系，關聯性強于聚合：組合類與被組合類有相同的生命周期，組合類要對被組合類負責，采用實心的菱形表示組合關系：
實作的形式是:
class A{...} class B{ A a; ...}
參考文章：http://blog.csdn.net/wfwd/archive/2006/05/30/763753.aspx
http://blog.csdn.net/wfwd/archive/2006/05/30/763760.aspx
17.面向對象的三個基本特征，并簡單叙述之？
1. 封裝：将客觀事物抽象成類，每個類對自身的資料和方法實行protection(private, protected,public)
2. 繼承：廣義的繼承有三種實作形式：實作繼承（指使用基類的屬性和方法而無需額外編碼的能力）、可視繼承（子窗體使用父窗體的外觀和實作代碼）、接口繼承（僅使用屬性和方法，實作滞後到子類實作）。前兩種（類繼承）和後一種（對象組合=>接口繼承以及純虛函數）構成了功能複用的兩種方式。
3. 多态：是将父對象設定成為和一個或更多的他的子對象相等的技術，指派之後，父對象就可以根據目前指派給它的子對象的特性以不同的方式運作。簡單的說，就是一句話：允許将子類類型的指針指派給父類類型的指針。
18. 重載（overload)和重寫(overried，有的書也叫做“覆寫”）的差別？
常考的題目。從定義上來說：
重載：是指允許存在多個同名函數，而這些函數的參數表不同（或許參數個數不同，或許參數類型不同，或許兩者都不同）。
重寫：是指子類重新定義複類虛函數的方法。
從實作原理上來說：
重載：編譯器根據函數不同的參數表，對同名函數的名稱做修飾，然後這些同名函數就成了不同的函數（至少對于編譯器來說是這樣的）。如，有兩個同名函數：function func(p:integer):integer;和function func(p:string):integer;。那麼編譯器做過修飾後的函數名稱可能是這樣的：int_func、str_func。對于這兩個函數的調用，在編譯器間就已經确定了，是靜态的。也就是說，它們的位址在編譯期就綁定了（早綁定），是以，重載和多态無關！
重寫：和多态真正相關。當子類重新定義了父類的虛函數後，父類指針根據賦給它的不同的子類指針，動态的調用屬于子類的該函數，這樣的函數調用在編譯期間是無法确定的（調用的子類的虛函數的位址無法給出）。是以，這樣的函數位址是在運作期綁定的（晚綁定）。
1、局部變量能否和全局變量重名？
能，局部會屏蔽全局。要用全局變量，需要使用"::"
局部變量可以與全局變量同名，在函數内引用這個變量時，會用到同名的局部變量，而不會用到全局變量。對于有些編譯器而言，在同一個函數内可以定義多個同名的局部變量，比如在兩個循環體内都定義一個同名的局部變量，而那個局部變量的作用域就在那個循環體内。
2、如何引用一個已經定義過的全局變量？
extern
可以用引用頭檔案的方式，也可以用extern關鍵字，如果用引用頭檔案方式來引用某個在頭檔案中聲明的全局變理，假定你将那個變寫錯了，那麼在編譯期間會報錯，如果你用extern方式引用時，假定你犯了同樣的錯誤，那麼在編譯期間不會報錯，而在連接配接期間報錯。
3、全局變量可不可以定義在可被多個.C檔案包含的頭檔案中？為什麼？
可以，在不同的C檔案中以static形式來聲明同名全局變量。
可以在不同的C檔案中聲明同名的全局變量，前提是其中隻能有一個C檔案中對此變量賦初值，此時連接配接不會出錯。
4、語句for( ；1 ；)有什麼問題？它是什麼意思？
無限循環，和while(1)相同。
5、do……while和while……do有什麼差別？
前一個循環一遍再判斷，後一個判斷以後再循環。
6、請寫出下列代碼的輸出内容
#include<stdio.h>
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 0;
}
答：10，12，120
7、請找出下面代碼中的是以錯誤
說明：以下代碼是把一個字元串倒序，如“abcd”倒序後變為“dcba”
#include "string.h"
main()
{
char*src="hello,world";
char* dest=NULL;
int len=strlen(src);
dest=(char*)malloc(len);
char* d=dest;
char* s=src[len];
while(len--!=0)
d++=s--;
printf("%s",dest);
return 0;
}
答：
方法1：
int main()
{
char* src = "hello,world";
int len = strlen(src);
char* dest = (char*)malloc(len+1);//要為\0配置設定一個空間
char* d = dest;
char* s = &src[len-1];//指向最後一個字元
while( len-- != 0 )
*d++=*s--;
*d = 0;//尾部要加\0
printf("%s\n",dest);
free(dest);// 使用完，應當釋放空間，以免造成記憶體彙洩露
return 0;
}
方法2：
#include <stdio.h>
#include <string.h>
main()
{
char str[]="hello,world";
int len=strlen(str);
char t;
for(int i=0; i<len/2; i++)
{
t=str[i];
str[i]=str[len-i-1]; str[len-i-1]=t;
}
printf("%s",str);
return 0;
}
8、-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)
答案：63
9、用兩個棧實作一個隊列的功能？要求給出算法和思路！
設2個棧為A,B, 一開始均為空.
入隊:
将新元素push入棧A;
出隊:
(1)判斷棧B是否為空；
(2)如果不為空，則将棧A中所有元素依次pop出并push到棧B；
(3)将棧B的棧頂元素pop出；這樣實作的隊列入隊和出隊的平攤複雜度都還是O(1), 比上面的幾種方法要好。
10、在c語言庫函數中将一個字元轉換成整型的函數是atool()嗎，這個函數的原型是什麼？
函數名: atol
功 能: 把字元串轉換成長整型數
用 法: long atol(const char *nptr);
程式例:
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
long l;
char *str = "98765432";
l = atol(lstr);
printf("string = %s integer = %ld\n", str, l);
return(0);
}
11、對于一個頻繁使用的短小函數,在C語言中應用什麼實作,在C++中應用什麼實作?
c用宏定義，c++用inline
12、直接連結兩個信令點的一組鍊路稱作什麼?
PPP點到點連接配接
13、接入網用的是什麼接口?
14、voip都用了那些協定?
15、軟體測試都有那些種類?
黑盒：針對系統功能的測試 白合：測試函數功能，各函數接口
16、确定子產品的功能和子產品的接口是在軟體設計的那個隊段完成的?
概要設計階段
17、enum string
{
x1,
x2,
x3=10,
x4,
x5,
}x;
問x= 0x801005，0x8010f4;
18、unsigned char *p1;
unsigned long *p2;
p1=(unsigned char *)0x801000;
p2=(unsigned long *)0x810000;
請問p1+5= 0x801005;
p2+5= 0x801014;
19. 多态的作用？
主要是兩個：1. 隐藏實作細節，使得代碼能夠子產品化；擴充代碼子產品，實作代碼重用；2. 接口重用：為了類在繼承和派生的時候，保證使用家族中任一類的執行個體的某一屬性時的正确調用。
20. 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 的支援。
21. New delete 與malloc free 的聯系與差別?
都是在堆(heap)上進行動态的記憶體操作。用malloc函數需要指定記憶體配置設定的位元組數并且不能初始化對象，new 會自動調用對象的構造函數。delete 會調用對象的destructor，而free 不會調用對象的destructor.
22. #define DOUBLE(x) x+x ，i = 5*DOUBLE(5)； i 是多少？
答案：i 為30。
23. 有哪幾種情況隻能用intialization list 而不能用assignment?
答案：當類中含有const、reference 成員變量；基類的構造函數都需要初始化表。
24. C++是不是類型安全的？
答案：不是。兩個不同類型的指針之間可以強制轉換（用reinterpret cast)。C#是類型安全的。
25. main 函數執行以前，還會執行什麼代碼？
答案：全局對象的構造函數會在main 函數之前執行。
26. 描述記憶體配置設定方式以及它們的差別?
1）從靜态存儲區域配置設定。記憶體在程式編譯的時候就已經配置設定好，這塊記憶體在程式的整個運作期間都存在。例如全局變量，static 變量。
2）在棧上建立。在執行函數時，函數内局部變量的存儲單元都可以在棧上建立，函數執行結束時這些存儲單元自動被釋放。棧記憶體配置設定運算内置于處理器的指令集。
3）從堆上配置設定，亦稱動态記憶體配置設定。程式在運作的時候用malloc 或new 申請任意多少的記憶體，程式員自己負責在何時用free 或delete 釋放記憶體。動态記憶體的生存期由程式員決定，使用非常靈活，但問題也最多。
27.struct 和 class 的差別
struct 的成員預設是公有的，而類的成員預設是私有的。struct 和 class 在其他方面是功能相當的。
從感情上講，大多數的開發者感到類和結構有很大的差别。感覺上結構僅僅象一堆缺乏封裝和功能的開放的記憶體位，而類就象活的并且可靠的社會成員，它有智能服務，有牢固的封裝屏障和一個良好定義的接口。既然大多數人都這麼認為，那麼隻有在你的類有很少的方法并且有公有資料（這種事情在良好設計的系統中是存在的!）時，你也許應該使用 struct 關鍵字，否則，你應該使用 class 關鍵字。
28.當一個類A 中沒有生命任何成員變量與成員函數,這時sizeof(A)的值是多少，如果不是零，請解釋一下編譯器為什麼沒有讓它為零。（Autodesk）
肯定不是零。舉個反例，如果是零的話，聲明一個class A[10]對象數組，而每一個對象占用的空間是零，這時就沒辦法區分A[0],A[1]…了。
29. 在8086 彙編下，邏輯位址和實體位址是怎樣轉換的？（Intel）
通用寄存器給出的位址，是段内偏移位址，相應段寄存器位址*10H+通用寄存器内位址，就得到了真正要通路的位址。
30. 比較C++中的4種類型轉換方式？
請參考：http://blog.csdn.net/wfwd/archive/2006/05/30/763785.aspx，重點是static_cast, dynamic_cast和reinterpret_cast的差別和應用。
31.分别寫出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)
32.請說出const與#define 相比，有何優點？
答案：
1） const 常量有資料類型，而宏常量沒有資料類型。編譯器可以對前者進行類型安全檢查。而對後者隻進行字元替換，沒有類型安全檢查，并且在字元替換可能會産生意料不到的錯誤。
2）有些內建化的調試工具可以對const 常量進行調試，但是不能對宏常量進行調試。
33.簡述數組與指針的差別？
數組要麼在靜态存儲區被建立（如全局數組），要麼在棧上被建立。指針可以随時指向任意類型的記憶體塊。
(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 位元組
}
34.類成員函數的重載、覆寫和隐藏差別？
答案：
a.成員函數被重載的特征：
（1）相同的範圍（在同一個類中）；
（2）函數名字相同；
（3）參數不同；
（4）virtual 關鍵字可有可無。
b.覆寫是指派生類函數覆寫基類函數，特征是：
（1）不同的範圍（分别位于派生類與基類）；
（2）函數名字相同；
（3）參數相同；
（4）基類函數必須有virtual 關鍵字。
c.“隐藏”是指派生類的函數屏蔽了與其同名的基類函數，規則如下：
（1）如果派生類的函數與基類的函數同名，但是參數不同。此時，不論有無virtual關鍵字，基類的函數将被隐藏（注意别與重載混淆）。
（2）如果派生類的函數與基類的函數同名，并且參數也相同，但是基類函數沒有virtual 關鍵字。此時，基類的函數被隐藏（注意别與覆寫混淆）
35. There are two int variables: a and b, don’t use “if”, “? :”, “switch”or other judgement statements, find out the biggest one of the two numbers.
答案：
( ( a + b ) + abs( a - b ) ) / 2
36. 如何列印出目前源檔案的檔案名以及源檔案的目前行号？
答案：
cout << __FILE__ ;
cout<<__LINE__ ;
__FILE__和__LINE__是系統預定義宏，這種宏并不是在某個檔案中定義的，而是由編譯器定義的。
37. 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;
}
The _onexit function is passed the address of a function (func) to be called when the program terminates normally. Successive calls to _onexit create a register of functions that are executed in LIFO (last-in-first-out) order. The functions passed to _onexit cannot take parameters.
38. 如何判斷一段程式是由C 編譯程式還是由C++編譯程式編譯的？
答案：
#ifdef __cplusplus
cout<<"c++";
#else
cout<<"c";
#endif
39.檔案中有一組整數，要求排序後輸出到另一個檔案中
答案：
#include<iostream>
#include<fstream>
using namespace std;
void Order(vector<int>& data) //bubble sort
{
int count = data.size() ;
int tag = false ; // 設定是否需要繼續冒泡的标志位
for ( int i = 0 ; i < count ; i++)
{
for ( int j = 0 ; j < count - i - 1 ; j++)
{
if ( data[j] > data[j+1])
{
tag = true ;
int temp = data[j] ;
data[j] = data[j+1] ;
data[j+1] = temp ;
}
}
if ( !tag )
break ;
}
}
void main( void )
{
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 ( i = 0 ; i < data.size() ; i++)
out<<data<<" ";
out.close(); //關閉輸出檔案流
}
40. 連結清單題：一個連結清單的結點結構
struct Node
{
int data ;
Node *next ;
};
typedef struct Node Node ;
(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 ;
}
(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 ;
}
(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 ;
}
41. 分析一下這段程式的輸出 (Autodesk)
class B
{
public:
B()
{
cout<<"default constructor"<<endl;
}
~B()
{
cout<<"destructed"<<endl;
}
B(int i):data(i) //B(int) works as a converter ( int -> instance of B)
{
cout<<"constructed by parameter " << data <<endl;
}
private:
int data;
};
B Play( B b)
{
return b ;
}
(1) results:
int main(int argc, char* argv[]) constructed by parameter 5
{ destructed B(5)形參析構
B t1 = Play(5); B t2 = Play(t1); destructed t1形參析構
return 0; destructed t2 注意順序！
} destructed t1
(2) results:
int main(int argc, char* argv[]) constructed by parameter 5
{ destructed B(5)形參析構
B t1 = Play(5); B t2 = Play(10); constructed by parameter 10
return 0; destructed B(10)形參析構
} destructed t2 注意順序！
destructed t1
42. 寫一個函數找出一個整數數組中，第二大的數 （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 > maxnumber )
{
sec_max = maxnumber ;
maxnumber = data ;
}
else
{
if ( data > sec_max )
sec_max = data ;
}
}
return sec_max ;
}
43. 寫一個在一個字元串(n)中尋找一個子串(m)第一個位置的函數。
KMP算法效率最好，時間複雜度是Ｏ(n+m)。
44. 多重繼承的記憶體配置設定問題：
比如有class A : public class B, public class C {}
那麼A的記憶體結構大緻是怎麼樣的？
這個是compiler-dependent的, 不同的實作其細節可能不同。
如果不考慮有虛函數、虛繼承的話就相當簡單；否則的話，相當複雜。
可以參考《深入探索C++對象模型》，或者：http://blog.csdn.net/wfwd/archive/2006/05/30/763797.aspx
45. 如何判斷一個單連結清單是有環的？（注意不能用标志位，最多隻能用兩個額外指針）
struct node { char val; node* next;}
bool check(const node* head) {} //return false : 無環；true: 有環
一種O（n）的辦法就是（搞兩個指針，一個每次遞增一步，一個每次遞增兩步，如果有環的話兩者必然重合，反之亦然）：
bool check(const 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. C++的類和C裡面的struct有什麼差別？
struct成員預設通路權限為public，而class成員預設通路權限為private
2. 析構函數和虛函數的用法和作用
析構函數是在對象生存期結束時自動調用的函數，用來釋放在構造函數配置設定的記憶體。
虛函數是指被關鍵字virtual說明的函數，作用是使用C++語言的多态特性
3. 全局變量和局部變量有什麼差別？是怎麼實作的？作業系統和編譯器是怎麼知道的?
1) 全局變量的作用用這個程式塊,而局部變量作用于目前函數
2) 前者在記憶體中配置設定在全局資料區,後者配置設定在棧區
3) 生命周期不同：全局變量随主程式建立和建立，随主程式銷毀而銷毀，局部變量在局部函數内部，甚至局部循環體等内部存在，退出就不存在
4) 使用方式不同：通過聲明後全局變量程式的各個部分都可以用到，局部變量隻能在局部使用
4. 有N個大小不等的自然數（1--N），請将它們由小到大排序.要求程式算法：時間複雜度為O(n)，空間複雜度為O(1)。
void sort(int e[], int n)
{
int i;
int t;
for (i=1; i<n+1; i++)
{
t = e[e[i]];
e[e[i]] = e[i];
e[i] = t;
}
}
5. 堆與棧的去差別
A. 申請方式不同
Stack由系統自動配置設定，而heap需要程式員自己申請，并指明大小。
B. 申請後系統的響應不同
Stack：隻要棧的剩餘空間大于申請空間，系統就為程式提供記憶體，否則将抛出棧溢出異常
Heap：當系統收到程式申請時，先周遊作業系統中記錄空閑記憶體位址的連結清單，尋找第一個大于所申請空間的堆結點，然後将該結點從空間結點連結清單中删除，并将該結點的空間配置設定給程式。另外，大多數系統還會在這塊記憶體空間中的首位址處記錄本次配置設定的大小，以便于delete語句正确釋放空間。而且，由于找到的堆結點的大小不一定正好等于申請的大小，系統會自動将多餘的那部分重新放入空閑連結清單。
C. 申請大小限制的不同
Stack：在windows下，棧的大小是2M（也可能是1M它是一個編譯時就确定的常數），如果申請的空間超過棧的剩餘空間時，将提示overflow。是以，能從棧獲得的空間較小。
Heap：堆是向高位址擴充的資料結構，是不連續的記憶體區域。這是由于系統是用連結清單來存儲的空閑記憶體位址的，自然是不連續的，而連結清單的周遊方向是由低位址向高位址。堆的大小受限于計算機系統中有效的虛拟記憶體。由此可見，堆獲得的空間比較靈活，也比較大。
D. 申請效率的比較：
棧由系統自動配置設定，速度較快。但程式員是無法控制的。
堆是由new配置設定的記憶體，一般速度比較慢，而且容易産生記憶體碎片,不過用起來最友善。
另外，在WINDOWS下，最好的方式是用VirtualAlloc配置設定記憶體，他不是在堆，也不是在棧是直接在程序的位址空間中保留一快記憶體，雖然用起來最不友善。但是速度快，也最靈活。
E. 堆和棧中的存儲内容
棧：在函數調用時，第一個進棧的是主函數中後的下一條指令（函數調用語句的下一條可執行語句）的位址，然後是函數的各個參數，在大多數的C編譯器中，參數是由右往左入棧的，然後是函數中的局部變量。注意靜态變量是不入棧的。當本次函數調用結束後，局部變量先出棧，然後是參數，最後棧頂指針指向最開始存的位址，也就是主函數中的下一條指令，程式由該點繼續運作。
堆：一般是在堆的頭部用一個位元組存放堆的大小。堆中的具體内容有程式員安排。
6. 含參數的宏與函數的優缺點
宏：
優點：在預處理階段完成，不占用編譯時間，同時，省去了函數調用的開銷，運作效率高
缺點：不進行類型檢查，多次宏替換會導緻代碼體積變大，而且由于宏本質上是字元串替換，故可能會由于一些參數的副作用導緻得出錯誤的結果。
函數：
優點：沒有帶參數宏可能導緻的副作用，進行類型檢查，計算的正确性更有保證。
缺點：函數調用需要參數、傳回位址等的入棧、出棧開銷，效率沒有帶參數宏高
PS：宏與内聯函數的差別
内聯函數和宏都是在程式出現的地方展開，内聯函數不是通過函數調用實作的，是在調用該函數的程式處将它展開（在編譯期間完成的）；宏同樣是；
不同的是：内聯函數可以在編譯期間完成諸如類型檢測，語句是否正确等編譯功能；宏就不具有這樣的功能，而且宏展開的時間和内聯函數也是不同的（在運作期間展開）
7. Windows程式的入口是哪裡？寫出Windows消息機制的流程
Windows程式的入口是WinMain()函數。
Windows應用程式消息處理機制：
A. 作業系統接收應用程式的視窗消息，将消息投遞到該應用程式的消息隊列中
B. 應用程式在消息循環中調用GetMessage函數從消息隊列中取出一條一條的消息，取出消息後，應用程式可以對消息進行一些預處理。
C. 應用程式調用DispatchMessage，将消息回傳給作業系統。
D. 系統利用WNDCLASS結構體的lpfnWndProc成員儲存的視窗過程函數的指針調用視窗過程，對消息進行處理。
8. 如何定義和實作一個類的成員函數為回調函數
A.什麼是回調函數?
簡而言之，回調函數就是被調用者回頭調用調用者的函數。
使用回調函數實際上就是在調用某個函數（通常是API函數）時，将自己的一個函數（這個函數為回調函數）的位址作為參數傳遞給那個被調用函數。而該被調用函數在需要的時候，利用傳遞的位址調用回調函數。
回調函數，就是由你自己寫的，你需要調用另外一個函數，而這個函數的其中一個參數，就是你的這個回調函數名。這樣，系統在必要的時候，就會調用你寫的回調函數，這樣你就可以在回調函數裡完成你要做的事。
B.如何定義和實作一個類的成員函數為回調函數
要定義和實作一個類的成員函數為回調函數需要做三件事：
a．聲明；
b．定義；
c．設定觸發條件，就是在你的函數中把你的回調函數名作為一個參數，以便系統調用
如：
一、聲明回調函數類型
typedef void (*FunPtr)(void);
二、定義回調函數
class A
{
public:
A();
static void callBackFun(void) //回調函數，必須聲明為static
{
cout<<"callBackFun"<<endl;
}
virtual ~A();
};
三、設定觸發條件
void Funtype(FunPtr p)
{
p();
}
void main(void)
{
Funtype(A::callBackFun);
}
C. 回調函數與API函數
回調和API非常接近，他們的共性都是跨層調用的函數。但差別是API是低層提供給高層的調用，一般這個函數對高層都是已知的；而回調正好相反，他是高層提供給底層的調用，對于低層他是未知的，必須由高層進行安裝，這個安裝函數其實就是一個低層提供的API，安裝後低層不知道這個回調的名字，但它通過一個函數指針來儲存這個回調函數，在需要調用時，隻需引用這個函數指針和相關的參數指針。
其實：回調就是該函數寫在高層，低層通過一個函數指針儲存這個函數，在某個事件的觸發下，低層通過該函數指針調用高層那個函數。
1) 什麼是預編譯，何時需要預編譯：
總是使用不經常改動的大型代碼體。
程式由多個子產品組成，所有子產品都使用一組标準的包含檔案和相同的編譯選項。在這種情況下，可以将所有包含檔案預編譯為一個預編譯頭。
2) char * const p;
char const * p
const char *p
上述三個有什麼差別？
char * const p; //常量指針，p的值不可以修改
char const * p；//指向常量的指針，指向的常量值不可以改
const char *p； //和char const *p
3) 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;
cout << ( str3 == str4 ) << endl;
cout << ( str5 == str6 ) << endl;
cout << ( str7 == str8 ) << endl;
結果是：0 0 1 1
解答：str1,str2,str3,str4是數組變量，它們有各自的記憶體空間；而str5,str6,str7,str8是指針，它們指向相同的常量區域。
4) 以下代碼中的兩個sizeof用法有問題嗎？
void UpperCase( char str[] ) // 将 str 中的小寫字母轉換成大寫字母
{
for( size_t i=0; i<sizeof(str)/sizeof(str[0]); ++i )
if( 'a'<=str[i] && str[i]<='z' )
str[i] -= ('a'-'A' );
}
char str[] = "aBcDe";
cout << "str字元長度為: " << sizeof(str)/sizeof(str[0]) << endl;
UpperCase( str );
cout << str << endl;
答：函數内的sizeof有問題。根據文法，sizeof如用于數組，隻能測出靜态數組的大小，無法檢測動态配置設定的或外部數組大小。函數外的str是一個靜态定義的數組，是以其大小為6，函數内的str實際隻是一個指向字元串的指針，沒有任何額外的與數組相關的資訊，是以sizeof作用于上隻将其當指針看，一個指針為4個位元組，是以傳回4。
5) 一個32位的機器,該機器的指針是多少位？
指針是多少位隻要看位址總線的位數就行了。80386以後的機子都是32的資料總線。是以指針的位數就是4個位元組了。
6) main()
{
int a[5]={1,2,3,4,5};
int *ptr=(int *)(&a+1);
printf("%d,%d",*(a+1),*(ptr-1));
}
輸出：2,5
*(a+1）就是a[1]，*(ptr-1)就是a[4],執行結果是2，5
&a+1不是首位址+1，系統會認為加一個a數組的偏移，是偏移了一個數組的大小（本例是5個int）
int *ptr=(int *)(&a+1);
則ptr實際是&(a[5]),也就是a+5
原因如下：
&a是數組指針，其類型為 int (*)[5];
而指針加1要根據指針類型加上一定的值，不同類型的指針+1之後增加的大小不同。
a是長度為5的int數組指針，是以要加 5*sizeof(int)
是以ptr實際是a[5]
但是prt與(&a+1)類型是不一樣的(這點很重要)
是以prt-1隻會減去sizeof(int*)
a,&a的位址是一樣的，但意思不一樣，a是數組首位址，也就是a[0]的位址，&a是對象（數組）首位址，a+1是數組下一進制素的位址，即a[1],&a+1是下一個對象的位址，即a[5].
7) 請問以下代碼有什麼問題：
int main()
{
char a;
char *str=&a;
strcpy(str,"hello");
printf(str);
return 0;
}
沒有為str配置設定記憶體空間，将會發生異常。問題出在将一個字元串複制進一個字元變量指針所指位址。雖然可以正确輸出結果，但因為越界進行内在讀寫而導緻程式崩潰。
8)
char* s="AAA";
printf("%s",s);
s[0]='B';
printf("%s",s);
有什麼錯？
"AAA"是字元串常量。s是指針，指向這個字元串常量，是以聲明s的時候就有問題。
cosnt char* s="AAA";
然後又因為是常量，是以對是s[0]的指派操作是不合法的。
9) 寫一個“标準”宏，這個宏輸入兩個參數并傳回較小的一個。
.#define Min(X, Y) ((X)>(Y)?(Y):(X))//結尾沒有;
10) 嵌入式系統中經常要用到無限循環，你怎麼用C編寫死循環。
while(1){}或者for(;;)
軟體開發網 www.mscto.cn
11) 關鍵字static的作用是什麼？
定義靜态變量
12) 關鍵字const有什麼含意？
表示常量不可以修改的變量。
13) 關鍵字volatile有什麼含意？并舉出三個不同的例子？
提示編譯器對象的值可能在編譯器未監測到的情況下改變。
14) int (*s[10])(int) 表示的是什麼？
int (*s[10])(int) 函數指針數組，每個指針指向一個int func(int param)的函數。
15) 有以下表達式：
int a=248; b=4;
int const c=21;
const int *d=&a;
int *const e=&b;
int const *f const =&a;
請問下清單達式哪些會被編譯器禁止？為什麼？
*c=32;d=&b;*d=43;e=34;e=&a;f=0x321f;
*c 這是個什麼東東，禁止
*d 說了是const， 禁止
e = &a 說了是const 禁止
const *f const =&a; 禁止
16) 交換兩個變量的值，不使用第三個變量。即a=3,b=5,交換之後a=5,b=3;
有兩種解法, 一種用算術算法, 一種用^(異或)
a = a + b;
b = a - b;
a = a - b;
or
a = a^b;// 隻能對int,char..
b = a^b;
a = a^b;
or
a ^= b ^= a;
17) c和c++中的struct有什麼不同？
c和c++中struct的主要差別是c中的struct不可以含有成員函數，而c++中的struct可以。c++中struct和class的主要差別在于預設的存取權限不同，struct預設為public，而class預設為private。
18) #include <stdio.h>
#include <stdlib.h>
void getmemory(char *p)
{
p=(char *) malloc(100);
strcpy(p,"hello world");
}
int main( )
{
char *str=NULL;
getmemory(str);
printf("%s/n",str);
free(str);
return 0;
}
程式崩潰，getmemory中的malloc 不能傳回動态記憶體， free（）對str操作很危險
19) char szstr[10];
strcpy(szstr,"0123456789");
産生什麼結果？為什麼？
長度不一樣，會造成非法的OS
20) 列舉幾種程序的同步機制，并比較其優缺點。
原子操作
信号量機制
自旋鎖
管程，會合，分布式系統
21) 程序之間通信的途徑
共享存儲系統
消息傳遞系統
管道：以檔案系統為基礎
22) 程序死鎖的原因
資源競争及程序推進順序非法
23) 死鎖的4個必要條件
互斥、請求保持、不可剝奪、環路
24) 死鎖的處理
鴕鳥政策、預防政策、避免政策、檢測與解除死鎖
25) 作業系統中程序排程政策有哪幾種？
FCFS(先來先服務)，優先級，時間片輪轉，多級回報
26) 類的靜态成員和非靜态成員有何差別？
類的靜态成員每個類隻有一個，非靜态成員每個對象一個
27) 純虛函數如何定義？使用時應注意什麼？
virtual void f()=0;
是接口，子類必須要實作
28) 數組和連結清單的差別
數組：資料順序存儲，固定大小
連表：資料可以随機存儲，大小可動态改變
29) ISO的七層模型是什麼？tcp/udp是屬于哪一層？tcp/udp有何優缺點？
應用層
表示層
會話層
運輸層
網絡層
實體鍊路層
實體層
tcp /udp屬于運輸層
TCP 服務提供了資料流傳輸、可靠性、有效流控制、全雙工操作和多路複用技術等。
與 TCP 不同， UDP 并不提供對 IP 協定的可靠機制、流控制以及錯誤恢複功能等。由于 UDP 比較簡單， UDP 頭包含很少的位元組，比 TCP 負載消耗少。
tcp: 提供穩定的傳輸服務，有流量控制，缺點是標頭大，備援性不好
udp: 不提供穩定的服務，標頭小，開銷小
30) (void *)ptr 和 (*(void**))ptr的結果是否相同？
其中ptr為同一個指針(void *)ptr 和 (*(void**))ptr值是相同的
32)
int main()
{
int x=3;
printf("%d",x);
return 1;
}
問函數既然不會被其它函數調用，為什麼要傳回1？
mian中，c标準認為0表示成功，非0表示錯誤。具體的值是某中具體出錯資訊
33) 要對絕對位址0x100000指派，我們可以用(unsigned int*)0x100000 = 1234;那麼要是想讓程式跳轉到絕對位址是0x100000去執行，應該怎麼做？
*((void (*)( ))0x100000 ) ( );
首先要将0x100000強制轉換成函數指針,即:
(void (*)())0x100000
然後再調用它:
*((void (*)())0x100000)();
用typedef可以看得更直覺些:
typedef void(*)() voidFuncPtr;
*((voidFuncPtr)0x100000)();
34) 已知一個數組table，用一個宏定義，求出資料的元素個數
#define NTBL
#define NTBL (sizeof(table)/sizeof(table[0]))
35) 線程與程序的差別和聯系? 線程是否具有相同的堆棧? dll是否有獨立的堆棧?
程序是死的，隻是一些資源的集合，真正的程式執行都是線程來完成的，程式啟動的時候作業系統就幫你建立了一個主線程。
每個線程有自己的堆棧。DLL中有沒有獨立的堆棧？
這個問題不好回答，或者說這個問題本身是否有問題。因為DLL中的代碼是被某些線程所執行，隻有線程擁有堆棧，如果DLL中的代碼是EXE中的線程所調用，那麼這個時候是不是說這個DLL沒有自己獨立的堆棧？如果DLL中的代碼是由DLL自己建立的線程所執行，那麼是不是說DLL有獨立的堆棧？
以上講的是堆棧，如果對于堆來說，每個DLL有自己的堆，是以如果是從DLL中動态配置設定的記憶體，最好是從DLL中删除，如果你從DLL中配置設定記憶體，然後在EXE中，或者另外一個DLL中删除，很有可能導緻程式崩潰。
36) unsigned short A = 10;
printf("~A = %u\n", ~A);
char c=128;
printf("c=%d\n",c);
輸出多少？并分析過程
第一題，～A ＝0xfffffff5,int值 為－11，但輸出的是uint。是以輸出4294967285
第二題，c＝0x10,輸出的是int，最高位為1，是負數，是以它的值就是0x00的補碼就是128，是以輸出－128。
這兩道題都是在考察二進制向int或uint轉換時的最高位處理。
37) 分析下面的程式：
void GetMemory(char **p,int num)
{
*p=(char *)malloc(num);
}
int main()
{
char *str=NULL;
GetMemory(&str,100);
strcpy(str,"hello");
free(str);
if(str!=NULL)
{
strcpy(str,"world");
}
printf("\n str is %s",str); 軟體開發網 www.mscto.com
getchar();
}
問輸出結果是什麼？
輸出str is world。
free 隻是釋放的str指向的記憶體空間,它本身的值還是存在的.是以free之後，有一個好的習慣就是将str=NULL.
此時str指向空間的記憶體已被回收,如果輸出語句之前還存在配置設定空間的操作的話,這段存儲空間是可能被重新配置設定給其他變量的,
盡管這段程式确實是存在大大的問題（上面各位已經說得很清楚了），但是通常會列印出world來。
這是因為，程序中的記憶體管理一般不是由作業系統完成的，而是由庫函數自己完成的。
當你malloc一塊記憶體的時候，管理庫向作業系統申請一塊空間（可能會比你申請的大一些），然後在這塊空間中記錄一些管理資訊（一般是在你申請的記憶體前面一點），并将可用記憶體的位址傳回。但是釋放記憶體的時候，管理庫通常都不會将記憶體還給作業系統，是以你是可以繼續通路這塊位址的。
char a[10],strlen(a)為什麼等于15？運作的結果
38) #include "stdio.h"
#include "string.h"
void main()
{
char aa[10];
printf("%d",strlen(aa));
}
sizeof()和初不初始化，沒有關系；
strlen()和初始化有關。
39) char (*str)[20];
char *str[20];
40) long a=0x801010;
a+5=?
0x801010用二進制表示為：“1000 0000 0001 0000 0001 0000”，十進制的值為8392720，再加上5就是8392725羅
41) 給定結構
struct A
{
char t:4;
char k:4;
unsigned short i:8;
unsigned long m;
};
問sizeof(A) = ?
給定結構
struct A
{
char t:4; 4位
char k:4; 4位
unsigned short i:8; 8位
unsigned long m; // 偏移2位元組保證4位元組對齊
}; // 共8位元組
42) 下面的函數實作在一個數上加一個數，有什麼錯誤？請改正。
int add_n ( int n )
{
static int i = 100;
i += n;
return i;
}
當你第二次調用時得不到正确的結果，難道你寫個函數就是為了調用一次？問題就出在 static上？
43) 分析一下
#include<iostream.h>
#include <string.h>
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
typedef struct AA
{
int b1:5;
int b2:2;
}AA;
void main()
{
AA aa;
char cc[100];
strcpy(cc,"0123456789abcdefghijklmnopqrstuvwxyz");
memcpy(&aa,cc,sizeof(AA));
cout << aa.b1 <<endl;
cout << aa.b2 <<endl;
}
答案是 -16和１
首先sizeof(AA)的大小為4,b1和b2分别占5bit和2bit.經過strcpy和memcpy後,aa的4個位元組所存放的值是: 0,1,2,3的ASC碼，即00110000,00110001,00110010,00110011是以，最後一步：顯示的是這４個位元組的前５位，和之後的２位分别為：10000,和01，因為int是有正負之分
是以：答案是-16和１
44) 求函數傳回值，輸入x=9999;
int func （ x ）
{
int countx = 0;
while ( x )
{
countx ++;
x = x&(x-1);
}
return countx;
}
結果呢？
知道了這是統計9999的二進制數值中有多少個1的函數，且有9999＝9×1024＋512＋256＋15
9×1024中含有1的個數為2；
512中含有1的個數為1；
256中含有1的個數為1；
15中含有1的個數為4； 軟體開發網 www.mscto.com
故共有1的個數為8，結果為8。
1000 - 1 = 0111，正好是原數取反。這就是原理。
用這種方法來求1的個數是很效率很高的。
不必去一個一個地移位。循環次數最少。
int a,b,c 請寫函數實作C=a+b ,不可以改變資料類型,如将c改為long int,關鍵是如何處理溢出問題
bool add (int a, int b,int *c)
{
*c=a+b;
return (a>0 && b>0 &&(*c<a || *c<b) || (a<0 && b<0 &&(*c>a || *c>b)));
}
45) 分析：
struct bit
{
int a:3;
int b:2;
int c:3;
};
int main()
{
bit s;
char *c=(char*)&s;
cout<<sizeof(bit)<<endl;
*c=0x99;
cout << s.a <<endl <<s.b<<endl<<s.c<<endl;
int a=-1;
printf("%x",a);
return 0;
}
輸出為什麼是
4
1
-1
-4
ffffffff
因為0x99在記憶體中表示為 100 11 001 , a = 001, b = 11, c = 100。當c為有符合數時, c = 100, 最高1為表示c為負數，負數在計算機用補碼表示，是以c = -4;同理 b = -1;當c為有符合數時, c = 100,即 c = 4,同理 b = 3。
46) 位域 ：
有些資訊在存儲時，并不需要占用一個完整的位元組， 而隻需占幾個或一個二進制位。例如在存放一個開關量時，隻有0和1 兩種狀态，用一位二進位即可。為了節省存儲空間，并使處理簡便，Ｃ語言又提供了一種資料結構，稱為“位域”或“位段”。所謂“位域”是把一個位元組中的二進位劃分為幾個不同的區域，并說明每個區域的位數。每個域有一個域名，允許在程式中按域名進行操作。這樣就可以把幾個不同的對象用一個位元組的二進制位域來表示。一、位域的定義和位域變量的說明位域定義與結構定義相仿，其形式為：
struct 位域結構名 { 位域清單 }; 其中位域清單的形式為：類型說明符位域名：位域長度
例如：
struct bs
{
int a:8;
int b:2;
int c:6;
};
位域變量的說明與結構變量說明的方式相同。可采用先定義後說明，同時定義說明或者直接說明這三種方式。例如：
struct bs
{
int a:8;
int b:2;
int c:6;
}data;
說明data為bs變量，共占兩個位元組。其中位域a占8位，位域b占2位，位域c占6位。對于位域的定義尚有以下幾點說明：
一個位域必須存儲在同一個位元組中，不能跨兩個位元組。如一個位元組所剩空間不夠存放另一位域時，應從下一單元起存放該位域。也可以有意使某位域從下一單元開始。例如：
struct bs
{
unsigned a:4
unsigned :0
unsigned b:4
unsigned c:4
}
在這個位域定義中，a占第一位元組的4位，後4位填0表示不使用，b從第二位元組開始，占用4位，c占用4位。
由于位域不允許跨兩個位元組，是以位域的長度不能大于一個位元組的長度，也就是說不能超過8位二進位。
位域可以無位域名，這時它隻用來作填充或調整位置。無名的位域是不能使用的。例如：
struct k
{
int a:1
int :2
int b:3
int c:2
};
從以上分析可以看出，位域在本質上就是一種結構類型，不過其成員是按二進位配置設定的。
位域的使用位域的使用和結構成員的使用相同，其一般形式為：位域變量名?位域名位域允許用各種格式輸出。
main()
{
struct bs
{
unsigned a:1;
unsigned b:3;
unsigned c:4;
}
bit,*pbit;
bit.a=1;
bit.b=7;
bit.c=15;
pri
47) 改錯：
#include <stdio.h>
int main(void)
{
int **p;
int arr[100];
p = &arr;
return 0;
}
解答：搞錯了,是指針類型不同,int **p; //二級指針&arr; //得到的是指向第一維為100的數組的指針
#include <stdio.h>
int main(void)
{
int **p, *q;
int arr[100];
q = arr;
p = &q;
return 0;
}
48) 下面這個程式執行後會有什麼錯誤或者效果:
#define MAX 255
int main()
{
unsigned char A[MAX],i;//i被定義為unsigned char
for (i=0;i<=MAX;i++)
A[i]=i;
return 0;
}
解答：死循環加數組越界通路（C/C++不進行數組越界檢查）MAX=255 數組A的下标範圍為:0..MAX-1,這是其一..
其二.當i循環到255時,循環内執行:A[255]=255;這句本身沒有問題..但是傳回for (i=0;i<=MAX;i++)語句時,由于unsigned char的取值範圍在(0..255),i++以後i又為0了..無限循環下去。
49) struct name1
{
char str;
short x;
int num;
}
struct name2
{
char str;
int num;
short x;
}
sizeof(struct name1)=8,sizeof(struct name2)=12
在第二個結構中，為保證num按四個位元組對齊，char後必須留出3位元組的空間；同時為保證整個結構的自然對齊（這裡是4位元組對齊），在x後還要補齊2個位元組，這樣就是12位元組。
50) intel：
A.c 和B.c兩個c檔案中使用了兩個相同名字的static變量,編譯的時候會不會有問題?這兩個static變量會儲存到哪裡（棧還是堆或者其他的）?
static的全局變量，表明這個變量僅在本子產品中有意義，不會影響其他子產品。他們都放在資料區，但是編譯器對他們的命名是不同的。如果要使變量在其他子產品也有意義的話，需要使用extern關鍵字。
51) struct s1
{
int i: 8;
int j: 4;
int a: 3;
double b;
};
struct s2
{
int i: 8;
int j: 4;
double b;
int a:3;
};
printf("sizeof(s1)= %d\n", sizeof(s1));
printf("sizeof(s2)= %d\n", sizeof(s2));
result: 16, 24
第一個struct s1
{
int i: 8;
int j: 4;
int a: 3;
double b;
};
理論上是這樣的，首先是i在相對0的位置，占8位一個位元組，然後，j就在相對一個位元組的位置，由于一個位置的位元組數是4位的倍數，是以不用對齊，就放在那裡了，然後是a，要在3位的倍數關系的位置上，是以要移一位，在15位的位置上放下，目前總共是18位，折算過來是2位元組2位的樣子，由于double 是8位元組的，是以要在相對0要是8個位元組的位置上放下，是以從18位開始到8個位元組之間的位置被忽略，直接放在8位元組的位置了，是以，總共是16位元組。
第二個最後會對照是不是結構體内最大資料的倍數，不是的話，會補成是最大資料的倍數。
![swmm與lisflood-fp源碼如何一起編譯 CMake指令[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)