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分配的對象的引用、返回一個靜態對象引用。根據前面提到的引用做爲返回值的三個規則，第二、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;
}

1.是否是一個父類寫了一個virtual 函數，若是子類覆蓋它的函數不加virtual ,也能實現多態?
virtual修飾符會被隱形繼承的。
private 也被集成，只事派生類沒有訪問權限而已
virtual可加可不加
子類的空間裏有父類的全部變量(static除外)
同一個函數只存在一個實體(inline除外)
子類覆蓋它的函數不加virtual ,也能實現多態。
在子類的空間裏，有父類的私有變量。私有變量不能直接訪問。

--------------------------------------------------------------------------
2.輸入一個字符串，將其逆序後輸出。（使用C++，不建議用僞碼）
#include <iostream>
using namespace std;

void main()
{
  char a[50];memset(a,0,sizeof(a));
  int i=0,j;
  char t;
  cin.getline(a,50,'"n');
  for(i=0,j=strlen(a)-1;i<strlen(a)/2;i++,j--)
  {
   t=a[i];
      a[i]=a[j];
   a[j]=t;
  }
  cout<<a<<endl;  
}
//第二種
string str;
cin>>str;
str.replace;
cout<<str;

--------------------------------------------------------------------------
3.請簡單描述Windows內存管理的方法。
內存管理是操做系統中的重要部分，兩三句話恐怕誰也說不清楚吧～～
我先說個大概，但願可以拋磚引玉吧
當程序運行時須要從內存中讀出這段程序的代碼。代碼的位置必須在物理內存中才能被運行，因爲如今的操做系統中有很是多的程序運行着，內存中不可以徹底放下，因此引出了虛擬內存的概念。把哪些不經常使用的程序片段就放入虛擬內存，當須要用到它的時候在load入主存（物理內存）中。這個就是內存管理所要作的事。內存管理還有另一件事須要作：計算程序片斷在主存中的物理位置，以便CPU調度。
內存管理有塊式管理，頁式管理，段式和段頁式管理。如今經常使用段頁式管理
塊式管理：把主存分爲一大塊、一大塊的，當所需的程序片段不在主存時就分配一塊主存空間，把程 序片段load入主存，就算所需的程序片度只有幾個字節也只能把這一塊分配給它。這樣會形成很大的浪費，平均浪費了50％的內存空間，但時易於管理。
頁式管理：把主存分爲一頁一頁的，每一頁的空間要比一塊一塊的空間小不少，顯然這種方法的空間利用率要比塊式管理高不少。
段式管理：把主存分爲一段一段的，每一段的空間又要比一頁一頁的空間小不少，這種方法在空間利用率上又比頁式管理高不少，可是也有另一個缺點。一個程序片段可能會被分爲幾十段，這樣不少時間就會被浪費在計算每一段的物理地址上（計算機最耗時間的你們都知道是I/O吧）。
段頁式管理：結合了段式管理和頁式管理的優勢。把主存分爲若干頁，每一頁又分爲若干段。好處就很明顯，不用我多說了吧。
各類內存管理都有它本身的方法來計算出程序片段在主存中的物理地址，其實都很類似。
這只是一個大概而已，不足以說明內存管理的皮毛。不管哪一本操做系統書上都有詳細的講解

