1．燒一根不均勻的繩子，從頭燒到尾總共需要 1 個小時，問如何用燒繩子的方法來確定半小時的時間呢？

2．10 個海盜搶到了100 顆寶石，每一顆都一樣大小且價值連城。他們決定這么分：

（1）抽簽決定自己的號碼（1~10）；

（2）首先，由1 號提出分配方案，然后大家表決，當且僅當超過半數的人同意時，按照他的方案進行分配，否則將被扔進大海喂鯊魚；

（3）如果1 號死后，再由2 號提出分配方案，然后剩下的4 個人進行表決，當且僅當超過半數的人同意時，按照他的方案進行分配，否則將被扔入大海喂鯊魚；

（4）依此類推

條件：每個海盜都是很聰明的人，都能很理智地做出判斷，從而做出選擇。

問題：第一個海盜提出怎樣的分配方案才能使自己的收益最大化？

3．為什么下水道的蓋子是圓的？

4．中國有多少輛汽車？

5．你讓工人為你工作7 天，回報是一根金條，這根金條平分成相連的7 段,你必須在每天結束的時候給他們一段金條。如果只允許你兩次把金條弄斷，你如何給你的工人付費？

6．有一輛火車以每小時15 公里的速度離開北京直奔廣州，同時另一輛火車以每小時20 公里的速度從廣州開往北京。如果有一只鳥，以30 公里每小時的速度和兩輛火車同時啟動，從北京出發，碰到另一輛車后就向相反的方向返回去飛，就這樣依次在兩輛火車之間來回地飛，直到兩輛火車相遇。請問， 這只鳥共飛行了多長的距離？

7．你有兩個罐子以及50 個紅色彈球和50 個藍色彈球，隨機選出一個罐子，隨機選出一個彈球放入罐子，怎樣給出紅色彈球最大的選中機會？在你的計劃里，得到紅球的幾率是多少？

8．想像你站在鏡子前，請問，為什么鏡子中的影像可以左右顛倒，卻不能上下顛倒呢？

9．如果你有無窮多的水，一個3 公升的提捅，一個5 公升的提捅，兩只提捅形狀上下都不均勻，問你如何才能準確稱出4 公升的水？

10．你有一桶果凍，其中有黃色、綠色、紅色三種，閉上眼睛抓取同種顏色的兩個。抓取多少次就可以確定你肯定有兩個同一顏色的果凍？

11．連續整數之和為1000 的共有幾組？

12．從同一地點出發的相同型號的飛機，可是每架飛機裝滿油只能繞地球飛半周，飛機之間可以加油，加完油的飛機必須回到起點。問至少要多少架次，才能滿足有一架繞地球一周。

1．兩邊一起燒。

2．96，0，1，0，1，0，1，0，1，0。

3．因為口是圓的。

4．很多。

5．分1，2，4。

6．6/7 北京到廣州的距離。

7．100%。

8．平面鏡成像原理（或者是“眼睛是左右長的”）。

9．3 先裝滿，倒在5 里，再把3 裝滿，倒進5 里。把5 里的水倒掉，把3 里

剩下的水倒進5 里，再把3 裝滿，倒進5 里，ok！

10．一次。

11．首先1000 為一個解。連續數的平均值設為x，1000 必須是x 的整數倍。

假如連續數的個數為偶數個，x 就不是整數了。x 的2 倍只能是5，25，125 才行。

因為平均值為12.5,要連續80 個達不到。125/2=62.5 是可以的。即62，63，61，

64，等等。連續數的個數為奇數時，平均值為整數。1000 為平均值的奇數倍。

1000=2×2×2×5×5×5；x 可以為2，4，8，40，200 排除后剩下40 和200 是可以的。所以答案為平均值為62.5，40，200，1000 的4 組整數。

12．答案是5 架次。一般的解法可以分為如下兩個部分：

（1）直線飛行

