C/C++ 筆試、面試題目大彙總

這些東西有點煩，有點無聊。如果要去C++面試就看看吧。幾年前網上搜尋的。剛才看到，就整理一下，裡面有些被我改了，感覺之前說的不對或不完善。

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. “引用”與多态的關系？

引用是除指針外另一個可以産生多态效果的手段。這意味着，一個基類的引用可以指向它的派生類執行個體（見：C++中類的多态與虛函數的使用）。

例4

Class A;

Class B : Class A

　　// ...

};

B b;

A& ref = b;

7. “引用”與指針的差別是什麼？

指針通過某個指針變量指向一個對象後，對它所指向的變量間接操作。程式中使用指針，程式的可讀性差；

而引用本身就是目标變量的别名，對引用的操作就是對目标變量的操作。此外，就是上面提到的對函數傳ref和pointer的差別。

8. 什麼時候需要“引用”？

流操作符<<和>>、指派操作符=的傳回值、拷貝構造函數的參數、指派操作符=的參數、其它情況都推薦使用引用。

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

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

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

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

a)

＃include <stdio.h>

union

　　int i;

　　char x[2];

}a;

　　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。

答案：

/*

編寫strcpy函數（10分）

已知strcpy函數的原型是

char *strcpy(char *strDest, const char *strSrc);

其中strDest是目的字元串，strSrc是源字元串。

（1）不調用C++/C的字元串庫函數，請編寫函數 strcpy

（2）strcpy能把strSrc的内容複制到strDest，為什麼還要char * 類型的傳回值？

答：為了 實作鍊式表達式。 // 2分

例如 int length = strlen( strcpy( strDest, “hello world”) );

*/

#include <assert.h>

#include <stdio.h>

char *strcpy(char *strDest, const char *strSrc)

assert((strDest!=NULL) && (strSrc !=NULL)); // 2分

char* address = strDest; 　　// 2分

while( (*strDest++ = *strSrc++) != '\0' )　　　　　　　// 2分

NULL;

return address ; 　　　// 2分

另外strlen函數如下：

#include<stdio.h>

#include<assert.h>

int strlen( const char *str ) // 輸入參數const

assert( str != NULL ); // 斷言字元串位址非0

int len = 0;

while( (*str++) != '\0' )

len++;

}

return len;

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);

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的頭檔案變為：

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函數例子工程中包含的三個檔案的源代碼如下：

/* c語言頭檔案：cExample.h */

#ifndef C_EXAMPLE_H

#define C_EXAMPLE_H

extern int add(int x, int y);

#endif

/* c語言實作檔案：cExample.c */

#include "cExample.h"

int add( int x, int y )

　　return x + y;

// c++實作檔案，調用add：cppFile.cpp

extern"C"

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 );

//C++實作檔案 cppExample.cpp

＃include"cppExample.h"