--------------------------------------------------------------------------
4.
#include "stdafx.h"
#define SQR(X) X*X
int main(int argc, char* argv[])
{
 int a = 10;
 int k = 2;
 int m = 1;
 a /= SQR(k+m)/SQR(k+m); 
 printf("%d"n",a); 
 return 0;
}
這道題目的結果是什麼啊?
define 只是定義而已，在編擇時只是簡單代換X*X而已，並不通過算術法則的
a /= (k+m)*(k+m)/(k+m)*(k+m);
=>a /= (k+m)*1*(k+m);
=>a = a/9;
=>a = 1;
--------------------------------------------------------------------------
5.
const 符號常量；
(1)const char *p
(2)char const *p
(3)char * const p
說明上面三種描述的區別；

若是const位於星號的左側，則const就是用來修飾指針所指向的變量，即指針指向爲常量；
若是const位於星號的右側，const就是修飾指針自己，即指針自己是常量。
(1)const char *p
一個指向char類型的const對象指針，p不是常量,咱們能夠修改p的值，使其指向不一樣的char，可是不能改變它指向非char對象，如：
const char *p;
char c1='a';
char c2='b';
p=&c1;//ok
p=&c2;//ok
*p=c1;//error
(2)char const *p
(3)char * const p
這兩個好象是同樣的，此時*p能夠修改，而p不能修改。
(4)const char * const p
這種是地址及指向對象都不能修改。
--------------------------------------------------------------------------
6.下面是C語言中兩種if語句判斷方式。請問哪一種寫法更好？爲何？
 int n;
 if (n == 10) // 第一種判斷方式
 if (10 == n) // 第二種判斷方式
若是少了個=號,編譯時就會報錯,減小了出錯的可能行,能夠檢測出是否少了=
--------------------------------------------------------------------------
7.下面的代碼有什麼問題？
void DoSomeThing(...)
{
 char* p;
 ...
 p = malloc(1024);  // 分配1K的空間
 if (NULL == p)
  return;
 ...
 p = realloc(p, 2048); // 空間不夠，從新分配到2K
 if (NULL == p)
  return;
 ...
}
A:
p = malloc(1024);     應該寫成： p = (char *) malloc(1024); 
        沒有釋放p的空間，形成內存泄漏。

--------------------------------------------------------------------------
8.下面的代碼有什麼問題？並請給出正確的寫法。
void DoSomeThing(char* p)
{
 char str[16];
 int n;
 assert(NULL != p);
 sscanf(p, "%s%d", str, n);
 if (0 == strcmp(str, "something"))
 {
  ...
 }
}
A:
sscanf(p, "%s%d", str, n);   這句該寫成： sscanf(p, "%s%d", str, &n);
--------------------------------------------------------------------------
9.下面代碼有什麼錯誤?
Void test1() 
{ 
 char string[10]; 
 char *str1="0123456789";
 strcpy(string, str1); 
} 
數組越界
--------------------------------------------------------------------------
10.下面代碼有什麼問題?
Void test2() 
{ 
  char string[10], str1[10]; 
  for(i=0; i<10;i++) 
  { 
     str1[i] ='a'; 
  } 
  strcpy(string, str1); 
} 
數組越界
--------------------------------------------------------------------------
11.下面代碼有什麼問題?
Void test3(char* str1) 
{ 
  char string[10]; 
  if(strlen(str1)<=10) 
  { 
    strcpy(string, str1); 
  } 
} 
==數組越界
==strcpy拷貝的結束標誌是查找字符串中的"0 所以若是字符串中沒有遇到"0的話 會一直複製，直到遇到"0,上面的123都所以產生越界的狀況
 
建議使用 strncpy 和 memcpy
--------------------------------------------------------------------------
12.下面代碼有什麼問題?
#define MAX_SRM 256 
DSN get_SRM_no() 
{ 
  static int SRM_no; //是否是這裏沒賦初值？
  int I; 
  for(I=0;I<MAX_SRM;I++,SRM_no++) 
  { 
    SRM_no %= MAX_SRM; 
    if(MY_SRM.state==IDLE) 
    { 
      break; 
    } 
  } 
  if(I>=MAX_SRM) 
    return (NULL_SRM); 
  else 
    return SRM_no; 
} 
系統會初始化static int變量爲0,但該值會一直保存,所謂的不可重入...
--------------------------------------------------------------------------
13.寫出運行結果:
{// test1
    char str[] = "world"; cout << sizeof(str) << ": ";
    char *p    = str;     cout << sizeof(p) << ": ";
    char i     = 10;      cout << sizeof(i) << ": ";
    void *pp   = malloc(10);  cout << sizeof(p) << endl;
}
6：4：1：4
--------------------------------------------------------------------------
14.寫出運行結果:
{// test2
    union V {
 struct X {
  unsigned char s1:2;
  unsigned char s2:3;
  unsigned char s3:3;
 } x;
 unsigned char c;
    } v;
    v.c = 100;
    printf("%d", v.x.s3); 
}
3
--------------------------------------------------------------------------
15.用C++寫個程序，如何判斷一個操做系統是16位仍是32位的？不能用sizeof()函數
A1:
16位的系統下，
int i = 65536;
cout << i; // 輸出0；
int i = 65535;
cout << i; // 輸出-1；
32位的系統下，
int i = 65536;
cout << i; // 輸出65536；
int i = 65535;
cout << i; // 輸出65535；
A2:
int a = ~0;
if( a>65536 ) 
{
    cout<<"32 bit"<<endl;
}
else
{
    cout<<"16 bit"<<endl;
}

--------------------------------------------------------------------------
16.C和C++有什麼不一樣?
從機制上：c是面向過程的（但c也能夠編寫面向對象的程序）；c++是面向對象的，提供了類。可是，
c++編寫面向對象的程序比c容易
從適用的方向：c適合要求代碼體積小的，效率高的場合，如嵌入式；c++適合更上層的，複雜的；  llinux核心大部分是c寫的，由於它是系統軟件，效率要求極高。
從名稱上也能夠看出，c++比c多了+，說明c++是c的超集；那爲何不叫c+而叫c++呢，是由於c++比
c來講擴充的東西太多了，因此就在c後面放上兩個+；因而就成了c++
C語言是結構化編程語言，C++是面向對象編程語言。
C++側重於對象而不是過程，側重於類的設計而不是邏輯的設計。
--------------------------------------------------------------------------
17.在不用第三方參數的狀況下，交換兩個參數的值
#include <stdio.h>
void main()
{
        int i=60;
        int j=50;
        i=i+j;
        j=i-j;
        i=i-j;
        printf("i=%d"n",i);
        printf("j=%d"n",j);
}
方法二：
i^=j;
j^=i;
i^=j;
方法三：
// 用加減實現，並且不會溢出
a = a+b-(b=a)
--------------------------------------------------------------------------
18.有關位域的面試題（爲何輸出的是一個奇怪的字符）
a.t = 'b';效果至關於 a.t= 'b' & 0xf;
'b' --> 01100010
'b' & 0xf -->>00000010
因此輸出Ascii碼爲2的特殊字符

char t:4;就是4bit的字符變量，一樣
unsigned short i:8;就是8bit的無符號短整形變量
--------------------------------------------------------------------------
19.int i=10, j=10, k=3; k*=i+j; k最後的值是?
60
--------------------------------------------------------------------------
20.進程間通訊的方式有?
進程間通訊的方式有 共享內存， 管道 ，Socket ，消息隊列 , DDE等
--------------------------------------------------------------------------
21.
struct A 
{ 
char t:4; 
char k:4; 
unsigned short i:8; 
unsigned long m; 
} 
sizeof(A)=?（不考慮邊界對齊）
7
struct CELL             // Declare CELL bit field
{
   unsigned character  : 8;  // 00000000 ????????
   unsigned foreground : 3;  // 00000??? 00000000
   unsigned intensity  : 1;  // 0000?000 00000000
   unsigned background : 3;  // 0???0000 00000000
   unsigned blink      : 1;  // ?0000000 00000000
} screen[25][80];       // Array of bit fields
2、位結構 
    位結構是一種特殊的結構, 在需按位訪問一個字節或字的多個位時, 位結構 
比按位運算符更加方便。 
    位結構定義的通常形式爲: 
     struct位結構名{ 
          數據類型 變量名: 整型常數; 
          數據類型 變量名: 整型常數; 
     } 位結構變量; 
    其中: 數據類型必須是int(unsigned或signed)。 整型常數必須是非負的整 
數, 範圍是0~15, 表示二進制位的個數, 即表示有多少位。 
    變量名是選擇項, 能夠不命名, 這樣規定是爲了排列須要。 
    例如: 下面定義了一個位結構。 
     struct{ 
          unsigned incon: 8;  /*incon佔用低字節的0~7共8位*/ 
          unsigned txcolor: 4;/*txcolor佔用高字節的0~3位共4位*/ 
          unsigned bgcolor: 3;/*bgcolor佔用高字節的4~6位共3位*/ 
          unsigned blink: 1;  /*blink佔用高字節的第7位*/ 
     }ch; 
    位結構成員的訪問與結構成員的訪問相同。 
    例如: 訪問上例位結構中的bgcolor成員可寫成: 
      ch.bgcolor 
  
    注意: 
    1. 位結構中的成員能夠定義爲unsigned, 也可定義爲signed,  但當成員長 
度爲1時, 會被認爲是unsigned類型。由於單個位不可能具備符號。 
    2. 位結構中的成員不能使用數組和指針, 但位結構變量能夠是數組和指針, 
若是是指針, 其成員訪問方式同結構指針。 
    3. 位結構總長度(位數), 是各個位成員定義的位數之和,  能夠超過兩個字 
節。 
    4. 位結構成員能夠與其它結構成員一塊兒使用。 
    例如: 
     struct info{ 
          char name[8]; 
          int age; 
          struct addr address; 
          float pay; 
          unsigned state: 1; 
          unsigned pay: 1; 
          }workers;
    上例的結構定義了關於一個工人的信息。其中有兩個位結構成員, 每一個位結 
構成員只有一位, 所以只佔一個字節但保存了兩個信息, 該字節中第一位表示工 
人的狀態, 第二位表示工資是否已發放。因而可知使用位結構能夠節省存貯空間。

--------------------------------------------------------------------------
22.下面的函數實如今一個固定的數上加上一個數，有什麼錯誤，改正 
int add_n(int n) 
{ 
  static int i=100; 
  i+=n; 
  return i; 
} 
答:
由於static使得i的值會保留上次的值。
去掉static就可了
--------------------------------------------------------------------------
23.下面的代碼有什麼問題?
class A 
{ 
public: 
  A() { p=this; } 
  ~A() { if(p!=NULL) { delete p; p=NULL; } } 
  A* p; 
};
答:
會引發無限遞歸
--------------------------------------------------------------------------
24.
union a {
 int a_int1;
 double a_double;
 int a_int2;
};
typedef struct
{
 a a1;
 char y;
} b;
class c
{
 double c_double;
 b b1;
 a a2;
};
輸出cout<<sizeof(c)<<endl;的結果?
答:
VC6環境下得出的結果是32
另:
我(sun)在VC6.0+win2k下作過試驗:
short - 2
int-4
float-4
double-8
指針-4
sizeof(union)，以結構裏面size最大的爲union的size

解析C語言中的sizeof
1、sizeof的概念　 
　　sizeof是C語言的一種單目操做符，如C語言的其餘操做符++、--等。它並非函數。sizeof操做符以字節形式給出了其操做數的存儲大小。操做數能夠是一個表達式或括在括號內的類型名。操做數的存儲大小由操做數的類型決定。　

2、sizeof的使用方法　 
　　一、用於數據類型　 
　　sizeof使用形式：sizeof（type）　 
　　數據類型必須用括號括住。如sizeof（int）。　 
　　二、用於變量　 
　　sizeof使用形式：sizeof（var_name）或sizeof　var_name　 
　　變量名能夠不用括號括住。如sizeof　(var_name)，sizeof　var_name等都是正確形式。帶括號的用法更廣泛，大多數程序員採用這種形式。　 
　　注意：sizeof操做符不能用於函數類型，不徹底類型或位字段。不徹底類型指具備未知存儲大小的數據類型，如未知存儲大小的數組類型、未知內容的結構或聯合類型、void類型等。　 
　　如sizeof(max)若此時變量max定義爲int　max(),sizeof(char_v)　若此時char_v定義爲char　char_v　[MAX]且MAX未知，sizeof(void)都不是正確形式。　

3、sizeof的結果　 
　　sizeof操做符的結果類型是size_t，它在頭文件
中typedef爲unsigned　int類型。該類型保證能容納實現所創建的最大對象的字節大小。　 
　　一、若操做數具備類型char、unsigned　char或signed　char，其結果等於1。　 
　　ANSI　C正式規定字符類型爲1字節。　 
　　二、int、unsigned　int　、short　int、unsigned　short　、long　int　、unsigned　long　、float、double、long　double類型的sizeof　在ANSI　C中沒有具體規定，大小依賴於實現，通常可能分別爲二、二、二、二、四、四、四、八、10。　 
　　三、當操做數是指針時，sizeof依賴於編譯器。例如Microsoft　C/C++7.0中，near類指針字節數爲2，far、huge類指針字節數爲4。通常Unix的指針字節數爲4。　 
　　四、當操做數具備數組類型時，其結果是數組的總字節數。　 
　　五、聯合類型操做數的sizeof是其最大字節成員的字節數。結構類型操做數的sizeof是這種類型對象的總字節數，包括任何墊補在內。　 
　　讓咱們看以下結構：　 
　　struct　{char　b;　double　x;}　a;　 
　　在某些機器上sizeof（a）=12，而通常sizeof（char）+　sizeof（double）=9。　 
　　這是由於編譯器在考慮對齊問題時，在結構中插入空位以控制各成員對象的地址對齊。如double類型的結構成員x要放在被4整除的地址。　 
　　六、若是操做數是函數中的數組形參或函數類型的形參，sizeof給出其指針的大小。　

4、sizeof與其餘操做符的關係　 
　　sizeof的優先級爲2級，比/、%等3級運算符優先級高。它能夠與其餘操做符一塊兒組成表達式。如i*sizeof（int）；其中i爲int類型變量。　

5、sizeof的主要用途　 
　　一、sizeof操做符的一個主要用途是與存儲分配和I/O系統那樣的例程進行通訊。例如：　 
　　void　*malloc（size_t　size）,　 
　　size_t　fread(void　*　ptr,size_t　size,size_t　nmemb,FILE　*　stream)。　 
　　二、sizeof的另外一個的主要用途是計算數組中元素的個數。例如：　 
　　void　*　memset（void　*　s,int　c,sizeof(s)）。　

6、建議　 
　　因爲操做數的字節數在實現時可能出現變化，建議在涉及到操做數字節大小時用sizeof來代替常量計算。

=============================================================
本文主要包括二個部分，第一部分重點介紹在VC中，怎麼樣採用sizeof來求結構的大小，以及容易出現的問題，並給出解決問題的方法，第二部分總結出VC中sizeof的主要用法。 
一、 sizeof應用在結構上的狀況 
請看下面的結構： 
struct MyStruct 
{ 
double dda1; 
char dda; 
int type 
}; 
對結構MyStruct採用sizeof會出現什麼結果呢？sizeof(MyStruct)爲多少呢？也許你會這樣求： 
sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13 
可是當在VC中測試上面結構的大小時，你會發現sizeof(MyStruct)爲16。你知道爲何在VC中會得出這樣一個結果嗎？ 
其實，這是VC對變量存儲的一個特殊處理。爲了提升CPU的存儲速度，VC對一些變量的起始地址作了"對齊"處理。在默認狀況下，VC規定各成員變量存放的起始地址相對於結構的起始地址的偏移量必須爲該變量的類型所佔用的字節數的倍數。下面列出經常使用類型的對齊方式(vc6.0,32位系統)。 
類型 
對齊方式（變量存放的起始地址相對於結構的起始地址的偏移量） 
Char 
偏移量必須爲sizeof(char)即1的倍數 
int 
偏移量必須爲sizeof(int)即4的倍數 
float 
偏移量必須爲sizeof(float)即4的倍數 
double 
偏移量必須爲sizeof(double)即8的倍數 
Short 
偏移量必須爲sizeof(short)即2的倍數 
各成員變量在存放的時候根據在結構中出現的順序依次申請空間，同時按照上面的對齊方式調整位置，空缺的字節VC會自動填充。同時VC爲了確保結構的大小爲結構的字節邊界數（即該結構中佔用最大空間的類型所佔用的字節數）的倍數，因此在爲最後一個成員變量申請空間後，還會根據須要自動填充空缺的字節。 
下面用前面的例子來講明VC到底怎麼樣來存放結構的。 
struct MyStruct 
{ 
double dda1; 
char dda; 
int type 
}； 
爲上面的結構分配空間的時候，VC根據成員變量出現的順序和對齊方式，先爲第一個成員dda1分配空間，其起始地址跟結構的起始地址相同（恰好偏移量0恰好爲sizeof(double)的倍數），該成員變量佔用sizeof(double)=8個字節；接下來爲第二個成員dda分配空間，這時下一個能夠分配的地址對於結構的起始地址的偏移量爲8，是sizeof(char)的倍數，因此把dda存放在偏移量爲8的地方知足對齊方式，該成員變量佔用sizeof(char)=1個字節；接下來爲第三個成員type分配空間，這時下一個能夠分配的地址對於結構的起始地址的偏移量爲9，不是sizeof(int)=4的倍數，爲了知足對齊方式對偏移量的約束問題，VC自動填充3個字節（這三個字節沒有放什麼東西），這時下一個能夠分配的地址對於結構的起始地址的偏移量爲12，恰好是sizeof(int)=4的倍數，因此把type存放在偏移量爲12的地方，該成員變量佔用sizeof(int)=4個字節；這時整個結構的成員變量已經都分配了空間，總的佔用的空間大小爲：8+1+3+4=16，恰好爲結構的字節邊界數（即結構中佔用最大空間的類型所佔用的字節數sizeof(double)=8）的倍數，因此沒有空缺的字節須要填充。因此整個結構的大小爲：sizeof(MyStruct)=8+1+3+4=16，其中有3個字節是VC自動填充的，沒有聽任何有意義的東西。 
下面再舉個例子，交換一下上面的MyStruct的成員變量的位置，使它變成下面的狀況： 
struct MyStruct 
{ 
char dda; 
double dda1;   
int type 
}； 
這個結構佔用的空間爲多大呢？在VC6.0環境下，能夠獲得sizeof(MyStruc)爲24。結合上面提到的分配空間的一些原則，分析下VC怎麼樣爲上面的結構分配空間的。（簡單說明） 
struct MyStruct 
{ 
  char dda;//偏移量爲0，知足對齊方式，dda佔用1個字節； 
double dda1;//下一個可用的地址的偏移量爲1，不是sizeof(double)=8 
             //的倍數，須要補足7個字節才能使偏移量變爲8（知足對齊 
             //方式），所以VC自動填充7個字節，dda1存放在偏移量爲8 
             //的地址上，它佔用8個字節。 
int type；//下一個可用的地址的偏移量爲16，是sizeof(int)=4的倍 
           //數，知足int的對齊方式，因此不須要VC自動填充，type存 
           //放在偏移量爲16的地址上，它佔用4個字節。 
}；//全部成員變量都分配了空間，空間總的大小爲1+7+8+4=20，不是結構 
   //的節邊界數（即結構中佔用最大空間的類型所佔用的字節數sizeof 
   //(double)=8）的倍數，因此須要填充4個字節，以知足結構的大小爲 
   //sizeof(double)=8的倍數。 
因此該結構總的大小爲：sizeof(MyStruc)爲1+7+8+4+4=24。其中總的有7+4=11個字節是VC自動填充的，沒有聽任何有意義的東西。 
VC對結構的存儲的特殊處理確實提升CPU存儲變量的速度，可是有時候也帶來了一些麻煩，咱們也屏蔽掉變量默認的對齊方式，本身能夠設定變量的對齊方式。 
VC中提供了#pragma pack(n)來設定變量以n字節對齊方式。n字節對齊就是說變量存放的起始地址的偏移量有兩種狀況：第1、若是n大於等於該變量所佔用的字節數，那麼偏移量必須知足默認的對齊方式，第2、若是n小於該變量的類型所佔用的字節數，那麼偏移量爲n的倍數，不用知足默認的對齊方式。結構的總大小也有個約束條件，分下面兩種狀況：若是n大於全部成員變量類型所佔用的字節數，那麼結構的總大小必須爲佔用空間最大的變量佔用的空間數的倍數； 
不然必須爲n的倍數。下面舉例說明其用法。 
#pragma pack(push) //保存對齊狀態 
#pragma pack(4)//設定爲4字節對齊 
struct test 
{ 
  char m1; 
  double m4; 
  int  m3; 
}; 
#pragma pack(pop)//恢復對齊狀態 
以上結構的大小爲16，下面分析其存儲狀況，首先爲m1分配空間，其偏移量爲0，知足咱們本身設定的對齊方式（4字節對齊），m1佔用1個字節。接着開始爲m4分配空間，這時其偏移量爲1，須要補足3個字節，這樣使偏移量知足爲n=4的倍數（由於sizeof(double)大於n）,m4佔用8個字節。接着爲m3分配空間，這時其偏移量爲12，知足爲4的倍數，m3佔用4個字節。這時已經爲全部成員變量分配了空間，共分配了16個字節，知足爲n的倍數。若是把上面的#pragma pack(4)改成#pragma pack(16)，那麼咱們能夠獲得結構的大小爲24。（請讀者本身分析）

二、 sizeof用法總結 
在VC中，sizeof有着許多的用法，並且很容易引發一些錯誤。下面根據sizeof後面的參數對sizeof的用法作個總結。 
A． 參數爲數據類型或者爲通常變量。例如sizeof(int),sizeof(long)等等。這種狀況要注意的是不一樣系統系統或者不一樣編譯器獲得的結果多是不一樣的。例如int類型在16位系統中佔2個字節，在32位系統中佔4個字節。 
B． 參數爲數組或指針。下面舉例說明. 
int a[50];  //sizeof(a)=4*50=200; 求數組所佔的空間大小 
int *a=new int[50];// sizeof(a)=4; a爲一個指針，sizeof(a)是求指針 
                   //的大小,在32位系統中，固然是佔4個字節。 
C． 參數爲結構或類。Sizeof應用在類和結構的處理狀況是相同的。但有兩點須要注意，第1、結構或者類中的靜態成員不對結構或者類的大小產生影響，由於靜態變量的存儲位置與結構或者類的實例地址無關。 
第2、沒有成員變量的結構或類的大小爲1，由於必須保證結構或類的每一 
個實例在內存中都有惟一的地址。 
下面舉例說明， 
Class Test{int a;static double c};//sizeof(Test)=4. 
Test *s;//sizeof(s)=4,s爲一個指針。 
Class test1{ };//sizeof(test1)=1; 
D． 參數爲其餘。下面舉例說明。 
   int func(char s[5]); 
   { 
     cout<<sizeof(s);//這裏將輸出4，原本s爲一個數組，但因爲作爲函 
                     //數的參數在傳遞的時候系統處理爲一個指針，所 
                     //以sizeof(s)實際上爲求指針的大小。 
     return 1; 
} 
sizeof(func("1234"))=4//由於func的返回類型爲int，因此至關於 
                     //求sizeof(int). 
以上爲sizeof的基本用法，在實際的使用中要注意分析VC的分配變量的分配策略，這樣的話能夠避免一些錯誤。

--------------------------------------------------------------------------
25.i最後等於多少?
int i = 1;
int j = i++;
if((i>j++) && (i++ == j)) i+=j;
答:
i = 5
--------------------------------------------------------------------------
26.
unsigned short array[]={1,2,3,4,5,6,7};
int i = 3;
*(array + i) = ?
答:
4
--------------------------------------------------------------------------
27.
class A
{
  virtual void func1()；
  void func2();
}
Class B: class A
{
  void func1(){cout << "fun1 in class B" << endl;}
  virtual void func2(){cout << "fun2 in class B" << endl;}
} 
A, A中的func1和B中的func2都是虛函數.
B, A中的func1和B中的func2都不是虛函數.
C, A中的func2是虛函數.，B中的func1不是虛函數.
D, A中的func2不是虛函數，B中的func1是虛函數.
答:
A
--------------------------------------------------------------------------
28.
數據庫：抽出部門，平均工資，要求按部門的字符串順序排序，不能含有"human resource"部門，
employee結構以下：employee_id, employee_name, depart_id,depart_name,wage
答:
select depart_name, avg(wage)
from employee
where depart_name <> 'human resource'
group by depart_name
order by depart_name
--------------------------------------------------------------------------
29.
給定以下SQL數據庫：Test(num INT(4)) 請用一條SQL語句返回num的最小值，但不準使用統計功能，如MIN，MAX等
答:
select top 1 num
from Test
order by num desc
--------------------------------------------------------------------------
30.
輸出下面程序結果。 
#include <iostream.h> 
class A 
{ 
public:
 virtual void print(void) 
 { 
    cout<<"A::print()"<<endl; 
 } 
};
class B:public A 
{ 
public:
 virtual void print(void) 
 { 
   cout<<"B::print()"<<endl;
 }; 
}; 
class C:public B
{
public:
 virtual void print(void)
 {
  cout<<"C::print()"<<endl;
 }
};
void print(A a) 
{ 
   a.print(); 
} 
void main(void) 
{ 
   A a, *pa,*pb,*pc; 
   B b; 
   C c; 
   
   pa=&a; 
   pb=&b; 
   pc=&c; 
   
   a.print(); 
   b.print(); 
   c.print(); 
   
   pa->print(); 
   pb->print(); 
   pc->print(); 
   
   print(a); 
   print(b); 
   print(c); 
}
A:
A::print()
B::print()
C::print()
A::print()
B::print()
C::print()
A::print()
A::print()
A::print()
--------------------------------------------------------------------------
31.
試編寫函數判斷計算機的字節存儲順序是開序(little endian)仍是降序(bigendian)
答:
bool IsBigendian()
{
 unsigned short usData = 0x1122;
 unsigned char  *pucData = (unsigned char*)&usData;
 return (*pucData == 0x22);
}
--------------------------------------------------------------------------
32.簡述Critical Section和Mutex的不一樣點
答:
對幾種同步對象的總結
1.Critical Section
A.速度快
B.不能用於不一樣進程
C.不能進行資源統計(每次只能夠有一個線程對共享資源進行存取)
2.Mutex
A.速度慢
B.可用於不一樣進程
C.不能進行資源統計
3.Semaphore
A.速度慢
B.可用於不一樣進程
C.可進行資源統計(可讓一個或超過一個線程對共享資源進行存取)
4.Event
A.速度慢
B.可用於不一樣進程
C.可進行資源統計
--------------------------------------------------------------------------
33.一個數據庫中有兩個表:
一張表爲Customer，含字段ID,Name;
一張表爲Order，含字段ID,CustomerID（連向Customer中ID的外鍵）,Revenue；
寫出求每一個Customer的Revenue總和的SQL語句。
建表
create table customer
(
ID int primary key,Name char(10)
)
go
create table [order]
(
ID int primary key,CustomerID  int foreign key references customer(id) , Revenue float
)
go
--查詢
select Customer.ID, sum( isnull([Order].Revenue,0) )
from customer full join [order] 
on( [order].customerid=customer.id )
group by customer.id
--------------------------------------------------------------------------
34.請指出下列程序中的錯誤而且修改
void GetMemory(char *p){
  p=(char *)malloc(100);
}
void Test(void){
  char *str=NULL;
  GetMemory=(str);
  strcpy(str,"hello world");
  printf(str);
}
A:錯誤--參數的值改變後，不會傳回
GetMemory並不能傳遞動態內存，Test函數中的 str一直都是 NULL。
strcpy(str, "hello world");將使程序崩潰。
修改以下:
char *GetMemory(){
  char *p=(char *)malloc(100);
  return p;
}
void Test(void){
  char *str=NULL;
  str=GetMemory(){
  strcpy(str,"hello world");
  printf(str);
}
方法二:void GetMemory2(char **p)變爲二級指針.
void GetMemory2(char **p, int num)
{
 *p = (char *)malloc(sizeof(char) * num);
}
--------------------------------------------------------------------------
35.程序改錯
class mml
{
  private:
    static unsigned int x;
  public:
    mml(){ x++; }
    mml(static unsigned int &) {x++;}
    ~mml{x--;}
  pulic:
    virtual mon() {} = 0;
    static unsigned int mmc(){return x;}
    ......                      
 
};
class nnl:public mml
{
  private:
    static unsigned int y;
  public:
    nnl(){ x++; }
    nnl(static unsigned int &) {x++;}
    ~nnl{x--;}
  public:
    virtual mon() {};
     static unsigned int nnc(){return y;}
    ......                   
};
代碼片段:
mml* pp = new nnl;
..........
delete pp;

A:
基類的析構函數應該爲虛函數
virtual ~mml{x--;}
--------------------------------------------------------------------------
36.101個硬幣100真、1假，真假區別在於重量。請用無砝碼天平稱兩次給出真幣重仍是假幣重的結論。
答:
101個先取出2堆,
33,33
第一次稱,若是不相等,說明有一堆重或輕
那麼把重的那堆拿下來,再放另外35箇中的33
若是相等,說明假的重,若是不相等,新放上去的仍是重的話,說明假的輕(不可能新放上去的輕)
第一次稱,若是相等的話，這66個確定都是真的,從這66箇中取出35個來,與剩下的沒稱過的35個比
下面就不用說了
方法二:
第3題也能夠拿A(50),B(50)比一下，同樣的話拿剩下的一個和真的比一下。
若是不同，就拿其中的一堆。好比A(50)再分紅兩堆25比一下，同樣的話就在
B(50)中，不同就在A(50)中，結合第一次的結果就知道了。
--------------------------------------------------------------------------
37.static變量和static 函數各有什麼特色？
答:
static變量：在程序運行期內一直有效，若是定義在函數外，則在編譯單元內可見，若是在函數內，在在定義的block內可見；
static函數：在編譯單元內可見；
--------------------------------------------------------------------------
38.用C 寫一個輸入的整數,倒着輸出整數的函數,要求用遞歸方法 ;
答:
void fun( int a )
{
 printf( "%d", a%10 );
 a /= 10;
 if( a <=0 )return;
 fun( a );
}
--------------------------------------------------------------------------
39.寫出程序結果:
void Func(char str[100])
{
  printf("%d"n", sizeof(str));
}
答:
4
分析:
指針長度
--------------------------------------------------------------------------
40.int id[sizeof(unsigned long)];
    這個對嗎？爲何??
答:
對
這個 sizeof是編譯時運算符，編譯時就肯定了
能夠當作和機器有關的常量。

本文主要包括二個部分，第一部分重點介紹在VC中，怎麼樣採用sizeof來求結構的大小，以及容易出現的問題，並給出解決問題的方法，第二部分總結出VC中sizeof的主要用法。 
一、 sizeof應用在結構上的狀況 
請看下面的結構： 
struct MyStruct 
{ 
double dda1; 
char dda; 
int type 
}; 
對結構MyStruct採用sizeof會出現什麼結果呢？sizeof(MyStruct)爲多少呢？也許你會這樣求： 
sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13 
可是當在VC中測試上面結構的大小時，你會發現sizeof(MyStruct)爲16。你知道爲何在VC中會得出這樣一個結果嗎？ 
其實，這是VC對變量存儲的一個特殊處理。爲了提升CPU的存儲速度，VC對一些變量的起始地址作了"對齊"處理。在默認狀況下，VC規定各成員變量存放的起始地址相對於結構的起始地址的偏移量必須爲該變量的類型所佔用的字節數的倍數。下面列出經常使用類型的對齊方式(vc6.0,32位系統)。 
類型 
對齊方式（變量存放的起始地址相對於結構的起始地址的偏移量） 
Char 
偏移量必須爲sizeof(char)即1的倍數 
int 
偏移量必須爲sizeof(int)即4的倍數 
float 
偏移量必須爲sizeof(float)即4的倍數 
double 
偏移量必須爲sizeof(double)即8的倍數 
Short 
偏移量必須爲sizeof(short)即2的倍數 
各成員變量在存放的時候根據在結構中出現的順序依次申請空間，同時按照上面的對齊方式調整位置，空缺的字節VC會自動填充。同時VC爲了確保結構的大小爲結構的字節邊界數（即該結構中佔用最大空間的類型所佔用的字節數）的
c/c++面試題(比較基礎但經典)
<注>:上傳區上我已經傳了幾課時孫鑫的VC++教程，有興趣的能夠趕忙去找找，要否則被無知的管理員刪了就惋惜了... 
一、解釋堆和棧的區別。
  1)棧區（stack）— 由編譯器自動分配釋放，存放函數的參數值，局部變量的值等。其操做方式相似於數據結構中的棧。
  2)堆區（heap） — 通常由程序員分配釋放，若程序員不釋放，程序結束時可能由OS回收 。注意它與數據結構中的堆是兩回事，
  分配方式卻是相似於鏈表，呵呵。
  3)全局區（靜態區）（static）—，全局變量和靜態變量的存儲是放在一塊的，初始化的全局變量和靜態變量在一塊區域，未初始 
  化的全局變量和未初始化的靜態變量在相鄰的另外一塊區域。 - 程序結束後有系統釋放 
  4)文字常量區—常量字符串就是放在這裏的。 程序結束後由系統釋放
  5)程序代碼區—存放函數體的二進制代碼。