一架飛機載滿油飛行距離為1，n 架飛機最遠能飛多遠？在不是兜圈沒有迎頭接應的情況，這問題就是n 架飛機能飛多遠？存在的極值問題是不要重復飛行，比如兩架飛機同時給一架飛機加油且同時飛回來即可認為是重復，或者換句話說，離出發點越遠，在飛的飛機就越少，這個極值條件是顯然的，因為n 架飛機帶的油是一定的，如重復，則浪費的油就越多。比如最后肯定是只有一架飛機全程飛行，注意“全程”這兩個字，也就是不要重復的極值條件。如果是兩架飛機的話，肯定是一架給另一架加滿油，并使剩下的油剛好能回去，就說第二架飛機帶的油耗在3 倍于從出發到加油的路程上，有三架飛機第三架帶的油耗在倍于從出發到其加油的路程上，所以n 架飛機最遠能飛行的距離為s=1+1/3+?+1/（2n+1）這個級數是發散的，所以理論上只要飛機足夠多最終可以使一架飛機飛到無窮遠，當然實際上不可能一架飛機在飛行1/（2n+1）時間內同時給n個飛機加油。

（2）可以迎頭接應加油

一架飛機載滿油飛行距離為1/2，最少幾架飛機能飛行距離1？也是根據不要重復飛行的極值條件，得出最遠處肯定是只有一架飛機飛行，這樣得出由1/2處對稱兩邊1/4 肯定是一架飛機飛行，用上面的公式即可知道一邊至少需要兩架飛機支持，（1/3+1/5）/2>1/4（左邊除以2 是一架飛機飛行距離為1/2），但是有一點點剩余，所以想像為一個滑輪（中間一個飛機是個繩子，兩邊兩架飛機是個棒）的話，可以滑動一點距離，就說加油地點可以在一定距離內變動（很容)易算出來每架飛機的加油地點和加油數量，等等

1寫出下列算法的時間復雜度。

(1)冒泡排序；

(2)選擇排序；

(3)插入排序；

(4)快速排序；

(5)堆排序；

(6)歸并排序；

2寫出下列程序在X86上的運行結果。

struct mybitfields

{

unsigned short a : 4;

unsigned short b : 5;

unsigned short c : 7;

}test

void main(void)

{

int i;

test.a=2;

test.b=3;

test.c=0;

i=*((short *)&test);

printf("%d\n",i);

}

3寫出下列程序的運行結果。

unsigned int i=3;

cout<<i * -1;

4寫出下列程序所有可能的運行結果。

int a;

int b;

int c;

void F1()

{

b=a*2;

a=b;

}

void F2()

{

c=a+1;

a=c;

}

main()

{

a=5;

//Start F1,F2 in parallel

F1(); F2();

printf("a=%d\n",a);

}

5考察了一個CharPrev()函數的作用。

6對 16 Bits colors的處理，要求：

（1）Byte轉換為RGB時，保留高5、6bits；

（2）RGB轉換為Byte時，第2、3位置零。

7一個鏈表的操作，注意代碼的健壯和安全性。要求：

（1）增加一個元素；

（2）獲得頭元素；

（3）彈出頭元素（獲得值并刪除）。

8一個給定的數值由左邊開始升位到右邊第N位，如 0010<<1 == 0100 或者 0001 0011<<4 == 0011 0000

請用C或者C++或者其他X86上能運行的程序實現。

附加題（只有在完成以上題目后，才獲準回答）

In C++, what does "explicit" mean? what does "protected" mean?

某棟寫字樓6層，有1部電梯，請編寫一個電梯仿真程序

A.考慮如下條件

1.每層樓都有上行和下行兩個按鍵

2. 電梯一開始停在1層

3. 電梯可以容納8個人

4. 乘坐電梯的客人的請求頻率，時間間隔和到達樓層是隨機的

5. 電梯的上下一層需要1秒

6. 電梯空間有限，同時只能容納一定數量的客人，如果已經達到人數額度，電梯將不理會任何請求

7.不考慮客人請求當前樓層和不請求樓層的情況

8. 電梯的響應延遲為0（比如，電梯往3樓上行，3樓的客人在電梯到達3樓之前按上行鍵，程序有權調度電梯在3樓開門）

