---

1.C/C++申請、釋放堆空間的方式對比

1.1C語言申請、釋放堆空間

關于C語言的堆內存管理內存管理不熟悉可看以下章節
C語言精講-12
c語言中申請、釋放堆空間一般用malloc和free函數

#include<stdio.h>
#include<stdlib.h>void test(void)
{//申請內存int*p=(int*) malloc(sizeof(int));if(NULL==p){printf("內存申請失敗\n");exit(0) ;}*p=10;printf("*p=%d\n",*p);//釋放內存；free(p);p=NULL;}int main(void)
{test();return 0;}

1.2C++申請、釋放堆空間

c++申請、釋放堆空間一般用new/delete表達式；

#include<iostream>
using std::cout;
using std::endl;void test(void)
{//初始化為該類型的默認值int * p1 = new int();cout<<*p1<<endl;int *p2=new int(2);cout<<*p2<<endl;//釋放內存delete p1;delete p2;//將 p1 和 p2 置為 nullptr；避免野指針p1= nullptr;p2= nullptr;}int main(void)
{test();return 0;}

1.2.1 new表達式申請數組空間

1.默認初始化為0；

#include<iostream>
using std::cout;
using std::cin;
using std::endl;void test(void)
{//將動態分配的數組元素默認初始化為 0//申請10個int類型的堆空間int * p1 = new int[10]();for(int idx = 0; idx < 10; ++idx){p1[idx] = idx;}for(int idx = 0; idx < 10; ++idx){cout << p1[idx] << endl;}//釋放堆空間delete [] p1;p1=nullptr;}int main(void)
{       test();return 0;
}       
~                                       

2.賦初值

#include<iostream>
using std::cout;
using std::cin;
using std::endl;void test(void)
{       //申請3個int類型的堆空間int * p1 = new int[3]{2,4,6};for(int i=0;i<3;i++){cout<<p1[i]<<endl;}//釋放堆空間delete [] p1;p1=nullptr;}int main(void)
{       test();return 0;
}       
~                           

1.3回收空間時的注意事項

1.三組申請空間和回收空間的匹配組合

malloc            freenew               deletenew int[5]()      delete[]

2安全回收
delete只是回收了指針指向的空間，但這個指針變量依然還在，指向了不確定的內容（野指針），容易造成錯誤。所以需要進行安全回收，將這個指針設為空指針C++11之后使用nullptr表示空指針。

1.4malloc/free 和 new/delete 的區別

1.malloc/free 是庫函數；new/delete 是表達式，后兩者使用時不是函數的寫法；
2.new 表達式的返回值是相應類型的指針，malloc 返回值是 void*；
3.malloc 申請的空間不會進行初始化，獲取到的空間是有臟數據的，但 new 表達式申請空間時可以直接初始化；
4.malloc 的參數是字節數，new 表達式不需要傳遞字節數，會根據相應類型自動獲取空間大小。

2.引用

2.1 引用的概念

引用是c++對c的重要擴充。在c/c++中指針的作用基本都是一樣的，但是c++增加了另外一種給函數傳遞地址的途徑，這就是按引用傳遞
變量概述
1.變量名實質上是一段連續內存空間的別名，是一個標號(門牌號)
2.程序中通過變量來申請并命名內存空間
3.通過變量的名字可以使用存儲空間
c++中新增了引用的概念，引用可以作為一個已定義變量的別名。
基本語法:

Type& ref = val;
示例：
int number = 2；
int & ref = number;

#include<iostream>
using std::cout;
using std::cin;
using std::endl;int main(void)
{int sum=10;cout<<"sum="<<sum<<endl;int&s=sum;cout<<"s="<<s<<endl;s=100;cout<<"s="<<s<<endl<<"num="<<sum<<endl;return 0;
}

注意事項：
?&在此不是求地址運算，而是起標識作用。
?類型標識符是指目標變量的類型
?必須在聲明引用變量時進行初始化。
?引用初始化之后不能改變。
?不能有NULL引用。必須確保引用是和一塊合法的存儲單元關聯。

2.2 引用的本質

引用的本質在c++內部實現是一個常指針；c++編譯器在編譯過程中使用常指針作為引用的內部實現，因此引用所占用的空間大小與指針相同，只是這個過程是編譯器內部實現，用戶不可見。

#include<iostream>
using std::cout;
using std::cin;
using std::endl;void test(void)
{int sum=10;int &s=sum;int*p=&sum;cout<<"sum的地址："<<&sum<<endl;cout<<"s的地址："<<&s<<endl;cout<<"p所指向的地址："<<p<<endl;cout<<"size(p)="<<sizeof(p)<<endl;//指針p占多少字節cout<<"size(s)="<<sizeof(&s)<<endl;//引用&s占多數字節
}int main(void)
{test();return 0;
}

2.3 引用與指針的聯系與區別

聯系：

1. 引用和指針都有地址的概念，都是用來間接訪問變量；

2. 引用的底層還是指針來完成，可以把引用視為一個常指針。

區別：
4. 引用必須初始化，指針可以不初始化；
5. 引用不能修改綁定，但是指針可以修改指向；
6. 在代碼層面對引用本身取址取到的是變量本體的地址，但是對指針取址取到的是指針變量的地址

2.4 引用的使用場景

2.4.1 引用作為函數的參數

在沒有引用之前，如果我們想通過形參改變實參的值，只有使用指針才能到達目的。但使用指針的過程中，不好操作，很容易犯錯。 而引用既然可以作為其他變量的別人而存在，那在很多場合下就可以用引用代替指針，因而也具有更好的可讀性和實用性。這就是引用存在的意義。

#include<iostream>
using std::cout;
using std::cin;
using std::endl;//使用指針
void swap(int *a,int*b)
{int temp=*a;*a=*b;*b=temp;
}
//使用引用
void swap2(int&a,int&b)
{int temp=a;a=b;b=temp;
}void test1(void)
{int a=10,b=20;cout<<"交換前：a="<<a<<",b="<<b<<endl;swap(&a,&b);cout<<"交換后：a="<<a<<",b="<<b<<endl;swap2(a,b);cout<<"再次交換后：a="<<a<<"b="<<b<<endl;
}
int main(void)
{test1();return 0;
}

2.5 引用作為函數的返回值

當以引用作為函數的返回值時，返回的變量其生命周期一定是要大于函數的生命周期的，即當函數執行完畢時，返回的變量還存在。
目的： 避免復制，節省開銷

#include<iostream>
using std::cout;
using std::cin;
using std::endl;int fun1(void)
{int a=10;//返回的是a的副本，變量a是局部變量。在fun1函數結束時a的空間就被回收cout<<"fun a的地址："<<&a<<endl;return a;
}int& fun2(void)
{///使用指針/引用作為返回值時候，不可返回一個局部的變量；可加static修飾static int  b=100;//返回的是一個綁定b的的引用；cout<<"fun2 b的地址："<<&b<<endl;return b;
}int main(void)
{//把fun1中a的值復制給main函數中的變量a；int a=fun1();cout<<"main中a的地址："<<&a<<endl;int &b=fun2();cout<<"main 中引用b的地址："<<&b<<endl;return 0;
}

注意事項
1.不要返回局部變量的引用。因為局部變量會在函數返回后被銷毀，被返回的引用就成為了"無所指"的引用，程序會進入未知狀態。
2.不要輕易返回一個堆空間變量的引用，非常容易造成內存泄漏。

int & func()
{int * pint = new int(1);return *pint;
}void test()
{int a = 2, b = 4;int c = a + func() + b;//內存泄漏
}

2.6 總結

1. 在引用的使用中，單純給某個變量取個別名沒有什么意義，引用的目的主要用于在函數參數傳遞中，解決大塊數據或對象的傳遞效率和空間不理想的問題。
2. 用引用傳遞函數的參數，能保證參數傳遞中不產生副本，提高傳遞的效率，還可以通過const的使用，保證了引用傳遞的安全性。
3. 引用與指針的區別是，指針通過某個指針變量指向一個變量后，對它所指向的變量間接操作。程序中使用指針，程序的可讀性差；引用底層仍然是指針，但是編譯器不允許訪問到這個底層的指針，邏輯上簡單理解為——對引用的操作就是對目標變量的操作。可以用指針或引用解決的問題，更推薦使用引用

3.強制類型轉換

3.1 c語言里的強制類型轉換

格式：數據類型 變量1 = （數據類型）變量2；

#include<stdio.h>int main(void)
{       float a=3.14f;printf("a=%f\n",a);int b=(int)a;printf("b=%d\n",b);return 0;
}       

缺點：

1. 數據丟失風險高
   C 語言的強制類型轉換語法簡單，不過在將大類型轉換為小類型時，容易發生數據丟失。比如把long類型轉換為int類型，若long類型的值超出int類型的范圍，就會出現數據截斷。
2. 破壞類型系統且缺乏安全性檢查
   C 語言允許進行各種類型的強制轉換，像指針類型的轉換，這可能會破壞類型系統的安全性，編譯器也不會做嚴格的類型檢查。例如將void*指針轉換為其他類型的指針，若使用不當，就會引發未定義行為。
3. 掩蓋潛在錯誤
   C 語言的強制類型轉換可能會掩蓋代碼中的潛在錯誤，使代碼能通過編譯，但實際上邏輯可能存在問題。
4. 可移植性差
   不同平臺上數據類型的大小和表示方式可能不同，C 語言的強制類型轉換可能會導致在不同平臺上產生不同的結果，影響代碼的可移植性。

3.2 c++數據類型強制轉換

3.2.1 static_cast（常用）

最常用的類型轉換符，在正常狀況下的類型轉換, 用于將一種數據類型轉換成另一種數據類型，如把int轉換為float

目標類型 轉換后的變量 = static_cast<目標類型>(要轉換的變量)

好處：不允許非法的轉換發生；方便查找

int a = 100；
float f = 0；
f = (float) a；//C風格
f = static_cast<float>(a);

void * p1 = malloc(sizeof(int));
int * p2 = static_cast<int*>(p1);
*p2 = 1;

不能完成任意兩個指針類型間的轉換（限制一些非法轉換）

int a = 1;
int * p1 = &a;
float * p2 = static_cast<float *>(p1);//錯誤

總結，static_cast的用法主要有以下幾種：

1）用于基本數據類型之間的轉換，如把int轉換成char，把int轉換成enum。這種轉換的安全性需要開發人員來保證；
2）把void指針轉換成目標類型的指針，但不安全；
3）把任何類型的表達式轉換成void類型；
4）用于類層次結構中基類和子類之間指針或引用的轉換

3.2.3 const_cast （常不用）

該運算符用來修改類型的const屬性。
指向常量的指針被轉化成普通指針，并且仍然指向原來的對象；
常量引用被轉換成非常量引用，并且仍然指向原來的對象；

const int number = 100;
int * pInt = &number;//error
int * pInt2 = const_cast<int *>(&number);

3.2.3 其他（后面章節中應用到在講解）

dynamic_cast：該運算符主要用于基類和派生類間的轉換；
reinterpret_cast：功能強大，慎用（也稱為萬能轉換）；