二、論述含參數的宏與函數的優缺點。
  1)函數調用時，先求出實參表達式的值，而後帶入形參。而使用帶參的宏只是進行簡單的字符替換。
  2)函數調用是在程序運行時處理的，分配臨時的內存單元；而宏展開則是在編譯時進行的，在展開時並不分配內存單元，不進行值的傳
  遞處理，也沒有「返回值」的概念。
  3)對函數中的實參和形參都要定義類型，兩者的類型要求一致，如不一致，應進行類型轉換；而宏不存在類型問題，宏名無類型，它
  的參數也無類型，只是一個符號表明，展開時帶入指定的字符便可。宏定義時，字符串能夠是任何類型的數據。
  4)調用函數只可獲得一個返回值，而用宏能夠設法獲得幾個結果。
  5)使用宏次數多時，宏展開後源程序長，由於每展開一次都使程序增加，而函數調用不使源程序變長。
  6)宏替換不佔運行時間。而函數調用則佔運行時間（分配單元、保留現場、值傳遞、返回）。
  通常來講，用宏來表明簡短的表達式比較合適。
三、請講一講析構函數和虛函數的用法和做用。
四、在C++中有沒有純虛構造函數？
   沒有
五、在C++的一個類中聲明一個靜態成員函數有沒有用？
  不屬於類對象，因此能夠不經過對象而執行，但邏輯上屬於類，不歸於某一個對象，實現數據封裝
  提供一種方式訪問靜態成員變量 
  避免使用全局函數，爲函數設置一個類域的訪問權限