9. 電梯的開關門時間和客人上下電梯時間為0，勻速運行

10. 電梯調度算法不能預讀尚未發生的請求（比如在10秒的時候電梯無法預知11秒時某層客人的請求)

11.客人請求發生在整數秒

B.目標

1. 在運送所有客人到達目標樓層的前提下電梯的總行程盡可能小

2. 設計一個接口，實現調度算法的可替換性（比如，通過重新實現該接口可以使系統使用其它算法）

C. 輸入和輸出

輸入:

input.txt

客人的請求序列，格式為到達時間，所在樓層，請求樓層，假設該輸入是按照時間遞增的

比如：

input.txt

1 2 3

2 3 1

在1秒的時候有客人請求從2層到3層，2秒的時候有客人請求從3層到1層

輸出: 設計一種簡單實用的輸出可以清晰地反映電梯的運轉情況

選擇題部分

1. 以下哪些不是棧的基本操作

A. push

B. pop

C. 判斷棧是否為空

D. 棧排序

2.兩個有序數組 大小都是 n，現在要對它們進行合并排序。 問最壞情況下，需要比較多少次？

A. 2n+1

B. 2n

C.2n-1

D…記不清了

3. （an 表示第 n 個常數， x^5 表示 x 的 5 次方）

f（x）= a0*x^0 + a1*x^1+a2*x^2+……an*x^n

對于固定的 n，f（x）的時間復雜度以及空間復雜度分別是多少？

A. o（n^2），o（n）

B.o（n），o（1）

C

D 都記不住了

4.是個概率題，大概意思是這樣的

現在有 800 個人，但是只有 400 份獎品，有一對夫婦都參加抽獎，但是他們最多抽到一份獎，現在問

他們倆能抽到一份獎的概率是多少？

A.0.5

B.0.75

C. （0.5,0.75）

D. （0.75,1）

5. 現有一鏈表當前指示節點為 currentNode, 生成了一個新節點 newNode,問要把 newNode 插入到currentNode 之后 ，該怎么做？

A…

B…

C. newNode->next = currentNode->next, currentNode->next = newNode.

D…

6. 問以下哪些特征不是 interpreted language（解釋型語言）所獨有的：

（我們知道一般分為兩種：解釋型語言 VB,Shell,批處理等；編譯型語言，C，java 等。各有優點 ）

A. 平臺無關性。（明顯不對，因為 java 才是平臺無關的）

B. 執行速度較快（這個問題，以前做作業時就沒爭論清楚，自己感覺解釋型語言不需要編譯，速度能快一些，但是重復執行時，編譯型語言只需要編譯一次，效率高……）

C. 可以定義動態變量（應該兩種都可以）

D.以上都不對

7.給了一個二叉樹，讓求后序遍歷的結果。

這個題如果知道后序遍歷，肯定就可以做出來了。

盡管不難 還是要搞清楚三者的區別（哈哈）

先序 左根右

中序 根左右

后序 左右根

8.問以下幾種排序方法，在最壞情況下時間復雜度小于 o（n^2）的是哪一種（這個題目記得不是很清楚了）

A.快排

B.插入排序

C.合并排序

D.棧排序

9. 現有 n+1 這么大的存儲空間（可以理解有這么一個大小為 n+1 的數組），中間存了[1,n+1]范圍內的n 個數，說明丟失了一個數，現在要找出這個丟失的數，問最好情況下時間復雜度是多少

A.o（1）

B.o（n）

C.o（n^2）

D.o（nlogn）

10.是一道程序題，由于太長，無從記憶……

編程題部分用 C,C++,C#,或 Java 中的一種來編寫以下程序。

現在給你一個 字符串，其中特殊的字符只有兩種 space（空格）（" "），newline（換行）（/n）。 現在讓你來去除其中多余的空格。具體要求

1.連續的空格只能當保留其中一個

2. 該字符串的開頭不能有空格

3. 該字符串的結尾不能有空格

4. 任何/n 的前面或才后面都不能存在多余的空格

為了得到很高的分數，還需要滿足以下條件

