一、引用

1. 引用的概念

寫法：型別名 & 引用名 = 某變數名;

int n = 4;
int & r = n;

某個變數的引用，等價於這個變數，相當於該變數的一個別名。

2. 注意事項

• 定義引用是一定要將其初始化成引用某個變數。
• 初始化後，它就一直引用該變數，不會再引用別的變量了。
• 引用只能引用變數，不能引用常量和表示式。
  
  

3. 引用的簡單示例

交換兩個變數的值

void swap(int & a, int & b)
{
      int tmp;
      tmp = a; a = b; b = tmp;
}
int n1, n2;
swap(n1, n2);
 

4. 引用作為函式的返回值

int n = 4;
int & SetValue() { return n; }
int main()
{
      SetValue() = 40;
      cout << n;
      return 0;
}//輸出：40

5. 常引用

定義引用時，前面加const關鍵字，即為“常引用”

int n;
const int & r = n;

r的型別是const int &

注意：不能通過常引用去修改其引用的內容

int n = 100;
const int & r = n;
r = 200;//編譯錯
n = 300;//沒問題
 

6. 常引用和非常引用的轉換

const T & 和T & 是不同的型別！
T & 型別的引用或T型別的變數可以用來初始化const T & 型別的引用。
const T & 型別的常變數和const T & 型別的引用則不能用來初始化T & 型別的引用，除非進行強制型別轉換。

二、const關鍵字

1. 定義常量

const int MAX_VAL = 23;
const double Pi = 3.14;
const char* SCHOOL_NAME = "Peking University";

2. 定義常量指標

• 不可通過常量指標修改其指向的內容

int n, m;
const int * p = & n;
* p = 5; //編譯出錯
n = 4; //ok
p = &m; //ok,常量指標的指向可以變化

• 不能把常量指標賦值給非常量指標，反過來可以
  （常量指標指向的內容不應該被修改）

const int * p1, int * p2;
p1 = p2; //ok
p2 = p1; //error
p2 = (int *) p1; //ok,強制型別轉換

• 函式引數為常量指標時，可避免函式內部不小心改變引數指標所指地方的內容

void MyPrintf(const char * p)
{
      strcpy(p, "this"); //編譯出錯
      printf("%s", p); //ok
}

3. 定義常引用

（見一）

三、動態記憶體分配

1. 用new運算子實現動態記憶體分配

• 第一種用法，分配一個變數：

P = new T;

T是任意型別名，P是型別為**T * **的指標。

動態分配出一片大小為sizeof(T)位元組的記憶體空間，並且將該記憶體空間的起始地址賦值給P。比如：

int * pn;
pn = new int;
* pn = 5;

• 第二種用法，分配一個數組：

P = new T[N];

T：任意型別名

P：型別為**T * **的指標

N：要分配的陣列元素的個數，可以是整型表示式

動態分配出一片大小為sizeof(T) * N 位元組的記憶體空間，並且將該記憶體空間的起始地址賦值給P。

int * pn;
int i = 5;
pn = new int[i * 20];
pn[0] = 20;
pn[100] = 30;//編譯通過，但執行時導致陣列越界

2. 用delete運算子釋放動態分配的記憶體

• 用new動態分配的記憶體空間，一定要用delete運算子進行釋放

delete 指標; //該指標必須指向new出來的空間

int * p = new int;
* p = 5;
delete p;
delete p; //異常，一片空間不能被delete多次

• 用delete釋放動態分配的陣列，要加[]

delete [] 指標; //該指標必須指向new出來的陣列

int * p = new int[20];
p[0] = 1;
delete [ ] p;