C++ 知識點

這是我在csdn上看到的一篇文章。
講的還不錯，貼出來給大家看看
1. 傳指標時，我們可以通過指標來修改它在外部所指向的內容。但如果要修改外部指標所指向的對象是不可能的。例如傳遞外部指標到函數內來分配空間，必須傳遞指標的指標或指標的引用。

2. char carry[10] = {0}; 編譯器會將其後所有的東西都置0；

3. 函數傳回值為const時，返回的東西付給一個類型相同的標示後其不能為左值；

4. const int *i; int const *i; int * const i; 前兩個功能相同，說明I所指向的內容不變；最後一個說明指標指向的地址不變，但內容可變。

5. 類中的const成員函數。定義為在原型後加const。常量函數不能修改類中的任何屬性。但有兩種方法可以修改。

a)         {（myclass *）this->member1 = values;}

b)        將一個成員定義成mutable即可被常量函數修改。

6. 類中的常量const 類型的，不能在類中被用來定義數組。而enum {ONE=100; TWO=2};定義的ONE、TWO卻可以。通常的enum定義的置分配問題：enum A{ L=9, Z};此時Z的值為10。

7. 用const定義的int可用來開闢數組，但const定義的常量數組中的元素，不能用來定義數組。

8. 用sizeof計算變數的空間，如果是數組，按實際空間返回；常量字串（實際上是在靜態記憶體區開闢的變數）sizeof返回比實際長度加一。如果是指標則不考慮它指向的空間大小，僅僅返回指標類型的大小。如果用sizeof計算函數的行參，即使是屬組也僅僅返回一個相互關聯類型指標的大小。

9. 形如int iarray[] = {12, 124, 433};編譯器會自動給iarray分配3個元素的長度。元素長度的個數計算公式為sizeof(iarray) / sizeof(*iarray)。

10.         拷貝建構函式：當行參和實參結合時，如果是複雜物件的傳實值型別，則調用拷貝建構函式產生一個臨時對象作為實參，退出函數時，臨時對象被調用解構函式釋放。當傳回值是複雜物件是，也是調用拷貝建構函式來賦值。這就出現建構函式和解構函式被調用次數不相等的情況。拷貝建構函式的原型為A(A&)，我們可在類中重載。（預設的拷貝建構函式是使用位（bit）拷貝方法：淺層拷貝，不拷貝指標指向的內容）。

11.         volatile類型的變數告訴編譯器，本變數不需要進行代碼最佳化。在多線程的應用中，我們如果讀入一個變數到寄存器，此時時間片到期，去處理其他線程了，在重新獲得處理機時，volatile類型告訴處理機，重新從變數讀取資料到寄存器，而不是用寄存器資料直接處理，這樣可以防止髒資料。

12.         class 和struct在一定程度上有相同的功能，只不過前者預設的成員是私人的，後者在預設時成員為共有的。故而class不是c++必需的保留字

13.         c和c++編譯器，對相同的函數名編譯後產生的相同的標示不同，故而在引用c的庫檔案時必須使用extern “C”告訴編譯器，它是c的函數，按c的規則編譯。通常我們使用的標準標頭檔已被處理過。

14.         #include “filename”； #include <filename>，前者先在目前的目錄下尋找檔案，如果找不到再到系統規定的路徑下找，後者直接到系統規定的路徑下找。

15.         任何地方分配的靜態變數（static）,其生命週期和主進程相同。第二次定義一個已存在的static變數，對變數的內用無影響，但它的可見範圍只在定義的範圍內。（考研曾作錯！）(從靜態變數的特性不難理解，類中的static類型是所有對象共用的)

16.         內嵌函式（inline）在實現上實際和宏類似，在內嵌函式出現的地方將函數展開來避免函數調用時的出棧、如棧，提高效率。但內嵌函式的代價是：代碼增大。inline函數適合成員函數和自由函數。在類中實現的函數自動為內嵌函式。inline必須定義到函數的實現上，例如：inline int PlusOne(int) 是無效的。友元函數在類的體內被實現自動變為內嵌函式。

17.         #include <iostream.h>

#define DEBUG(X) cout<<#X"="<<X<<endl

其中的#X表示X被當作字串輸出。

18.         assert(0 != 0); 如果assert中的條件為假，則運行期間回退出程式，且報告出錯代碼的行號。（#include <assert.h>）

