C/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

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

#ifndef C_EXAMPLE_H

#define C_EXAMPLE_H

extern int add(int x,int y);

#endif

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

}

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。對于這兩個函數的調用，在編譯器間就已經确

定了，是靜态的。也就是說，它們的位址在編譯期就綁定了（早綁定），是以，重載和多态

無關！

重寫：和多态真正相關。當子類重新定義了父類的虛函數後，父類指針根據賦給它的不同的

子類指針，動态的調用屬于子類的該函數，這樣的函數調用在編譯期間是無法确定的（調用

的子類的虛函數的位址無法給出）。是以，這樣的函數位址是在運作期綁定的（晚綁定）。

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.檔案中有一組整數，要求排序後輸出到另一個檔案中

答案：

＃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. 多重繼承的記憶體配置設定問題：

   比如有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;

}

本文來自CSDN部落格，轉載請标明出處：

http://blog.csdn.net/starysky/archive/2006/06/05/775079.aspx