1.不能申請新的字符串空間

2.對給出的字符串只能遍歷一遍

不能使用任何庫函數。

我們給了兩個供你調用的函數

int intIsSpace（char str）（）

當字符不為空格時，將返回 0

當字符為空格時，將返回其它任意非 0 值

int intIsNewLine（char str）（）當字符不為換行時，將返回 0

當字符為換行時，將返回其它任意非 0 值

程序編寫完成后，請編寫測試用例，并說明它完成的作用。

1) How would you calculate the hash value of a string?

2) List two major requirements of a hashing function

Assuming A, B, C are conditions. You can write logical expression that yields specific results. For example,

Please write the simplest logical expression that will give the following results (using only

Please rewrite the following If statements (in C) into just one If statement

For example,

if ( a > 10 )

{

if ( b < 5 )

{

Run();

}

}

can be rewritten as if ( a > 10 && b < 5 ) { Run(); }

Please rewrite the following if statement:

if ( a > 10 && b < 5)

{

if ( a > 15 )

{

Run();

}

}

else if ( b > 6 )

{

Run();

}

Please write a function in C to copy one string to another, while return the largest letter in the string. Please do not use any C runtime function.

The following code will display “Z”

char sz[100];

char ch;

ch = StringCopy( “Test Zoo”, sz );

printf( ch );

Binary tree can be used for storing and searching data. Please draw a binary tree, constructed by entering the following numbers in sequence:

8, 3, 10, 50, 9, 20, 1, -5, 2, 70, 35, 45, -10, 49, 0

Please draw a balanced binary tree using the same set of numbers as above.

Please define the data structure required to store a linked list of integer and write a routine to delete an integer from a given linked list of integers.

Please explain the difference between array and link-list.

If you are asked to implement a stack, will you use array, or link-list, or both? What are the limitations of using each one?

What is a message pump in Windows?

Please list names of Windows message that is sent when:

• A window is created: ______________________
• A window needs to be painted: ______________________
• A window is destroyed: ______________________

1．改錯

#include <stdio.h>

#include <String.h>

class CBuffer

{

char * m_pBuffer;

int m_size;

public:

CBuffer()

{

m_pBuffer=NULL;

}

~CBuffer()

{

Free();

}

void Allocte(int size) （3） {

m_size=size;

m_pBuffer= new char[size];

}

private:

void Free()

{

if(m_pBuffer!=NULL)

{

delete m_pBuffer;

m_pBuffer=NULL;

}

}

public:

void SaveString(const char* pText) const

{

strcpy(m_pBuffer, pText);

}

char* GetBuffer() const

{

return m_pBuffer;

}};

void main (int argc, char* argv[])

{

CBuffer buffer1;

buffer1.SaveString("Microsoft");

printf(buffer1.GetBuffer());

}

答：改正后

主要改正 SaveString 函數

將

void SaveString(const char* pText) const

{

strcpy(m_pBuffer, pText);

}

改為

void SaveString(const char* pText) （1）

{

Allocte(strlen(pText)+1); （2）

strcpy(m_pBuffer, pText);

}

原因：

（1） const 成員函數表示不會修改數據成員，而 SaveString 做不到，去掉 const 聲明

（2） m_pBuffer 指向 NULL，必須用 Allocte 分配空間才能賦值。

（3） 另外需要將 Allocte 成員函數聲明為私有成員函數更符合實際

2.下來程序想打印“Welcome MSR Asia”，改正錯誤

#include <stdio.h>

#include <string.h>

char * GetName (void)

{

//To return “MSR Asia” String

char name[]="MSR Asia";

return name;

}

void main(int argc, char* argv[])

{

char name[32];

//Fill in zeros into name

for(int i=0;i<=32;i++)

{

name[i]='\0';}

//copy “Welcome” to name

name="Welcome";

//Append a blank char

name[8]=" ";

//Append string to name

strcat(name,GetName());

//print out

printf(name);

}

答：改正后為

#include <stdio.h>

#include <string.h>

char * GetName (void)

{

//To return “MSR Asia” String

//char name[]="MSR Asia"; （1）

char *name=(char *)malloc(strlen("MSR Asia")+1);

strcpy(name,"MSR Asia");

return name;

}

void main(int argc, char* argv[])

{

char name[32];

//Fill in zeros into name

for(int i=0;i<=32;i++)

{

name[i]='\0';

}

//copy “Welcome” to name

//name="Welcome"; （2）

strcat(name,"Welcome ");

//Append a blank char

// name[8]=' '; （3）

//Append string to name

char *p=GetName(); （4）

strcat(name,p);

free (p);

//print out

printf(name);

}

原因：（1）在函數內部定義的變量在函數結束時就清空了，必須動態分配內存（2）字符串賦值語句錯誤，應該用 strcat

（3）該語句無效，可去掉

（4）定義一個指針指向動態分配的內存，用完后需用 free 語句釋放

3．寫出下面程序的輸出結果

#include <stdio.h>

class A

{

public:

void FuncA()

{

printf("FuncA called\n");

}

virtual void FuncB()

{

printf("FuncB called\n");

}

};

class B: public A

{

public:

void FuncA()

{

A::FuncA();

printf("FuncAB called\n");

}

virtual void FuncB()

{

printf("FuncBB called\n");

}

};

void main(void)

{

B b;

A *pa;

pa=&b;

A *pa2=new A;

b.FuncA(); （1）

b.FuncB(); （2）

pa->FuncA(); （3）pa->FuncB(); （4）

pa2->FuncA(); （5）

pa2->FuncB();

delete pa2;

}

答：

1．b.FuncA(); 輸出

FuncA called

FuncAB called

2．b.FuncB();輸出

FuncBB called

上兩者好理解，直接調用類 B 的相應成員函數

3．pa->FuncA();輸出

FuncA called 調用類 A 的 FuncA()

4．pa->FuncB();輸出

FuncBB called 調用類 B 的 FuncB()，原因是 C++的動態決議機制，當基類函數聲明為 virtual 時，指向派生

類對象的基類指針來調用該函數會選擇派生類的實現，除非派生類沒有才調用基類的虛函數。還有一點注

意的是：指向基類類型的指針可以指向基類對象也可以指向派生類對象，如 pa=&b;

5. pa2->FuncA();

pa2->FuncB();輸出

FuncA called

FuncB called

這也好理解，直接調用類 A 的相應成員函數

4．In the main() function, after ModifyString(text) is called, what’s the value of ‘text’?

#include <stdio.h>

#include <string.h>

int FindSubString(char* pch)

{

int count=0;

char* p1=pch;

while(*p1!='\0')

{

if(*p1==p1[1]-1)

{

p1++;

count++;

}

else

{

break;

}

}int count2=count;

while(*p1!='\0')

{

if(*p1==p1[1]+1)

{

p1++;

count2--;

}

else

{

break;

}

}

if(count2==0)

return count;

return 0;

}

void ModifyString(char* pText)

{

char* p1=pText;

char* p2=p1;

while(*p1!='\0')

{

int count=FindSubString(p1);

if(count>0){

*p2++=*p1;

sprintf(p2, "%I", count);

while(*p2!= '\0')

{

p2++;

}

p1+=count+count+1;

}

else{

*p2++=*p1++;

}}

void main(void)

{

char text[32]="XYBCDCBABABA";

ModifyString(text);

printf(text);

}

答：我不知道這個結構混亂的程序到底想考察什么，只能將最后運行結果寫出來是 XYBCDCBAIBAAP1912

給定一單鏈表的表頭指針和指向其中一個節點的指針，要求以該指針為頭將原鏈表逆序排列，例如：

N1->N2->N3->N4->N5->NULL pHEAD = N1，pSTART = N3，返回 N3->N2->N1->N5->N4->NULL

N1->N2->N3->N4->N5->NULL pHEAD = N1，pSTART = N5，返回這個 N5->N4->N3->N2->N1->NULL

N1->N2->N3->N4->N5->NULL pHEAD = N1，pSTART = N1，返回這個 N1->N5->N4->N3->N2->NULL

不允許額外分配存儲空間，不允許遞歸，可以使用臨時變量。

typedef struct node {

int value;

struct node *next;

} node;

void ReverseList(node **pHead, node *pStart){

node *t1, *t2, *it=*pHead;

t1 = it->next;

while(t1 != 0){

t2 = t1->next;

t1->next = (it == pStart?0:it);

it = t1;

t1 = t2;

}

(*pHead)->next = it;

*pHead = pStart;

}附加了測試代碼后的完整程序，抄了一部分 chaoslawful 的，呵呵

#include <stdio.h>

#include <stdarg.h>

#include <stdlib.h>

typedef struct node {

int value;struct node *next;

} node;

void ReverseList(node **pHead, node *pStart){

node *t1, *t2, *it=*pHead;

t1 = it->next;

while(t1 != 0){

t2 = t1->next;

t1->next = (it == pStart?0:it);

it = t1;

t1 = t2;

}

(*pHead)->next = it;

*pHead = pStart;

}

void PrintList(node *pHead){

node *it=pHead;

while(it){

printf("%d ",it->value);

it=it->next;

}

}

void ConstructList(node **pHead,...)

{

node *q=0;

va_list ap;

int i;

va_start(ap, pHead);

while (1){

i = va_arg(ap,int);

if(i<0)

break;

if(!q){

*pHead=q=(node *)malloc(sizeof(node));

q->value=i;

q->next=0;

} else {

q->next=(node *)malloc(sizeof(node));

q=q->next;

q->value=i;

q->next=0;

}}

}

void SetStart(node *it, node **pStart, int i)

{

while(i-- > 0 && it->next != 0){

it = it->next;

}

*pStart = it;

}

int main(){

node *pHead=(node *)malloc(sizeof(node *));

node *pStart=(node *)malloc(sizeof(node *));

ConstructList(&pHead,1,2,3,4,5,-1);

PrintList(pHead);

SetStart(pHead, &pStart, 2);

ReverseList(&pHead, pStart);

PrintList(pHead);

return 1;

}

1.寫出 a*(b-c*d)+e-f/g*(h+i*j-k)的逆波蘭表達式

2.面向對象語言中 public,proteced,private 的區別

3.SAX 和 DOM 的區別以及各自優缺點

4.進程和線程區別

5.假設現有一個功能，用戶點擊一個按鈕后就會自動發送一封郵件到用戶的郵箱。現在

用戶反映沒有受到郵件。你怎么去發現并解決問題

6.用 Java 寫一個 Singleton 類

7.2 個有序 List，請用 Java 寫一個合并函數合并他們,返回一個有序 List

public List Merge(List a,List b){

}

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

＃i nclude <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 參考：https://blog.csdn.net/wfwd/archive/2006/05/30/763551.aspx

9. 結構與聯合有和區別？

1. 結構和聯合都是由多個不同的數據類型成員組成, 但在任何同一時刻, 聯合中只存放了一個被選中的成員（所有成員共用一塊地址空間）, 而結構的所有成員都存在（不同成員的存放地址不同）。

2. 對于聯合的不同成員賦值, 將會對其它成員重寫, 原來成員的值就不存在了, 而對于結構的不同成員賦值是互不影響的。

10. 下面關于“聯合”的題目的輸出？

a)

＃i nclude <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. ＃i nclude<file.h> 與 ＃i nclude "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

＃i nclude "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"

{

＃i nclude "cExample.h"

}

而在 C 語言的頭文件中，對其外部函數只能指定為 extern 類型，C 語言中不支持 extern "C"

聲明，在.c 文件中包含了 extern "C"時會出現編譯語法錯誤。

C++引用 C 函數例子工程中包含的三個文件的源代碼如下：

/* c 語言頭文件：cExample.h */

#ifndef C_EXAMPLE_H

#define C_EXAMPLE_H

extern int add(int x,int y);

#endif

/* c 語言實現文件：cExample.c */

＃i nclude "cExample.h"

int add( int x, int y )

{

return x + y;

}// c++實現文件，調用 add：cppFile.cpp

extern "C"

{

＃i nclude "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

＃i nclude "cppExample.h"

int add( int x, int y )

{

return x + y;

}

/* C 實現文件 cFile.c

/* 這樣會編譯出錯：＃i nclude "cExample.h" */

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; ...}

參考文章：https://blog.csdn.net/wfwd/archive/2006/05/30/763753.aspx

https://blog.csdn.net/wfwd/archive/2006/05/30/763760.aspx

17.面向對象的三個基本特征，并簡單敘述之？

1. 封裝：將客觀事物抽象成類，每個類對自身的數據和方法實行 protection(private,protected,public)

2. 繼承：廣義的繼承有三種實現形式：實現繼承（指使用基類的屬性和方法而無需額外編碼的能力）、可視繼承（子窗體使用父窗體的外觀和實現代碼）、接口繼承（僅使用屬性和方法，實現滯后到子類實現）。前兩種（類繼承）和后一種（對象組合=>接口繼承以及純虛函數）構成了功能復用的兩種方式。

3. 多態：是將父對象設置成為和一個或更多的他的子對象相等的技術，賦值之后，父對象就可以根據當前賦值給它的子對象的特性以不同的方式運作。簡單的說，就是一句話：允許將子類類型的指針賦值給父類類型的指針。

18. 重載（overload)和重寫(overried，有的書也叫做“覆蓋”）的區別？

常考的題目。

從定義上來說：重載：是指允許存在多個同名函數，而這些函數的參數表不同（或許參數個數不同，或許參數類型不同，或許兩者都不同）。

重寫：是指子類重新定義復類虛函數的方法。

從實現原理上來說：

重載：編譯器根據函數不同的參數表，對同名函數的名稱做修飾，然后這些同名函數就成了不同的函數（至少對于編譯器來說是這樣的）。如，有兩個同名函數： functionfunc(p:integer):integer;和 function func(p:string):integer;。那么編譯器做過修飾后的函數名稱可能是這樣的：int_func、str_func。對于這兩個函數的調用，在編譯器間就已經確定了，是靜態的。也就是說，它們的地址在編譯期就綁定了（早綁定），因此，重載和多態無關！

重寫：和多態真正相關。當子類重新定義了父類的虛函數后，父類指針根據賦給它的不同的子類指針，動態的調用屬于子類的該函數，這樣的函數調用在編譯期間是無法確定的（調用的子類的虛函數的地址無法給出）。因此，這樣的函數地址是在運行期綁定的（晚綁定）。

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）

答案：肯定不是零。舉個反例，如果是零的話，聲明一個 classA[10]對象數組，而每一個對象占用的空間是零，這時就沒辦法區分 A[0],A[1] 了。

29. 在 8086 匯編下，邏輯地址和物理地址是怎樣轉換的？（Intel）

答案：通用寄存器給出的地址，是段內偏移地址，相應段寄存器地址*10H+通用寄存器內地址，就得到了真正要訪問的地址。

30. 比較 C++中的 4 種類型轉換方式？

請參考：https://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.文件中有一組整數，要求排序后輸出到另一個文件中

答案：

＃i nclude<iostream>

＃i nclude<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[i]<<" ";

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[i] > maxnumber )

{

sec_max = maxnumber ;

maxnumber = data[i] ;

}

else

{

if ( data[i] > sec_max )

sec_max = data[i] ;

}

}

return sec_max ;}

43. 寫一個在一個字符串(n)中尋找一個子串(m)第一個位置的函數。

KMP 算法效率最好，時間復雜度是Ｏ(n+m)。

44. 多重繼承的內存分配問題：

比如有 classA: public class B, public class C {}

那么 A 的內存結構大致是怎么樣的？

這個是 compiler-dependent 的, 不同的實現其細節可能不同。

如果不考慮有虛函數、虛繼承的話就相當簡單；否則的話，相當復雜。

可以參考《深入探索 C++對象模型》，或者：

https://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;

}