【轉】c++筆試題

原文：http://blog.csdn.net/dongfengsun/article/details/1541926node

①鏈表反轉

單向鏈表的反轉是一個常常被問到的一個面試題，也是一個很是基礎的問題。好比一個鏈表是這樣的： 1->2->3->4->5 經過反轉後成爲5->4->3->2->1。ios

最容易想到的方法遍歷一遍鏈表，利用一個輔助指針，存儲遍歷過程當中當前指針指向的下一個元素，而後將當前節點元素的指針反轉後，利用已經存儲的指針日後面繼續遍歷。源代碼以下：c++

struct linka {
int data;
linka* next;
};
void reverse(linka*& head) {
if(head ==NULL)
return;
linka *pre, *cur, *ne;
pre=head;
cur=head->next;
while(cur)
{
ne = cur->next;
cur->next = pre;
pre = cur;
cur = ne;
}
head->next = NULL;
head = pre;
}

還有一種利用遞歸的方法。這種方法的基本思想是在反轉當前節點以前先調用遞歸函數反轉後續節點。源代碼以下。不過這個方法有一個缺點，就是在反轉後的最後一個結點會造成一個環，因此必須將函數的返回的節點的next域置爲NULL。由於要改變head指針，因此我用了引用。算法的源代碼以下：程序員

linka* reverse(linka* p,linka*& head)
{
if(p == NULL || p->next == NULL)
{
head=p;
return p;
}
else
{
linka* tmp = reverse(p->next,head);
tmp->next = p;
return p;
}
}

②已知String類定義以下：web

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 ;
}面試

③網上流傳的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分配的對象的引用、返回一個靜態對象引用。根據前面提到的引用做爲返回值的三個規則，第二、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函數例子工程中包含的三個文件的源代碼以下：

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

參考文章：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;}