六、如何實現一個非阻塞的socket? 
  建立一個socket時，能夠指定它是否阻塞。在缺省狀況下，Berkerley的Socket函數和 WinSock都建立「阻塞」的socket。
  阻塞socket經過使用select函數或者WSAAsynSelect函數在指定操做下變成非阻塞的。 WSAAsyncSelect函數原型以下。
  int WSAAsyncSelect( SOCKET s, HWND hWnd, u_int wMsg, long lEvent );
  使用IO阻塞模型實現
七、在c++中純虛析構函數的做用是什麼？請舉例說明。
  當用一個基類的指針刪除一個派生類的對象時，派生類的析構函數會被調用
  class ClxBase
  {
   public:
     ClxBase() {};
     virtual ~ClxBase() {};
     virtual void DoSomething() { cout << "Do something in class ClxBase!" << endl; };
   };

   class ClxDerived : public ClxBase
   {
   public:
     ClxDerived() {};
     ~ClxDerived() { cout << "Output from the destructor of class ClxDerived!" << endl; };

     void DoSomething() { cout << "Do something in class ClxDerived!" << endl; };
   };
   ClxBase *pTest = new ClxDerived;
   pTest->DoSomething();
   delete pTest;
   Output : 
   Do something in class ClxDerived!
   Output from the destructor of class ClxDerived!
   可是，若是把類ClxBase析構函數前的virtual去掉，那輸出結果就是下面的樣了：
   Do something in class ClxDerived!
