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

  1.求下面函數的返回值(微軟)
  int func(x)
  {
  int countx = 0;
  while(x)
  {
  countx ++;
  x = x&(x-1);
  }
  return countx;
  }
  假定x = 9999。 答案:8
  思路:將x轉化爲2進制,看含有的1的個數。
  2. 什麽是「引用」?申明和使用「引用」要注重哪些問題?
  答:引用就是某個目標變量的「別名」(alias),對應用的操作與對變量直接操作效果完全相同。申明一個引用的時候,切記要對其進行初始化。引用聲明完畢後,相當于目標變量名有兩個名稱,即該目標原名稱和引用名,不能再把該引用名作爲其他變量名的別名。聲明一個引用,不是新定義了一個變量,它只表示該引用名是目標變量名的一個別名,它本身不是一種數據類型,因此引用本身不占存儲單元,系統也不給引用分配存儲單元。不能建立數組的引用。
  3. 將「引用」作爲函數參數有哪些特點?
  (1)傳遞引用給函數與傳遞指針的效果是一樣的。這時,被調函數的形參就成爲原來主調函數中的實參變量或對象的一個別名來使用,所以在被調函數中對形參變量的操作就是對其相應的目標對象(在主調函數中)的操作。
  (2)使用引用傳遞函數的參數,在內存中並沒有産生實參的副本,它是直接對實參操作;而使用一般變量傳遞函數的參數,當發生函數調用時,需要給形參分配存儲單元,形參變量是實參變量的副本;假如傳遞的是對象,還將調用拷貝構造函數。因此,當參數傳遞的數據較大時,用引用比用一般變量傳遞參數的效率和所占空間都好。
  (3)使用指針作爲函數的參數雖然也能達到與使用引用的效果,但是,在被調函數中同樣要給形參分配存儲單元,且需要重複使用"*指針變量名"的形式進行運算,這很輕易産生錯誤且程序的閱讀性較差;另一方面,在主調函數的調用點處,必須用變量的地址作爲實參。而引用更輕易使用,更清楚。
  4. 在什麽時候需要使用「常引用」?
  假如既要利用引用提高程序的效率,又要保護傳遞給函數的數據不在函數中被改變,就應使用常引用。常引用聲明方式:const 類型標識符 &引用名=目標變量名;
  例1
  int a ;
  const int &ra=a;
  ra=1; //錯誤
  a=1; //正確
  例2
  string foo( );
  void bar(string & s);
  那麽下面的表達式將是非法的:
  bar(foo( ));
  bar("hello world");
  原因在于foo( )和"hello world"串都會産生一個臨時對象,而在C++中,這些臨時對象都是const類型的。因此上面的表達式就是試圖將一個const類型的對象轉換爲非const類型,這是非法的。
  引用型參數應該在能被定義爲const的情況下,盡量定義爲const 。
  5. 將「引用」作爲函數返回值類型的格式、好處和需要遵守的規則?
  格式:類型標識符 &函數名(形參列表及類型說明){ //函數體 }
  好處:在內存中不産生被返回值的副本;(注重:正是因爲這點原因,所以返回一個局部變量的引用是不可取的。因爲隨著該局部變量生存期的結束,相應的引用也會失效,産生runtime error!
  注重事項:
  (1)不能返回局部變量的引用。這條可以參照Effective C++[1]的Item 31。主要原因是局部變量會在函數返回後被銷毀,因此被返回的引用就成爲了"無所指"的引用,程序會進入未知狀態。
  (2)不能返回函數內部new分配的內存的引用。這條可以參照Effective C++[1]的Item 31。雖然不存在局部變量的被動銷毀問題,可對于這種情況(返回函數內部new分配內存的引用),又面臨其它尴尬局面。例如,被函數返回的引用只是作爲一個臨時變量出現,而沒有被賦予一個實際的變量,那麽這個引用所指向的空間(由new分配)就無法釋放,造成memory leak。
  (3)可以返回類成員的引用,但最好是const。這條原則可以參照Effective C++[1]的Item 30。主要原因是當對象的屬性是與某種業務規則(business rule)相關聯的時候,其賦值經常與某些其它屬性或者對象的狀態有關,因此有必要將賦值操作封裝在一個業務規則當中。假如其它對象可以獲得該屬性的非常量引用(或指針),那麽對該屬性的單純賦值就會破壞業務規則的完整性。
  (4)流操作符重載返回值申明爲「引用」的作用:
  流操作符<<和>>,這兩個操作符經常希望被連續使用,例如:cout << "hello" << endl;因此這兩個操作符的返回值應該是一個仍然支持這兩個操作符的流引用。可選的其它方案包括:返回一個流對象和返回一個流對象指針。但是對于返回一個流對象,程序必須重新(拷貝)構造一個新的流對象,也就是說,連續的兩個<<操作符實際上是針對不同對象的!這無法讓人接受。對于返回一個流指針則不能連續使用<<操作符。因此,返回一個流對象引用是惟一選擇。這個唯一選擇很要害,它說明了引用的重要性以及無可替代性,也許這就是C++語言中引入引用這個概念的原因吧。賦值操作符=。這個操作符象流操作符一樣,是可以連續使用的,例如:x = j = 10;或者(x=10)=100;賦值操作符的返回值必須是一個左值,以便可以被繼續賦值。因此引用成了這個操作符的惟一返回值選擇。
  例3
  #i nclude <iostream.h>
  int &put(int n);
  int vals[10];
  int error=-1;
  void main()
  {
  put(0)=10; //以put(0)函數值作爲左值,等價于vals[0]=10;
  put(9)=20; //以put(9)函數值作爲左值,等價于vals[9]=20;
  cout<<vals[0];
  cout<<vals[9];
  }
  int &put(int n)
  {
  if (n>=0 && n<=9 ) return vals[n];
  else { cout<<"subscript error"; return error; }
  
   }
  (5)在另外的一些操作符中,卻千萬不能返回引用:+-*/ 四則運算符。它們不能返回引用,Effective C++[1]的Item23具體的討論了這個問題。主要原因是這四個操作符沒有side effect,因此,它們必須構造一個對象作爲返回值,可選的方案包括:返回一個對象、返回一個局部變量的引用,返回一個new分配的對象的引用、返回一個靜態對象引用。根據前面提到的引用作爲返回值的三個規則,第2、3兩個方案都被否決了。靜態對象的引用又因爲((a+b) == (c+d))會永遠爲true而導致錯誤。所以可選的只剩下返回一個對象了。
  6. 「引用」與多態的關系?
  引用是除指針外另一個可以産生多態效果的手段。這意味著,一個基類的引用可以指向它的派生類實例。
  例4
  Class A; Class B : Class A{...}; B b; A& ref = b;
  7. 「引用」與指針的區別是什麽?
  指針通過某個指針變量指向一個對象後,對它所指向的變量間接操作。程序中使用指針,程序的可讀性差;而引用本身就是目標變量的別名,對引用的操作就是對目標變量的操作。此外,就是上面提到的對函數傳ref和pointer的區別。
  8. 什麽時候需要「引用」?
  流操作符<<和>>、賦值操作符=的返回值、拷貝構造函數的參數、賦值操作符=的參數、其它情況都推薦使用引用。
  以上 2-8 參考:http://blog.csdn.net/wfwd/archive/2006/05/30/763551.aspx
  9. 結構與聯合有和區別?
  1. 結構和聯合都是由多個不同的數據類型成員組成, 但在任何同一時刻, 聯合中只存放了一個被選中的成員(所有成員共用一塊地址空間), 而結構的所有成員都存在(不同成員的存放地址不同)。
  2. 對于聯合的不同成員賦值, 將會對其它成員重寫, 原來成員的值就不存在了, 而對于結構的不同成員賦值是互不影響的。
  10. 下面關于「聯合」的題目的輸出?
  a)
  #i nclude <stdio.h>
  union
  {
  int i;
  char x[2];
  }a;
  void main()
  {
  a.x[0] = 10;
  a.x[1] = 1;
  printf("%d",a.i);
  }
  答案:266 (低位低地址,高位高地址,內存占用情況是Ox010A)
  b)
  main()
  {
  union{ /*定義一個聯合*/
  int i;
  strUCt{ /*在聯合中定義一個結構*/
  char first;
  char second;
  }half;
  }number;
  number.i=0x4241; /*聯合成員賦值*/
  printf("%c%c\n", number.half.first, mumber.half.second);
  number.half.first='a'; /*聯合中結構成員賦值*/
  number.half.second='b';
  printf("%x\n", number.i);
  getch();
  }
  答案: AB (0x41對應'A',是低位;Ox42對應'B',是高位)
  6261 (number.i和number.half共用一塊地址空間)
  11. 已知strcpy的函數原型:char *strcpy(char *strDest, const char *strSrc)其中strDest 是目的字符串,strSrc 是源字符串。不調用C++/C 的字符串庫函數,請編寫函數 strcpy。
  答案:
  char *strcpy(char *strDest, const char *strSrc)
  {
  if ( strDest == NULL strSrc == NULL)
  return NULL ;
  if ( strDest == strSrc)
  return strDest ;
  char *tempptr = strDest ;
  while( (*strDest++ = *strSrc++) != 『\0』)
  ;
  return tempptr ;
  }
  12. 已知String類定義如下:
  class String
  {
  public:
  String(const char *str = NULL); // 通用構造函數
  String(const String &another); // 拷貝構造函數
  ~ String(); // 析構函數
  String & operater =(const String &rhs); // 賦值函數
  private:
  char *m_data; // 用于保存字符串
  };
  嘗試寫出類的成員函數實現。
  答案:
  String::String(const char *str)
  {
  if ( str == NULL ) //strlen在參數爲NULL時會抛異常才會有這步判定
  {
  m_data = new char[1] ;
  m_data[0] = '\0' ;
  }
  else
  {
  m_data = new char[strlen(str) + 1];
  strcpy(m_data,str);
  }
  }
  String::String(const String &another)
  {
  m_data = new char[strlen(another.m_data) + 1];
  strcpy(m_data,other.m_data);
  }
  String& String::operator =(const String &rhs)
  {
  if ( this == &rhs)
  return *this ;
  delete []m_data; //刪除原來的數據,新開一塊內存
  
   m_data = new char[strlen(rhs.m_data) + 1];
  strcpy(m_data,rhs.m_data);
  return *this ;
  }
  String::~String()
  {
  delete []m_data ;
  }
  13. .h頭文件中的ifndef/define/endif 的作用?
  答:防止該頭文件被重複引用。
  14. #i nclude<file.h> 與 #i nclude "file.h"的區別?
  答:前者是從Standard Library的路徑尋找和引用file.h,而後者是從當前工作路徑搜尋並引用file.h。
  15.在C++ 程序中調用被C 編譯器編譯後的函數,爲什麽要加extern 「C」?
  首先,作爲extern是C/C++語言中表明函數和全局變量作用範圍(可見性)的要害字,該要害字告訴編譯器,其聲明的函數和變量可以在本模塊或其它模塊中使用。
  通常,在模塊的頭文件中對本模塊提供給其它模塊引用的函數和全局變量以要害字extern聲明。例如,假如模塊B欲引用該模塊A中定義的全局變量和函數時只需包含模塊A的頭文件即可。這樣,模塊B中調用模塊A中的函數時,在編譯階段,模塊B雖然找不到該函數,但是並不會報錯;它會在連接階段中從模塊A編譯生成的目標代碼中找到此函數
  extern "C"是連接申明(linkage declaration),被extern "C"修飾的變量和函數是按照C語言方式編譯和連接的,來看看C++中對類似C的函數是怎樣編譯的:
  作爲一種面向對象的語言,C++支持函數重載,而過程式語言C則不支持。函數被C++編譯後在符號庫中的名字與C語言的不同。例如,假設某個函數的原型爲:
  void foo( int x, int y );
  該函數被C編譯器編譯後在符號庫中的名字爲_foo,而C++編譯器則會産生像_foo_int_int之類的名字(不同的編譯器可能生成的名字不同,但是都采用了相同的機制,生成的新名字稱爲「mangled name」)。
  _foo_int_int 這樣的名字包含了函數名、函數參數數量及類型信息,C++就是靠這種機制來實現函數重載的。例如,在C++中,函數void foo( int x, int y )與void foo( int x, float y )編譯生成的符號是不相同的,後者爲_foo_int_float。
  同樣地,C++中的變量除支持局部變量外,還支持類成員變量和全局變量。用戶所編寫程序的類成員變量可能與全局變量同名,我們以"."來區分。而本質上,編譯器在進行編譯時,與函數的處理相似,也爲類中的變量取了一個獨一無二的名字,這個名字與用戶程序中同名的全局變量名字不同。
  未加extern "C"聲明時的連接方式
  假設在C++中,模塊A的頭文件如下:
  // 模塊A頭文件moduleA.h
  #ifndef MODULE_A_H
  #define MODULE_A_H
  int foo( int x, int y );
  #endif
  在模塊B中引用該函數:
  // 模塊B實現文件moduleB.cpp
  #i nclude "moduleA.h"
  foo(2,3);
  實際上,在連接階段,連接器會從模塊A生成的目標文件moduleA.obj中尋找_foo_int_int這樣的符號!
  加extern "C"聲明後的編譯和連接方式
  加extern "C"聲明後,模塊A的頭文件變爲:
  // 模塊A頭文件moduleA.h
  #ifndef MODULE_A_H
  #define MODULE_A_H
  extern "C" int foo( int x, int y );
  #endif
  在模塊B的實現文件中仍然調用foo( 2,3 ),其結果是:
  (1)模塊A編譯生成foo的目標代碼時,沒有對其名字進行非凡處理,采用了C語言的方式;
  (2)連接器在爲模塊B的目標代碼尋找foo(2,3)調用時,尋找的是未經修改的符號名_foo。
  假如在模塊A中函數聲明了foo爲extern "C"類型,而模塊B中包含的是extern int foo( int x, int y ) ,則模塊B找不到模塊A中的函數;反之亦然。
  所以,可以用一句話概括extern 「C」這個聲明的真實目的(任何語言中的任何語法特性的誕生都不是隨意而爲的,來源于真實世界的需求驅動。我們在思考問題時,不能只停留在這個語言是怎麽做的,還要問一問它爲什麽要這麽做,動機是什麽,這樣我們可以更深入地理解許多問題):實現C++與C及其它語言的混合編程。
  明白了C++中extern "C"的設立動機,我們下面來具體分析extern "C"通常的使用技巧:
  extern "C"的慣用法
  (1)在C++中引用C語言中的函數和變量,在包含C語言頭文件(假設爲cExample.h)時,需進行下列處理:
  extern "C"
  {
  #i nclude "cExample.h"
  }
  而在C語言的頭文件中,對其外部函數只能指定爲extern類型,C語言中不支持extern "C"聲明,在.c文件中包含了extern "C"時會出現編譯語法錯誤。
  C++引用C函數例子工程中包含的三個文件的源代碼如下:
  /* 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算法效率最好,時間複雜度是O(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;
  }