19.         靜態對象在main結束或exit()被調用時才調用自身的解構函式。這意味著，在對象的解構函式中調用exit()是很危險的，有可能進入一個死迴圈中。調用abort()來退出函數，靜態對象的解構函式並不會被調用。我們可以用atexit()來指定跳出main或調用exit時要執行的操作，用atexit註冊的函數，可以在所有對象的解構函式之前調用。

void exit_fn2(void)

{

   printf("Exit function #2 called/n");

}     //處理函數

atexit(exit_fn2);

20.         全域變數實際上用的是靜態儲存。靜態變數的構造是在進入main之前調用的，在main結束時調用它的解構函式。變數的名字由小範圍（c++而言）：

//*.cpp

int a; //靜態變數,但為 extern int a; 即它是全域的，外部可見的

static int b;       //靜態變數,static 和extern相反，只在*.cpp中有效，對其他單元（檔案）是不可見的。函數的定義和上面相同。

main()

{     }

類的靜態成員變數可以如下賦值：int X::s=23;（在*.cpp中，無論公私都可以）

21.         名字空間(namespace): 定義一個名字空間，然後使用unsing就可以將當前的類型上下文轉換名字空間所定地的.

namespace math

{

       enum sign{positive, negative};

       class integer{

       int i；

       sign s;

       public:

       interger(int I=0): i(i) {………}

       sign Sign() {………}

       …………………..  

       };//end class

interger A, B, C;

interger divide(interger, interger);

}//no ;

 

void q()

{

       using namespace math;

interger A; //hides math::A

A.Sign(negative);

Math::A.Sign(positive);

}

22.         一般對於函數flaot f(int a, int b); 某些c++編譯器編譯後產生_f_int_int的名字，有些c編譯器則產生_f的名字。故在c++中連結c的庫函數時要用extern “C”告訴編譯器，按c的規則來編譯函數。類似的還有extern “C”{#include “myhead.h”},c++還支援extern “C++”{}.

23.         在函數調用時，傳引用也是將指標壓棧。

24.         建構函式、解構函式、賦值建構函式、重載的=，四者的調用順序：(三種函數都已實現)

a)    X  x;     X  a=x;

result:

X:construct  

X:copy_struct

b)    X x;        X a;        a=x;

Result:

X:construct

X:construct

X:copy_stru

operator =

X:destruct

如果沒有賦值建構函式則結果：

                    X:construct

X:construct

operator =

X:destruct

（如果直接X a=x;這不掉用一般的建構函式，調用複製建構函式）

   指向類的成員函數的指標：設 int X:: a(void){}

X x;

                 int (X:: *pf)(void)= &X::a;

                 (x.*pf)();

指向成員變數的指標：設int i; 是X的成員變數

                    int X::*pm = &X::i;

                 X x;
x.*pm=12;

                 X *p=&x;

p->*pm=11;

25.         ++的操作符重載

const X& operator++() //++b;            const X operator++(int ) //b++

其中的第二個參數為啞元，永遠也不使用到。

26．自動類型轉換

a.)       class one{ b} class two{

      public:        one(){}                                          public:       two(const one &){}

             };              };

void f(two) {}

main(){ one ONE;       f(ONE);     }

此時會調用two中的一個建構函式進行類型的自動轉換。但效率不高。可以阻止隱含的類型轉換。方法如下：將類two給為

class two{ public:  explicit two(const one &){} };

explicit只對建構函式起作用。此時必須這樣調用函數：f(two(ONE));

27．    一個理想的string類，它知道如何從string轉換到char *:

      class string

{

      private:       char *s;

       public:

               string(const char *S="")

               {

                       s=new char[strlen(S)+1];

                       strcpy(s, S);

               }

               ~string(){delete s;}

               operator const char *() const {return s;}

};

     int main(void)

     {

       string str1("lizhihui2");

       string str2("lizhihui2");

       strcmp(str1, str2);

     }

28．    如果從一種類型到另一鐘類型有多種轉換方法，則會出錯：

      classs Y;

      class X

{

             public:      operator Y() const； //convert X to Y

      };

      class Y{

             public:       Y(X) ;//convert X to Y

      };

      void f(Y);

      main()

{

      X x;

      f(x); //error: ambiguous conversion

}

29．刪除數組對象：

      foo *fp = new foo[100];        delete []fp; 或 delete [100]fp;

      使指標更像數組：int *const q=new int[10];這樣q不能移動則更像數組。

30．new堆記憶體用完時的異常處理器函數

void out_of_memory() {printf(“out of memory!/n”);        exit(1);}