八、局部變量可否和全局變量重名？
   能夠，用"::"訪問全局變量
九、如何引用一個已經定義過的全局變量？
十、全局變量可不能夠定義在可被多個.C文件包含的頭文件中？爲何？
    能夠，在不一樣的C文件中以static形式來聲明同名全局變量。
    能夠在不一樣的C文件中聲明同名的全局變量，前提是其中只能有一個C文件中對此變量賦初值，此時鏈接不會出錯。
十一、do……while和while……do有什麼區別？
十二、對於一個頻繁使用的短小函數,在C語言中應用什麼實現,在C++中應用什麼實現?
    c用宏定義，c++用inline
1三、是否是一個父類寫了一個virtual 函數，若是子類覆蓋它的函數不加virtual ,也能實現多態?
    是的
1四、若是用VC開發程序，常見LNK2001錯誤，錯誤的緣由是什麼。
    變量只有聲明沒有定義
[b]下面這些問題，大概會佔面試時間的一半，而且會問不少問題，一不當心學生可能會被問住，兼顧考察他們的應變能力和內心素質。[/b]

1三、指針和引用有什麼分別；傳引用比傳指針安全，爲何？若是我使用常量指針難道不行嗎？
   1) 由於引用確定會指向一個對象，在C裏，引用應被初始化。
   2) 不存在指向空值的引用這個事實意味着使用引用的代碼效率比使用指針的要高。由於在使用引用以前不須要測試它的合法性。 
   3) 指針與引用的另外一個重要的不一樣是指針能夠被從新賦值以指向另外一個不一樣的對象。可是引用則老是指向在初始化時被指定的對象，之後不能改變。
   4) 指針變量和所指向的變量佔用不一樣的內存，但引用和所引用的變量指向同一個內存

   總的來講，在如下狀況下你應該使用指針，一是你考慮到存在不指向任何對象的可能（在這種狀況下，你可以設置指針爲空），
   二是你須要可以在不一樣的時刻指向不一樣的對象（在這種狀況下，你能改變指針的指向）。若是老是指向一個對象而且一旦指向一個
   對象後就不會改變指向，那麼你應該使用引用。   
    
   引用主要是爲了實現參數的地址傳遞，固然，咱們能夠經過傳遞指針改變實參指向的變量的內容，  
   但你要明白，那只是程序設計技巧，之前C是不支持引用的，因此C不支持參數的地址傳遞，所以若是咱們想改變實參的值，
   就只能經過那種技巧來實現，有時候爲了改變一個指針的值咱們不得不傳一個二級指針，很容易搞胡塗。如今有了引用，
   咱們就不用擔憂了，是否是使用技巧讓編譯器去處理吧，咱們只要使用引用就實現了地址傳遞，想改變誰就傳誰。

   引用既具備指針的效率，又具備變量使用的方便性和直觀性．
