前言：

💙本學習筆記參考B站視頻，在筆記里加了一些個人想法可能與原視頻講解內容有所差異，
因作者能力精力有限無法做到完美，若有不足和錯誤請大佬批評指正，

一、記憶體

1.1 記憶體四區

C++程式在執行時，將記憶體大致分為4個區域：代碼區，全域區，堆疊區，堆區

• 代碼區：存放函式體的的二進制代碼，作業系統管理，

🔵特點：①共享 ：對于頻繁被執行的程式，只需要在記憶體中有一份代碼即可，
②只讀：目的是防止程式意外地修改了它的指令，

• 全域區：存放全域變數、靜態變數和常量（除了const修飾的區域變數），程式結束時由作業系統釋放，

//全域變數
int g_a = 10;
const int c_g_a = 10;
int main()
{
	int l_a = 10;
	//靜態變數
	static int s_a = 10;
	
	//常量：字串常量/const修飾的變數（全域/區域變數）
	const char* a = "hello";
	const int c_l_a = 10;

	cout << "區域變數l_a的十進制地址為：" << (int)&l_a << endl;
	cout << "全域變數g_a的十進制地址為：" << (int)&g_a << endl;
	cout << "靜態變數s_a的十進制地址為：" << (int)&s_a << endl;
	cout << "字串常量a的十進制地址為：" << (int)a << endl;
	cout << "const修飾的全域變數c_g_a的十進制地址為：" << (int)&c_g_a << endl;
	cout << "const修飾的區域變數c_l_a的十進制地址為：" << (int)&c_l_a << endl;
	return 0;

}

• 堆疊區：存放函式的引數值、區域變數，由編譯器自動分配和釋放，

🔴注意：不要回傳區域變數的地址，

int* funcation()
{
	int a = 10;//存放在堆疊區，堆疊區的資料在函式執行完后自動釋放
	return &a;
}
int main()
{
	int* p = funcation();
	cout <<"區域變數a的值為："<< *p << endl;  //第一次正常列印，因為編譯器做了保留
	cout << "區域變數a的值為：" << *p << endl;
	return 0;
}

• 堆區：由程式員分配（new）和釋放（delete），若程式員不釋放，程式結束時由作業系統回收，

int* funcation()
{
	//new關鍵字，可以將資料開辟到堆區上
	//指標本質上也是區域變數，存放在堆疊區上，但是保存的資料在堆區
	int* p = new int(10);
	return p;
}
int main()
{
	int* p = funcation();
	cout << *p << endl;
	cout << *p << endl;
	return 0;
}

Tip：

• 程式運行前分為：代碼區，全域區
• 程式運行后分為：堆疊區,堆區

[注]： 關于記憶體更詳細的知識👉深度剖析資料在記憶體中的存盤👉幾分鐘讓你了解什么是函式堆疊幀的創建和銷毀

1.2 new運算子

//new的基本用法
int* p = new int(10);//在堆區創建整型變數，回傳該變數的地址
delete p;//釋放
int* parr = new int[10];//在堆區創建一個元素為10的整型陣列，回傳陣列首元素的地址
delete[] arr;//釋放一個陣列 

測驗delete

int* funcation()
{
	int* p = new int(10);
	return p;
}
int main()
{
	int* p = funcation();
	cout << *p << endl;
	cout << *p << endl;
	delete p;
	cout << *p << endl;
	return 0;
}

二、參考

2.1 參考基本使用和注意事項

作用：給變數起個別名，
語法：資料型別 & 別名=原名
本質：指標常量

//eg.
int a = 10;
int& b = a;

🔴注意：
①參考必須初始化，
②參考一旦初始化就不可以更改了（如下的例子相當于int *const b=&a），

	//①參考必須初始化
	int a = 10;
	int& b;//錯了！！！

	//②參考一旦初始化就不可以更改了
	int a = 10;
	int c = 20;
	int& b = a;
	int& b = c; //錯了！！！

2.2 參考做函式引數

//eg.
/*實作數值交換*/
//1.傳址交換
void swap1(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}
//2.參考
void swap2(int& a, int& b)//起別名可以和原名一樣
{
	int temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 10;
	int b = 20;
	swap1(&a, &b);
	swap2(a, b);
	return 0;
}

2.3 參考函式回傳值

🔴注意：
①不要回傳區域變數的參考，
②函式的呼叫可以作為左值，

//eg.
//①不要回傳區域變數的參考
int& test1()
{
	int a = 10;
	return a;
}
int main()
{
	int& ret = test1();
	cout << "ret=" << ret << endl;
	cout << "ret=" << ret << endl;
	test1() = 20; //②如果函式的回傳值為參考，函式的呼叫可以作為左值
	cout << "ret=" << ret << endl;
	cout << "ret=" << ret << endl;
	return 0;
}

2.3 常量參考

目的：用來修飾形參，防止誤操作，

int &ret=10; //錯了！，參考本身需要一個合法的記憶體空間，

/*
相當于編譯器先創建一個臨時變數:int temp=10;
然后進行起別名:int& ret=temp;
*/
const int& ret = 10;

🔴注意：用常量參考之后不可以更改資料，

//eg.
int main()
{
	const int& ret = 10;
	ret = 100;//err
	cout << "ret=" << ret << endl;
	return 0;
}

C++推薦參考，因為語法方便，編譯器幫我們做了指標的內容，

三、函式提高

3.1 函式默認引數

語法：回傳型別 函式名 （引數 =默認值） {}
用法：如果自己傳入資料就用自己的，如果沒有就用默認值，

int Add(int a = 0, int b = 0)
{
	return a + b;
}
int main()
{
	int a = 10;
	int b = 20;
	int c = Add(a, b);
	int e = Add(a);
	int f = Add(b);
	int g = Add();
	cout << "c=" << c << endl;
	cout << "e=" << e << endl;
	cout << "f=" << f << endl;
	cout << "g=" << g << endl;
	return 0;
}

🔴注意：

①默認值必須放在右邊，

int test(int a, int b = 10, int c);//err

②宣告和實作，有且只能有一個有默認引數，否則可能出現二義，

3.2 函式占位引數

語法：回傳型別 函式名 （資料型別） {}

//eg.
void test1(int a, int)
{
	cout << "haha" << endl;

}
void test2(int a, int b=10)//占位引數可以有默認引數
{
	cout << "haha" << endl;

}
int main()
{
	test1(1);//err
	test1(1, 1);
	test2(1);
	test2(1, 1);
	return 0;
}

3.3 函式多載

作用：函式名可以相同，提高復用率，
滿足條件：
①同一個作用域，
②函式名稱相同，
③引數型別不同/個數不同/順序不同，

//eg.
void test()
{
	cout << "呼叫test( )" << endl;
}
void test(int a) 
{
	cout << "呼叫test(int a)" << endl;
}
void test(double a)
{
	cout << "呼叫test(double a)" << endl;
}
void test(int a, int b)
{
	cout << "呼叫test(int a, int b)" << endl;
}
void test(int a, double b)
{
	cout << "呼叫test(int a, double b)" << endl;
}
void test(double a, int b)
{
	cout << "呼叫test(double a, int b)" << endl;
}
int main()
{
	test();
	test(1);
	test(3.14);
	test(1,3.14);
	test(3.14, 1);
	return 0;
}

🔴注意：