/* C實作檔案 cFile.c

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

extern int add( int x, int y );

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

　　add( 2, 3 );

16. 關聯、聚合(Aggregation)以及組合(Composition)的差別？

涉及到UML中的一些概念：

關聯是表示兩個類的一般性聯系，比如“學生”和“老師”就是一種關聯關系；

聚合表示has-a的關系，是一種相對松散的關系，聚合類不需要對被聚合類負責，如下圖所示，用空的菱形表示聚合關系：

從實作的角度講，聚合可以表示為:

class A {...}  class B { A* a; .....}

組合表示contains-a的關系，關聯性強于聚合：組合類與被組合類有相同的生命周期，組合類要對被組合類負責，采用實心的菱形表示組合關系：

實作的形式是:

class A{...} class B{ A a; ...}

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

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

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

3. 多态：系統能夠在運作時，能夠根據其類型确定調用哪個重載的成員函數的能力，稱為多态性。（見：C++中類的多态與虛函數的使用）

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

常考的題目。

從定義上來說：

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

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

從實作原理上來說：

重載：編譯器根據函數不同的參數表，對同名函數的名稱做修飾，然後這些同名函數就成了不同的函數（至少對于編譯器來說是這樣的）。如，有兩個同名函數：function func(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 與mallocfree 的聯系與差別?答案：都是在堆(heap)上進行動态的記憶體操作。用malloc函數需要指定記憶體配置設定的位元組數并且不能初始化對象，new 會自動調用對象的構造函數。delete 會調用對象的destructor，而free 不會調用對象的destructor.

（可以看看：顯式調用構造函數和析構函數）

22. #define DOUBLE(x) x+x ，i = 5*DOUBLE(5)； i 是多少？答案：i 為30。（注意直接展開就是了） 5 * 5 + 5 

23. 有哪幾種情況隻能用intializationlist 而不能用assignment?

答案：當類中含有const、reference 成員變量；基類的構造函數都需要初始化表。

24. C++是不是類型安全的？

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

25. main 函數執行以前，還會執行什麼代碼？答案：全局對象的構造函數會在main 函數之前執行，為malloc配置設定必要的資源，等等。

26. 描述記憶體配置設定方式以及它們的差別?

1） 從靜态存儲區域配置設定。記憶體在程式編譯的時候就已經配置設定好，這塊記憶體在程式的整個運作期間都存在。例如全局變量，static 變量。

2） 在棧上建立。在執行函數時，函數内局部變量的存儲單元都可以在棧上建立，函數執行結束時這些存儲單元自動被釋放。棧記憶體配置設定運算内置于處理器的指令集。

3） 從堆上配置設定，亦稱動态記憶體配置設定。程式在運作的時候用malloc 或new 申請任意多少的記憶體，程式員自己負責在何時用free 或delete 釋放記憶體。動态記憶體的生存期由程式員決定，使用非常靈活，但問題也最多。

4) 代碼區。

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種類型轉換方式？

重點是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）不同的範圍（分别位于派生類與基類）；

（3）參數相同；

（4）基類函數必須有virtual 關鍵字。

c.“隐藏”是指派生類的函數屏蔽了與其同名的基類函數，規則如下：

（1）如果派生類的函數與基類的函數同名，但是參數不同。此時，不論有無virtual關鍵字，基類的函數将被隐藏（注意别與重載混淆）。

（2）如果派生類的函數與基類的函數同名，并且參數也相同，但是基類函數沒有virtual 關鍵字。此時，基類的函數被隐藏（注意别與覆寫混淆）

35. There are twoint variables: a and b, don’t use “if”, “? :”, “switch”or other judgementstatements, 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" );

int fn2()

　　printf( "executed " );

int fn3()

　　printf( "is " );

int fn4()

　　printf( "This " );

The _onexit function is passed the address of a function (func) to be called whenthe program terminates normally. Successive calls to _onexit create a registerof functions that are executed in LIFO (last-in-first-out) order. The functionspassed to _onexit cannot take parameters.

38. 如何判斷一段程式是由C 編譯程式還是由C++編譯程式編譯的？

#ifdef __cplusplus

　　cout<<"c++";

#else

　　cout<<"c";

注意，後面很多代碼啊。代碼不看也罷。

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 ;

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)

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 ;

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 ;

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 ;

pcurrent->next = p2 ;

pcurrent = p2 ;

p2 = p2->next ;

if ( p1 != NULL )

if ( p2 != NULL )

(3)已知兩個連結清單head1 和head2 各自有序，請把它們合并成一個連結清單依然有序，這次要求用遞歸方法進行。(Autodesk)答案：

Node * MergeRecursive(Node *head1 , Node *head2)

if ( head1 == NULL )

head->next = MergeRecursive(head1->next,head2);

head->next = MergeRecursive(head1,head2->next);

41. 分析一下這段程式的輸出(Autodesk)

class B

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;

int data;

B Play( B b)

return b ;

(1) results:

int main(int argc, char* argv[]) constructedby parameter 5

{ destructed B(5)形參析構

B t1 = Play(5); B t2 = Play(t1); 　 destructed t1形參析構

return 0;　　　　　　　　　　　　　　 destructed t2　注意順序！

} destructed t1

(2) results:

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] ;

if ( data[i] > sec_max )

sec_max = data[i] ;

return sec_max ;

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

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

44. 多重繼承的記憶體配置設定問題：   比如有class A : public class B, public classC {}   那麼A的記憶體結構大緻是怎麼樣的？

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

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

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

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;

完