1四、參數傳遞有幾種方式；實現多態參數傳遞採用什麼方式，若是沒有使用某種方式緣由是什麼；
   Void* 和 模板
1五、構造函數能否是虛函數，爲何？析構函數呢，能否是純虛的呢？
   構造函數不能爲虛函數，要構造一個對象，必須清楚地知道要構造什麼，不然沒法構造一個對象。
   析構函數能夠爲純虛函數。
1六、C也能夠經過精心封裝某些函數功能實現重用，那C++的類有什麼優勢嗎，難道僅僅是爲實現重用。
   C++的主要優勢有：封裝性，繼承性，多態性。封裝是把數據與操做結合成一體，使程序結構更加緊湊，同時避免了數據紊亂帶來的
  調試與維護困難；繼承加強了軟件的可擴充性   
  併爲代碼重用提供了強有力的手段；多態性使程序員在設計程序時，對問題進行更好的抽象，以設計出重用性和維護性具佳期的程序。
  封裝性將數據與操做數據的函數銜接在一塊兒構成一個具備類類型的對象的描述稱爲封裝。
1七、C++特色是什麼，如何實現多態？畫出基類和子類在內存中的相互關係。
1八、爲何要引入抽象基類和純虛函數？
   主要目的是爲了實現一種接口的效果。