main() { set_new_handler(out_of_memory); …………….}

31．new和delete的一種全域重載方法

void * operator new(size_t sz)

{

       printf("operator new :%d bytes/n",sz);

       void *m=malloc(sz);

       if(!m) puts("out of memory/n");

       return m;

}

void operator delete(void *m)

{

       puts("operator delete./n");

       free(m);

}

class s

{

       int i[100];

public:

       s(){puts("s::S()");}

       ~s(){puts("s::~S()");}

};

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

{

       int *p=new int(23); //operator new :4 bytes

       delete p;                  //operator delete.

 

       s *pp=new s;           //operator new :400 bytes

       delete pp;                 //operator delete.

 

       s*pa=new s[3];       //operator new :1208 bytes, more 8 bytes for array info

       delete []pa;              // operator delete.       (C++Bilder unsupport)

       return 0;

}

預設的系統new和delete是調用malloc和free來工作的，系統要維護一張記憶體配置表。分配出去的記憶體要記住它的大小和起始地址，釋放時根據起使地址釋放。

32．    重載new在特定的記憶體上分配空間

class s

{

       int i;

public:

       s(int ix=0){i=ix;}

       ~s(){puts("s::~S()");}

       void * operator new(size_t  d, void *loc) {return loc;}

};

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

{

       int len[10];

       s *ps = new (len+1) s(3412); 

//第一個函數相當於告訴new從哪裡開始分配空間（隱含）；

//它的值則是要分配的長度。特殊的分配要注意需特殊的釋放。

       return 0;

}

new 在len的空間上分配空間給s對象。（new重載第一個參數必須為size_t系統會自動傳給它一個大小尺寸）

33．    跳轉函數setjmp、longjmp

void OZ()

{

       printf("there 's no placelike home/n");

       longjmp(kansas, 47);

}

jmp_buf kansas;

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

{

       if(setjmp(kansas)==0)  OZ();

       else       printf(" I have a dream../n");

       return 0;

}//執行完OZ()後，會立即跳轉到printf(" I have a dream../n");執行

setjmp()是一個特別的函數，當被調用的時候，它吧當前的進程狀態的相關資訊放到buff中，並返回0；如果使用longjmp對同一個buff操作，這就像再次從setjmp中返回，即正確彈出setjmp的後端。這時傳回值對於longjmp是第二個參數，所以能發現實際上從longjum中返回了。

34．    異常定製和拋出

class up{};

class fit{};

void g();

void f(int i) throw (up, fit)

{

       switch(i)

       {

               case 1: throw up();

               case 2: throw fit();

       }
       g();

}

void g(){throw 47;}

void my_unexpected()

{

       printf("unexpected handle!/n");

       exit(1);

}

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

{

       set_unexpected(my_unexpected);

       for(int i=1;i<=3;i++)

       {

               try{ f(i);}

               catch(up)  {printf("catch up/n");}

               catch(fit){printf("catch fit/n");}

       }

       return 0;

}

set_unexpected設定處理系統不認識的異常情況（預設是中斷）（異常處理安裝器預設指向terminate()）。上面我們定義了up、fit兩種異常拋出類，並拋出了這兩種異常，來捕獲。拋出異常時也產生了異常的一個對象。Catch(…){}捕獲所有異常。( 但失去了截獲的異常類型)

35．    當有未被捕獲的的異常時，系統預設調用terminate()，它調用abort()函數直接從進程中退出，此時靜態全域變數的解構函式未被調用。可以使用set_terminate來安裝自己的terminate函數，用法和上面的幾個安裝起一樣。他返回的typedef void (*terminate_handler)();為老的處理器指標。

       當一個建構函式在分配資源時，如果這時有unexpect異常到達，系統會結束而不會調用解構函式來釋放已指派的堆記憶體。

36．    運行期間的類型判定（run-time type identification, RTTI）

a.) 編譯器實現。

使用函數typeid(objname).name()就可得到函數的名字。實際上typeid（）返回全域typeinfo類的常量對象的一個引用。使用before來判斷一個對象是否在另一個對象前定義。

fit ft;

       up u;

       if(typeid(ft).before(typeid(u))) printf("lzh/n"); //is true

b). 安全方法向下映射法

        C* pc = dynamic_cast<C*>(pd);   // ok: C is a direct base class
                                         // pc points to C subobject of pd
           判斷pd時不是一個C*類型的對象，如是則返回一個指標，否則返回NULL.是通過試圖指派法來斷定的，與第一種方法不同。