1九、結合一個你認爲比較能體現OOP思想的項目，描述一下你如何使用OOP的。
   這個題目須要開發經驗和思想，要求比較高
你們能夠先作着，若是有什麼問題到網上搜搜看，這些東西大都有答案。
1 經典C/C++面試題（一） 
    1.介紹一下STL，詳細說明STL如何實現vector。 
     STL (標準模版庫，Standard Template Library)它由容器算法迭代器組成。 
     STL有如下的一些優勢： 
     能夠方便容易地實現搜索數據或對數據排序等一系列的算法； 
     調試程序時更加安全和方便； 
     即便是人們用STL在UNIX平臺下寫的代碼你也能夠很容易地理解（由於STL是跨平臺的）。
     vector實質上就是一個動態數組，會根據數據的增長,動態的增長數組空間。  

2.若是用VC開發程序，常見這麼幾個錯誤，C2001,c2005,c2011,這些錯誤的緣由是什麼。 
　 在學習VC++的過程當中，遇到的LNK2001錯誤的錯誤消息主要爲： 
　 unresolved external symbol 「symbol」（不肯定的外部「符號」）。 
    若是鏈接程序不能在全部的庫和目標文件內找到所引用的函數、變量或標籤，將產生此錯誤消息。 
     通常來講，發生錯誤的緣由有兩個：一是所引用的函數、變量不存在、拼寫不正確或者使用錯誤；其次可能使用了不一樣版本的鏈接庫。 
     編程中常常能遇到LNK2005錯誤——重複定義錯誤，其實LNK2005錯誤並非一個很難解決的錯誤.

3.繼承和委派有什麼分別，在決定使用繼承或者委派的時候須要考慮什麼。 
     在OOD,OOP中，組合優於繼承. 
     固然多態的基礎是繼承，沒有繼承多態無從談起。 
     當對象的類型不影響類中函數的行爲時，就要使用模板來生成這樣一組類。 
     當對象的類型影響類中函數的行爲時，就要使用繼承來獲得這樣一組類.  

4.指針和引用有什麼分別；若是傳引用比傳指針安全，爲何？若是我使用常量指針難道不行嗎？ 
     (1) 引用在建立的同時必須初始化，即引用到一個有效的對象；而指針在定義的時候沒必要初始化，能夠在定義後面的任何地方從新賦值． 
     (2) 不存在ＮＵＬＬ引用，引用必須與合法的存儲單元關聯;而指針則能夠是NULL. 
     (3) 引用一旦被初始化爲指向一個對象，它就不能被改變爲另外一個對象的引用；而指針在任什麼時候候均可以改變爲指向另外一個對象．給引用賦值並非改變它和原始對象的綁定關係． 
     (4) 引用的建立和銷燬並不會調用類的拷貝構造函數 
     (5) 語言層面，引用的用法和對象同樣；在二進制層面，引用通常都是經過指針來實現的，只不過編譯器幫咱們完成了轉換. 
     不存在空引用，而且引用一旦被初始化爲指向一個對象，它就不能被改變爲另外一個對象的引用，顯得很安全。 
     const 指針仍然存在空指針，而且有可能產生野指針. 
     總的來講：引用既具備指針的效率，又具備變量使用的方便性和直觀性．

5.參數傳遞有幾種方式；實現多態參數傳遞採用什麼方式，若是沒有使用某種方式緣由是什麼； 
     傳值，傳指針或者引用 
________________________________________
2 經典C/C++面試題（一）     

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.多重繼承如何消除向上繼承的二義性。 
     使用虛擬繼承便可. 
________________________________________
3 回覆：經典C/C++面試題（一） 
    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; 
 ________________________________________
4 回覆：經典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分配的對象的引用、返回一個靜態對象引用。根據前面提到的引用做爲返回值的三個規則，第二、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) 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(;;) 軟件開發網 http://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 這是個什麼東東，禁止 ________________________________________13 回覆：經典C/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 服務提供了數據流傳輸、可靠性、有效流控制、全雙工操做和多路複用技術等。 ________________________________________14 回覆：經典C/C++面試題（一）     　　與 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); 軟件開發網 http://www.mscto.com/ ________________________________________15 回覆：經典C/C++面試題（一）     　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"); ________________________________________16 回覆：經典C/C++面試題（一）     　　　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； 軟件開發網 http://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 兩種狀態，用一位二進位便可。爲了節省存儲空間，並使處理簡便，Ｃ語言又提供了一種數據結構，稱爲「位域」或「位段」。所謂「位域」是把一個字節中的二進位劃分爲幾個不一樣的區域，並說明每一個區域的位數。每一個域有一個域名，容許在程序中按域名進行操做。這樣就能夠把幾個不一樣的對象用一個字節的二進制位域來表示。1、位域的定義和位域變量的說明位域定義與結構定義相仿，其形式爲：  ________________________________________17 回覆：經典C/C++面試題（一）  　　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; 　　} ________________________________________18 回覆：經典C/C++面試題（一）     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字節。  　　第二個最後會對照是否是結構體內最大數據的倍數，不是的話，會補成是最大數據的倍數。 ________________________________________19 回覆：經典C/C++面試題（一）     （五） 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) ________________________________________20 回覆：經典C/C++面試題（一）     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  ________________________________________21 回覆：經典C/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; } 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：堆是向高地址擴展的數據結構，是不連續的內存區域。這是因爲系統是用鏈表來存儲的空閒內存地址的，天然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限於計算機系統中有效的虛擬內存。因而可知，堆得到的空間比較靈活，也比較大。 ________________________________________22 回覆：經典C/C++面試題（一）     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．設置觸發條件，就是在你的函數中把你的回調函數名做爲一個參數，以便系統調用 如： 1、聲明回調函數類型 typedef void (*FunPtr)(void); 2、定義回調函數 class A  { public: A(); static void callBackFun(void) //回調函數，必須聲明爲static { cout<<"callBackFun"<<endl; } virtual ~A(); }; 3、設置觸發條件 void Funtype(FunPtr p) { p(); } void main(void) { Funtype(A::callBackFun); } C. 回調函數與API函數 回調和API很是接近，他們的共性都是跨層調用的函數。但區別是API是低層提供給高層的調用，通常這個函數對高層都是已知的；而回調正好相反，他是高層提供給底層的調用，對於低層他是未知的，必須由高層進行安裝，這個安裝函數其實就是一個低層提供的API，安裝後低層不知道這個回調的名字，但它經過一個函數指針來保存這個回調函數，在須要調用時，只需引用這個函數指針和相關的參數指針。 其實：回調就是該函數寫在高層，低層經過一個函數指針保存這個函數，在某個事件的觸發下，低層經過該函數指針調用高層那個函數。 ________________________________________23 回覆：經典C/C++面試題（一）     一、局部變量可否和全局變量重名？ 能，局部會屏蔽全局。要用全局變量，須要使用"::" 局部變量能夠與全局變量同名，在函數內引用這個變量時，會用到同名的局部變量，而不會用到全局變量。對於有些編譯器而言，在同一個函數內能夠定義多個同名的局部變量，好比在兩個循環體內都定義一個同名的局部變量，而那個局部變量的做用域就在那個循環體內。 二、如何引用一個已經定義過的全局變量？ extern 能夠用引用頭文件的方式，也能夠用extern關鍵字，若是用引用頭文件方式來引用某個在頭文件中聲明的全局變理，假定你將那個變寫錯了，那麼在編譯期間會報錯，若是你用extern方式引用時，假定你犯了一樣的錯誤，那麼在編譯期間不會報錯，而在鏈接期間報錯。 三、全局變量可不能夠定義在可被多個.C文件包含的頭文件中？爲何？ 能夠，在不一樣的C文件中以static形式來聲明同名全局變量。 能夠在不一樣的C文件中聲明同名的全局變量，前提是其中只能有一個C文件中對此變量賦初值，此時鏈接不會出錯。 四、語句for( ；1 ；)有什麼問題？它是什麼意思？ 無限循環，和while(1)相同。 五、do……while和while……do有什麼區別？ 前一個循環一遍再判斷，後一個判斷之後再循環。 六、請寫出下列代碼的輸出內容 #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 七、請找出下面代碼中的因此錯誤 說明：如下代碼是把一個字符串倒序，如「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; } 八、-1,2,7,28,,126請問28和126中間那個數是什麼？爲何？ ________________________________________24 回覆：經典C/C++面試題（一）     答案應該是4^3-1=63 規律是n^3-1(當n爲偶數0，2，4) n^3+1(當n爲奇數1，3，5) 答案：63 九、用兩個棧實現一個隊列的功能？要求給出算法和思路！ 設2個棧爲A,B, 一開始均爲空. 入隊: 將新元素push入棧A;  出隊: (1)判斷棧B是否爲空； (2)若是不爲空，則將棧A中全部元素依次pop出並push到棧B； (3)將棧B的棧頂元素pop出；這樣實現的隊列入隊和出隊的平攤複雜度都仍是O(1), 比上面的幾種方法要好。 十、在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); } 十一、對於一個頻繁使用的短小函數,在C語言中應用什麼實現,在C++中應用什麼實現? c用宏定義，c++用inline 十二、直接連接兩個信令點的一組鏈路稱做什麼? PPP點到點鏈接 1三、接入網用的是什麼接口? 1四、voip都用了那些協議? 1五、軟件測試都有那些種類? 黑盒：針對系統功能的測試 白合：測試函數功能，各函數接口 1六、肯定模塊的功能和模塊的接口是在軟件設計的那個隊段完成的? 概要設計階段 1七、enum string { x1, x2, x3=10, x4, x5, }x; 問x= 0x801005，0x8010f4; 1八、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。 ________________________________________25 回覆：經典C/C++面試題（一）     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 常量進行調試，可是不能對宏常量進行調試。 ________________________________________26 回覆：經典C/C++面試題（一）     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 );  ________________________________________27 回覆：經典C/C++面試題（一）     _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(); //關閉輸出文件流 }