一、入門語法知識(shí)

1.預(yù)備

1.1 main函數(shù)

任何c++程序都有的 main。

#include<iostream>
using namespace std;
int main() {cout << "hello world" << endl;system("pause");return 0;
}

1.2 注釋

// 單行注釋
//cout << "hello world" << endl;
// 多行注釋
/*cout << "hello world" << endl;cout << "hello world" << endl;
*/

1.3 變量

變量的作用：給內(nèi)存起個(gè)名字，方便操作這塊內(nèi)存。

數(shù)據(jù)類型 變量名稱 = 變量初始值;

int a = 10;

1.3 常量

常量的作用：用于記錄程序中不可更改的數(shù)據(jù)。

// 1.第一種#define 宏常量
#define Day 7
// 2.第二種const 修飾一個(gè)變量
const int a = 10;

1.4 關(guān)鍵字

關(guān)鍵字的作用：c++中預(yù)先保留的單詞（標(biāo)識(shí)符），定義變量、常量名時(shí)不能再使用。
比如：int、double、bool、long、sizeof…

1.5 標(biāo)識(shí)符明明規(guī)則

1、 標(biāo)識(shí)符不能為關(guān)鍵字；
2、 標(biāo)識(shí)符只能是字母、數(shù)字、下劃線；
3、 第1個(gè)標(biāo)識(shí)符必須只能字母或下劃線；
4、標(biāo)識(shí)符字母區(qū)分大小寫。
建議：盡量做到“見名知意”。

int num1 = 10;
int num2 = 20;
int sum = num1 + num2;
cout << "和為：" << sum << endl;

2. 數(shù)據(jù)類型

2.1 整型

C++規(guī)定在創(chuàng)建一個(gè)變量或者常量時(shí)，必須要指定出相應(yīng)的數(shù)據(jù)類型，否則無法給變量分配合適的內(nèi)存。
比如，int a = 10;在內(nèi)存中找一個(gè)空間存放數(shù)據(jù)10，并且給這塊內(nèi)存空間命名為a，想要操縱管理這個(gè)空間，用a就行。
那數(shù)據(jù)類型存在的意義？
存放一個(gè)數(shù)據(jù)10，可以用小內(nèi)存，或者更大的內(nèi)存空間存放，而加上數(shù)據(jù)類型，就不會(huì)造成下圖的內(nèi)存空間浪費(fèi)。

除了int，還有別的常用的整型，區(qū)別在于占用的內(nèi)存空間不同。

2.1.1 sizeof關(guān)鍵字

作用：利用sizeof關(guān)鍵字可以統(tǒng)計(jì)數(shù)據(jù)類型所占內(nèi)存大小。

#include<iostream>
using namespace std;
int main(){cout << "short 類型所占內(nèi)存空間：" << sizeof(short) << endl;cout << "int 類型所占內(nèi)存空間：" << sizeof(int) << endl;cout << "long 類型所占內(nèi)存空間：" << sizeof(long) << endl;cout << "long long 類型所占內(nèi)存空間：" << sizeof(long long) << endl;system("pause");return 0;
}

整型結(jié)論：short<int<= long<= long long（區(qū)分操作系統(tǒng)）

2.2 實(shí)型（浮點(diǎn)型）

作用：用于表示小數(shù)
浮點(diǎn)型變量分為：
1.單精度float；
2.雙精度double。

float f1 = 3.14f;
double d1 = 3.14;
// 4
cout << "float所占內(nèi)存空間" << sizeof(float) << endl;
// 8
cout << "double所占內(nèi)存空間" << sizeof(double) << endl;
// 科學(xué)計(jì)數(shù)法
float f2 = 3e2; // 3 * 10 ~ 2
float f3 = 3e-2; // 3 * 0.1 ~ 2

2.3 字符型

語法 ：char ch = ‘a(chǎn)’;

注意1:在顯示字符型變量時(shí)，用單引號(hào)將字符括起來，不要用雙引號(hào)；
注意2:單引號(hào)內(nèi)只能有一個(gè)字符，不可以是字符串。
結(jié)論：
1.c和c++中字符型只占1個(gè)字節(jié)的內(nèi)存空間；
2.字符型變量并不是把字符本身放到內(nèi)存中存儲(chǔ)，而是將對(duì)應(yīng)的ASCIl編碼放入
到存儲(chǔ)單元。

2.4 轉(zhuǎn)義字符

作用：用于顯示一些不能顯示出來的ASCII字符。

2.5 字符串型

作用：用于表示一串字符
兩種風(fēng)格：
1.C風(fēng)格字符串：char 變量名[] = “字符串值”

char str1[] = "hello world";

2.C++風(fēng)格字符串：string 變量名 = “字符串值”

#include<string>  // 使用c++風(fēng)格時(shí)，需要包含這個(gè)頭文件。string str1 = "hello world";

2.6 布爾類型bool

作用：用于表示真或假
布爾類型bool只占1個(gè)字節(jié)的內(nèi)存空間；

bool flag = true;
cout << flag << endl; // 輸出為1

2.7 數(shù)據(jù)的輸入

作用：用于從鍵盤獲取數(shù)據(jù)
關(guān)鍵字：cin
語法：cin >> 變量

int a = 0;
cout << "請(qǐng)輸入數(shù)據(jù)：" << endl;
cin >> a;
cout << "輸入數(shù)據(jù)為：" << a << endl;

3. 運(yùn)算符

作用：用于執(zhí)行代碼的運(yùn)算

3.1 算數(shù)運(yùn)算符

作用：用于處理四則運(yùn)算
結(jié)論：
1.兩數(shù)相除（取模），除數(shù)不可以為0；
2.只有整型變量之間可以做取余運(yùn)算；
3.++a，前置遞增先讓變量+1，然后進(jìn)行表達(dá)式運(yùn)算
4.a++，后置遞增先進(jìn)行表達(dá)式運(yùn)算，后讓變量+1

int a1 = 10;
int a2 = 3;
cout << a1 / a2 << endl; // 輸出結(jié)果為3，取決于a1和a2的數(shù)據(jù)類型
float b1 = 0.55;
float b2 = 0.22;
cout << b1 / b2 << endl; // 輸出結(jié)果為小數(shù)，取決于b1和b2的數(shù)據(jù)類型int a1 = 10;

3.2 賦值運(yùn)算符

作用：用于將表達(dá)式的值賦值給變量

3.3 比較運(yùn)算符

作用：用于表達(dá)式的比較，返回一個(gè)真值或假值

3.4 邏輯運(yùn)算符

作用：用于根據(jù)表達(dá)式的值返回真值或假值

4. 程序流程結(jié)構(gòu)

作用：用于執(zhí)行代碼的運(yùn)算
C/C++支持最基本的三種程序運(yùn)行結(jié)構(gòu):
順序結(jié)構(gòu)、選擇結(jié)構(gòu)、循環(huán)結(jié)構(gòu)
1.順序結(jié)構(gòu)：程序按順序執(zhí)行，不發(fā)生跳轉(zhuǎn)；
2.選擇結(jié)構(gòu)：依據(jù)條件是否滿足，有選擇的執(zhí)行相應(yīng)功能；
3.循環(huán)結(jié)構(gòu)：依據(jù)條件是否滿足，循環(huán)多次執(zhí)行某段代碼；

4.1 選擇結(jié)構(gòu)

4.1.1 if語句

作用：執(zhí)行滿足條件的語句
if語句的三種形式：
1.單行格式if語句

int score = 70;
if (score > 60) //注意事項(xiàng)，if條件后面不要加分號(hào)
{cout << "分?jǐn)?shù)及格" << endl;
}

2.多行格式if語句

int score = 70;
if (score > 60)  //注意事項(xiàng)，if條件后面不要加分號(hào)
{cout << "分?jǐn)?shù)及格" << endl;
}
else
{cout << "分?jǐn)?shù)不及格" << endl;
}

3.多條件的if語句

int score = 70;
if (score > 90)  //注意事項(xiàng)，if條件后面不要加分號(hào)
{cout << "分?jǐn)?shù)優(yōu)秀" << endl;
}
else if (score > 80)
{cout << "分?jǐn)?shù)良好" << endl;
}
else
{cout << "分?jǐn)?shù)及格" << endl;
}

4.多嵌套if語句
在if語句中，可以嵌套使用if語句，達(dá)到更精確的條件判斷

int score = 70;
if (score > 90)  //注意事項(xiàng)，if條件后面不要加分號(hào)
{cout << "分?jǐn)?shù)優(yōu)秀" << endl;// 嵌套if語句if (score > 95){cout << "分?jǐn)?shù)特別優(yōu)秀" << endl;}
}
else if (score > 80)
{cout << "分?jǐn)?shù)良好" << endl;
}
else
{cout << "分?jǐn)?shù)及格" << endl;
}

4.1.2 三目運(yùn)算符

作用：通過三目運(yùn)算符實(shí)現(xiàn)簡(jiǎn)單的判斷
語法：表達(dá)式1 ? 表達(dá)式2 : 表達(dá)式3
解釋:
如果表達(dá)式1的值為真，執(zhí)行表達(dá)式2，并返回表達(dá)式2的結(jié)果；
如果表達(dá)式1的值為假，執(zhí)行表達(dá)式3，并返回表達(dá)式3的結(jié)果。

int a = 10;
int b = 20;
int c = 0;
c = (a > b ? a : b);
cout << c << endl;
// 在C++中三目運(yùn)算符返回的是變量，可以繼續(xù)賦值
(a > b ? a : b) = 30;

4.1.3 switch語句

作用：執(zhí)行多條件分支語句

語法：

switch (表達(dá)式){case 結(jié)果1: 執(zhí)行語句; break;case 結(jié)果2: 執(zhí)行語句; break;......default: 執(zhí)行語句; break;}

示例：

int score = 90;
switch (score)
{
case 90:cout << "成績(jī)優(yōu)秀" << endl;break; // 退出當(dāng)前分支
case 80:cout << "成績(jī)良好" << endl;break; // 退出當(dāng)前分支
case 70:cout << "成績(jī)及格" << endl;break; // 退出當(dāng)前分支
default:cout << "成績(jī)不及格" << endl;break;}

if和 switch 區(qū)別？
switch缺點(diǎn)：判斷時(shí)候只能是整型或者字符型，不可以是一個(gè)區(qū)間
switch優(yōu)點(diǎn)：結(jié)構(gòu)清晰，執(zhí)行效率高

4.2 循環(huán)結(jié)構(gòu)

4.2.1 while語句

作用：滿足循環(huán)條件，執(zhí)行循環(huán)語句
語法：while(循環(huán)條件){循環(huán)語句}
解釋：只要循環(huán)條件的結(jié)果為真，就執(zhí)行循環(huán)語句

int num = 0;
while (num < 10)
{cout << num << endl;num++;
}

注意事項(xiàng)：在寫循環(huán)一定要避免死循環(huán)的出現(xiàn)

4.2.2 do while語句

作用：滿足循環(huán)條件，執(zhí)行循環(huán)語句；
語法：do{循環(huán)語句 } while(循環(huán)條件)；
注意：與while的區(qū)別在于do…while會(huì)先執(zhí)行一次循環(huán)語句，再判斷循環(huán)條件

int num = 0;
do
{cout << num << endl;num++;
} while (num < 10);

4.2.3 for循環(huán)語句

作用：滿足循環(huán)條件，執(zhí)行循環(huán)語句；
語法：for(起始表達(dá)式;條件表達(dá)式;末尾循環(huán)體){循環(huán)語句;}；

for (int i = 0; i < 10; i++){cout << i << endl;}

4.2.4 嵌套循環(huán)

作用：在循環(huán)體中再嵌套—層循環(huán),解決—些實(shí)際問題

// 外層循環(huán)執(zhí)行一次
for (int i = 0; i < 10; i++)
{// 內(nèi)層循環(huán)執(zhí)行一周for (int j = 0; j < 10; j++){cout << "* ";}cout << endl;
}

4.3 跳轉(zhuǎn)結(jié)構(gòu)

4.3.1 break語句

作用：用于跳出選擇結(jié)構(gòu)或者循環(huán)結(jié)構(gòu)
break使用的時(shí)機(jī):
1.出現(xiàn)在switch條件語句中，作用是終止case并跳出switch
2.出現(xiàn)在循環(huán)語句中，作用是跳出當(dāng)前的循環(huán)語句
3.出現(xiàn)在嵌套循環(huán)中，跳出最近的內(nèi)層循環(huán)語句

4.3.2 continue語句

作用：在循環(huán)語句中，跳過本次循環(huán)中余下尚未執(zhí)行的語句，繼續(xù)執(zhí)行下一次循環(huán)

4.3.3 go to語句

作用：可以無條件跳轉(zhuǎn)語句；
語法：goto標(biāo)記；
解釋：如果標(biāo)記的名稱存在，執(zhí)行到goto語句時(shí)，會(huì)跳轉(zhuǎn)到標(biāo)記的位置

cout << "1" << endl;
cout << "2" << endl;
goto FLAG;
cout << "3" << endl;
cout << "4" << endl;
FLAG:
cout << "5" << endl;

注意：在程序中不建議使用goto語句，以免造成程序流程混亂

5. 數(shù)組

5.1 概述

所謂數(shù)組，就是—個(gè)集合，里面存放了“相同類型”的數(shù)據(jù)元素
特點(diǎn)1:數(shù)組中的每個(gè)數(shù)據(jù)元素都是相同的數(shù)據(jù)類型
特點(diǎn)2:數(shù)組是由連續(xù)的內(nèi)存位置組成的
好比，一個(gè)盒子放著同樣的電池。

5.2 一維數(shù)組

5.2.1 一維數(shù)組定義方式

—維數(shù)組定義的三種方式:
1.數(shù)據(jù)類型 數(shù)組名[數(shù)組長(zhǎng)度]；
2.數(shù)據(jù)類型 數(shù)組名[數(shù)組長(zhǎng)度] = { 值1，值2 …]；
3.數(shù)據(jù)類型 數(shù)組名[ ] ={ 值1，值2 …}；
數(shù)組特點(diǎn)：
1.放在一塊連續(xù)的內(nèi)存空間中
2.數(shù)組中每個(gè)元素都是相同數(shù)據(jù)類型

// 定義方式1
int	score[10];
// 定義方式2
// 如果{}內(nèi)不足10個(gè)數(shù)據(jù)，剩余數(shù)據(jù)用0補(bǔ)全
int	score[10] = {10, 20, 30, 40};
// 定義方式3
// 如果{}有了初始長(zhǎng)度，[]內(nèi)也可以不用顯式化數(shù)組長(zhǎng)度
int	score[] = { 10, 20, 30, 40 };

總結(jié)1：數(shù)組名的命名規(guī)范與變量名命名規(guī)范—致，不要和變量重名；
總結(jié)2：數(shù)組中下標(biāo)是從0開始索引。

5.2.2 一維數(shù)組數(shù)組名

一維數(shù)組名稱的用途:
1.可以統(tǒng)計(jì)整個(gè)數(shù)組在內(nèi)存中的長(zhǎng)度；
2.可以獲取數(shù)組在內(nèi)存中的首地址。

// 1.可以通過數(shù)組名統(tǒng)計(jì)整個(gè)數(shù)組占用內(nèi)存大小
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "整個(gè)數(shù)組占用的內(nèi)存空間為：" << sizeof(arr) << endl;
cout << "每個(gè)元素占用的內(nèi)存空間為：" << sizeof(arr[0]) << endl;
cout << "數(shù)組中元素的個(gè)數(shù)為：" << sizeof(arr) / sizeof(arr[0]) << endl;
// 2.可以通過數(shù)組名查看數(shù)組首地址，加(int)將16進(jìn)制地址強(qiáng)轉(zhuǎn)成10進(jìn)制數(shù)
cout << "數(shù)組首地址為：" << (int)arr<< endl;
cout << "數(shù)組中第一個(gè)元素的地址為：" << (int)&(arr[0])<< endl;
// 數(shù)組中存放的是整型，每個(gè)整型占用4個(gè)字節(jié)，所以每個(gè)元素地址差4
cout << "數(shù)組中第二個(gè)元素的地址為：" << (int)&(arr[1])<< endl;
// 數(shù)組名是常量，它已經(jīng)指向了首地址，不可以進(jìn)行賦值操作
// arr = 100;

示例，實(shí)現(xiàn)一個(gè)一維數(shù)組的逆置

// 1.創(chuàng)建數(shù)組
int arr[5] = { 1,3,2,5,4 };
cout << "數(shù)組逆置前：" << endl;
for (int i = 0; i < 5; i++)
{cout << arr[i] << endl;
}
// 2、實(shí)現(xiàn)逆置
// 2.1記錄起始下標(biāo)位置
int start = 0;
// 2.2記錄結(jié)束下標(biāo)位置
int end = sizeof(arr) / sizeof(arr[0]) - 1;
// 2.3起始下標(biāo)與結(jié)束下標(biāo)的元素互換
// 2.4起始位置++ 結(jié)束位置--
// 2.5循環(huán)執(zhí)行2.1操作，直到起始位置>=結(jié)束位置
while (start < end)
{int temp = arr[start];arr[start] = arr[end];arr[end] = temp;start++;end--;}
cout << "數(shù)組逆置后：" << endl;
for (int i = 0; i < 5; i++)
{cout << arr[i] << endl;
}

5.2.3 冒泡排序

作用：最常用的排序算法，對(duì)數(shù)組內(nèi)元素進(jìn)行排序
1.比較相鄰的元素。如果第一個(gè)比第二個(gè)大，就交換他們兩個(gè)。
2.對(duì)每一對(duì)相鄰元素做同樣的工作，執(zhí)行完畢后，找到第一個(gè)最大值。
3.重復(fù)以上的步驟，每次比較次數(shù)-1，直到不需要比較
首先看比幾輪，每1輪比幾次，比如第1輪， 就比8次；
其實(shí)第1輪的作用就是，兩兩比較，直到選到最大的數(shù)放在最后位置；
第2輪時(shí)候，因?yàn)榈?輪已經(jīng)找到最大數(shù)，所以比較次數(shù)-1，其作用就是第2大的數(shù)放在倒數(shù)第2位置。

int arr[9] = { 4,2,8,0,5,7,1,3,9 };
int arr_num = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < arr_num - 1; i++)
{for (int j = 0; j < arr_num - i - 1; j++){if (arr[j] > arr[j + 1]){int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}
}
cout << "排序后的結(jié)果：" << endl;
for (int i = 0; i < arr_num; i++)
{cout << arr[i] << endl;
}

5.3 二維數(shù)組

二維數(shù)組就是在一維數(shù)組上，多加一個(gè)維度。通常以矩陣的形式進(jìn)行體現(xiàn)。

5.3.1 二維數(shù)組定義方式

二維數(shù)組定義的四種方式:
1.數(shù)據(jù)類型 數(shù)組名[行數(shù)] [列數(shù)]；
2.數(shù)據(jù)類型 數(shù)組名[行數(shù)] [列數(shù)] = { (值1，值2), (值3，值4) …]；
3.數(shù)據(jù)類型 數(shù)組名[行數(shù)] [列數(shù)] ={ 值1,值2, 值3,值4…}；
4.數(shù)據(jù)類型 數(shù)組名[ ] [列數(shù)] ={ 值1,值2, 值3,值4…}；
建議：以上4種定義方式，利用第二種更加直觀，提高代碼的可讀性

// 1.數(shù)據(jù)類型 數(shù)組名[行數(shù)] [列數(shù)]；
int arr1[2][3];
// 2.數(shù)據(jù)類型 數(shù)組名[行數(shù)] [列數(shù)] = { (值1，值2), (值3，值4) ...]；
int arr2[2][3] =
{{1,2,3},{4,5,6}
};
// 3.數(shù)據(jù)類型 數(shù)組名[行數(shù)] [列數(shù)]  ={ 值1,值2,值3,值4...}；
int arr3[2][3] = { 1,2,3,4,5,6 };
// 4.數(shù)據(jù)類型 數(shù)組名[ ] [列數(shù)]  ={ 值1,值2,值3,值4...}；
int arr4[][3] = { 1,2,3,4,5,6 };

總結(jié)：在定義二維數(shù)組時(shí)，如果初始化了數(shù)據(jù)，可以省略行數(shù)

5.3.2 二維數(shù)組數(shù)組名

作用：
1.查看二維數(shù)組所占內(nèi)存空間
2.獲取二維數(shù)組首地址

int arr[2][3] ={{1,2,3},{4,5,6}};
// 1.查看二維數(shù)組所占內(nèi)存空間
cout << "二維數(shù)組所占內(nèi)存空間為：" << sizeof(arr) << endl;
cout << "二維數(shù)組第一行所占內(nèi)存空間為：" << sizeof(arr[0]) << endl;
cout << "二維數(shù)組第1個(gè)元素所占內(nèi)存空間為：" << sizeof(arr[0][0]) << endl;
cout << "二維數(shù)組行數(shù)為：" << sizeof(arr) / sizeof(arr[0]) << endl;
cout << "二維數(shù)組列數(shù)為：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
// 2.獲取二維數(shù)組首地址
cout << "二維數(shù)組首地址為：" << (int)arr << endl;
cout << "二維數(shù)組第1行首地址為：" << (int)arr[0] << endl;
// 第1行和第2行首地址差了12， 3x4
cout << "二維數(shù)組第2行首地址為：" << (int)arr[1] << endl;
// 第1個(gè)和第2個(gè)元素首地址差了4
cout << "二維數(shù)組第1個(gè)元素首地址為：" << (int)&arr[0][0] << endl;
cout << "二維數(shù)組第2個(gè)元素首地址為：" << (int)&arr[0][1] << endl;

6. 函數(shù)

6.1 概述

作用：將一段經(jīng)常使用的代碼封裝起來，減少重復(fù)代碼
一個(gè)較大的程序，一般分為若干個(gè)程序塊，每個(gè)模塊實(shí)現(xiàn)特定的功能。

6.2 函數(shù)的定義

函數(shù)的定義一般主要有5個(gè)步驟：
1、返回值類型
2、函數(shù)名
3、參數(shù)表列
4、函數(shù)體語句
5、return表達(dá)式

// 函數(shù)定義的時(shí)候，num1和num2并沒有真實(shí)數(shù)據(jù)，他只是一個(gè)形式上的參數(shù)，簡(jiǎn)稱形參
int add(int num1, int num2)
{int sum = num1 + num2;return sum;
}

6.3 函數(shù)的調(diào)用

功能：使用定義好的函數(shù)
語法：函數(shù)名（參數(shù))

int a = 10;
int b = 10;
// a和b稱為實(shí)際參數(shù)，簡(jiǎn)稱實(shí)參
// 當(dāng)調(diào)用函數(shù)時(shí)候，實(shí)參的值會(huì)傳遞給形參
int sum = add(a, b);

6.4 值傳遞

1.所謂值傳遞，就是函數(shù)調(diào)用時(shí)實(shí)參將數(shù)值傳入給形參
2.值傳遞時(shí)，如果形參發(fā)生，并不會(huì)影響實(shí)參

6.5 函數(shù)的常見樣式

1.無參無返
2.有參無返
3.無參有返
4.有參有返

6.6 函數(shù)的申明

作用：告訴編譯器函數(shù)名稱及如何調(diào)用函數(shù)。函數(shù)的實(shí)際主體可以單獨(dú)定義。
注意：函數(shù)的聲明可以多次，但是函數(shù)的定義只能有—次。

#include<iostream>
using namespace std;
// 提前告訴編譯器函數(shù)的存在，可以利用函數(shù)的聲明
int max(int a, int b);
// 聲明可以多次，但是函數(shù)的定義只能有—次。
int max(int a, int b);
int main()
{system("pause");return 0;
}
int max(int a, int b)
{return a > b ? a : b;
}

6.7 函數(shù)的分文件編寫

作用：讓代碼結(jié)構(gòu)更加清晰
函數(shù)分文件編寫一般有4個(gè)步驟：
1.創(chuàng)建后綴名為.h的頭文件

2.創(chuàng)建后綴名為.cpp的源文件

3.在頭文件中寫函數(shù)的聲明

#include<iostream>
using namespace std;
void swap(int a, int b);

4.在源文件中寫函數(shù)的定義

#include"swap.h"
void swap(int a, int b)
{int temp = a;a = b;b = temp;cout << "a=" << a << endl;cout << "b=" << b << endl;
}

主函數(shù)中進(jìn)行調(diào)用

#include<iostream>
using namespace std;
#include"swap.h"
int main()
{int a = 10;int b = 20;swap(a, b);system("pause");return 0;
}

7. 指針

7.1 指針的基本概念

作用：可以通過指針間接訪問內(nèi)存
1.內(nèi)存編號(hào)是從0開始記錄的，一般用“十六進(jìn)制數(shù)字”麥?zhǔn)?br /> 2.可以利用指針變量保存地址

7.2 指針變量的定義和使用

指針變量定義語法：數(shù)據(jù)類型 * 變量名

// 1、定義指針，語法： 數(shù)據(jù)類型 * 變量名；
int a = 10;
int* p; 
// 讓指針記錄變量a的地址
p = &a;
cout << "a的地址為：" << &a << endl;
cout << "指針p為：" << p << endl;
// 2、使用指針
// 可以通過解引用的方式來找到指針指向的內(nèi)存
// 指針前加 * 
*p = 1000;
cout << "a=" << a << endl;
cout << "*p=" << *p << endl;

7.3 指針?biāo)純?nèi)存空間

提問：指針也是種數(shù)據(jù)類型，那么這種數(shù)據(jù)類型占用多少內(nèi)存空間?

// 1、定義指針，語法： 數(shù)據(jù)類型 * 變量名；
int a = 10;
int* p = &a;  // 讓指針記錄變量a的地址// 在32位操作系統(tǒng)下，指針是占4個(gè)字節(jié)空間大小，不管是什么數(shù)據(jù)類型
// 在64位操作系統(tǒng)下，指針是占8個(gè)字節(jié)空間大小，不管是什么數(shù)據(jù)類型
cout << "int*所占內(nèi)存空間為：" << sizeof(int*) << endl;
cout << "int*所占內(nèi)存空間為：" << sizeof(p) << endl;
cout << "float*所占內(nèi)存空間為：" << sizeof(float*) << endl;cout << "double*所占內(nèi)存空間為：" << sizeof(double*) << endl;cout << "char* 所占內(nèi)存空間為：" << sizeof(char*) << endl;

7.4 空指針和野指針

7.4.1 空指針

空指針：指針變量指向內(nèi)存中編號(hào)為0的空間

用途：初始化指針變量
注意：空指針指向的內(nèi)存是不可以訪問的

//空指針
// 1.初始化指針變量
int* p = NULL;
// 2.空指針指向的內(nèi)存是不可以訪問的
// 0-255之間的內(nèi)存編號(hào)是系統(tǒng)占用的，因此不可以訪問
//*p = 100;

7.4.2 野指針

野指針：指針變量指向非法的內(nèi)存空間

// 野指針
// 1.初始化指針變量
// 0x1100這個(gè)內(nèi)存空間并不我們是申請(qǐng)的，沒有權(quán)利操縱這塊內(nèi)存
// 在程序中，盡量避免出現(xiàn)野指針
int* p = (int*)0x1100;
cout << *p << endl;

總結(jié)：空指針和野指針都不是我們申請(qǐng)的空間，因此不要訪問。

7.5 const修飾指針

const修飾指針有三種情況;

7.5.1 常量指針

const修飾指針—常量指針
記憶技巧：const修飾的是int *，所以 * 的操縱就不能了。

// 1.const修飾指針  常量指針
int a = 10;
int b = 10;
const int* p = &a;
// 指針指向的值不可以改，指針的指向可以改
// *p = 20;
p = &b;

7.5.2 指針常量

const修飾常量—指針常量
記憶技巧：const修飾的是指針p，所以指針p就不能操縱了。

// 2.const修飾常量  指針常量
int* const p2 = &a;
// 指針指向不可以改，指針指向的值可以改
*p2 = 2;
// p2 = &b;

7.5.3 既修飾指針，又修飾常量

cons既修飾指針，又修飾常量

// 3.const既修飾指針，又修飾常量  
const int* const p3 = &a;
// *p3 = 20;
// p3 = &b;

總結(jié)：看const右側(cè)緊跟著的是指針還是常量,是指針就是常量指針，是常量就是指針常量。

7.6 指針和數(shù)組

作用：利用指針訪問數(shù)組中元素。

// 指針和數(shù)組
// 利用指針訪問數(shù)組中的元素
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "數(shù)組種第一個(gè)元素為:" << arr[0] << endl;  //普通下標(biāo)訪問
int* p = arr; // 數(shù)組名就是數(shù)組的首地址 
// 當(dāng)使用指針指向數(shù)組首地址時(shí)，也可以通過p[0]這樣下標(biāo)的形式進(jìn)行元素的訪問。
cout << "利用指針訪問的第一個(gè)元素為：" <<* p << endl;
p++; //將指針向后偏移4個(gè)字節(jié)
cout << "利用指針訪問的第二個(gè)元素為：" << *p << endl;// 利用循環(huán)
int* p2 = arr;
for (int i = 0; i < 10; i++)
{cout << *p2 << endl;p2++;
}

7.7 指針和函數(shù)

作用：利用指針作函數(shù)參數(shù)，可以修改實(shí)參的值。

// 指針和函數(shù)
int a = 10;
int b = 20;
// 1.值傳遞
// 值傳遞不會(huì)改變實(shí)參
swap(a, b);
cout << "a=" << a << endl;
cout << "b=" << b << endl;
// 2.地址傳遞
// 如果是地址傳遞,可以修飾實(shí)參
swap02(&a, &b);
cout << "a=" << a << endl;
cout << "b=" << b << endl;

總結(jié)：如果不想修改實(shí)參，就用值傳遞，如果想修改實(shí)參，就用地址傳遞

7.8 指針、數(shù)組、函數(shù)的綜合案例

案例：封裝一個(gè)函數(shù)，利用冒泡排序，實(shí)現(xiàn)對(duì)整型數(shù)組的升序排

#include<iostream>
using namespace std;// 冒泡排序函數(shù)  參數(shù)1：數(shù)組的首地址   參數(shù)2：數(shù)組長(zhǎng)度
void bubbleSort(int* arr, int len)
{for (int i = 0; i < len - 1; i++){for (int j = 0; j < len - i -1; j++){// 如果j > j+1 的值，就進(jìn)行交換// 當(dāng)使用指針指向數(shù)組首地址時(shí)，也可以通過p[0]這樣下標(biāo)的形式進(jìn)行元素的訪問。if (arr[j] > arr[j+1]){int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}
}
int main()
{// 1.創(chuàng)建數(shù)組int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };// 數(shù)組長(zhǎng)度int len = sizeof(arr) / sizeof(arr[0]);// 2.創(chuàng)建函數(shù)，實(shí)現(xiàn)冒泡排序bubbleSort(arr, len); //一般，我們函數(shù)傳數(shù)組，會(huì)連著數(shù)組的長(zhǎng)度一起傳// 3.打印結(jié)果for (int i = 0; i < len; i++){cout << arr[i] << endl;}system("pause");return 0;
}

8.結(jié)構(gòu)體

8.1 結(jié)構(gòu)體的基本概念

結(jié)構(gòu)體屬于用戶自定義的數(shù)據(jù)類型，允許用戶存儲(chǔ)不同的數(shù)據(jù)類型

8.2 結(jié)構(gòu)體定義和使用

語法：struct結(jié)構(gòu)體名{結(jié)構(gòu)體成員列表};
通過結(jié)構(gòu)體創(chuàng)建變量的方式有三種：
1.struct 結(jié)構(gòu)體名 變量名
2.struct 結(jié)構(gòu)體名 變量名 = {成員1值，成員2值…}
3.定義結(jié)構(gòu)體時(shí)順便創(chuàng)建變量

#include<iostream>
using namespace std;
#include<string>
// 1.創(chuàng)建學(xué)生數(shù)據(jù)類型（3個(gè)屬性）
// 自定義數(shù)據(jù)類型，其實(shí)就是一些內(nèi)置數(shù)據(jù)類型的集合
struct Student  
{// 成員列表string name; //姓名int age; //年齡int score; //分?jǐn)?shù)
}s3; //順便創(chuàng)建結(jié)構(gòu)體變量s3int main()
{// 2.通過學(xué)生數(shù)據(jù)類型創(chuàng)建具體學(xué)生// 2.1 struct Student s1;// Student s1;  struct關(guān)鍵字可以省略// 給屬性進(jìn)行賦值s1.name = "張三";s1.age = 18;s1.score = 100;// 2.2 struct Student s2 = { ...}struct Student s2 = { "李四", 19, 80 };// 2.3 在定義結(jié)構(gòu)體時(shí)順便創(chuàng)建結(jié)構(gòu)體變量s3.name = "王五";s3.age = 20;s3.score = 60;system("pause");return 0;
}

總結(jié)1：定義結(jié)構(gòu)體時(shí)的關(guān)鍵字是struct，不可省略
總結(jié)2：創(chuàng)建結(jié)構(gòu)體變量時(shí)，關(guān)鍵字struct可以省略
總結(jié)3：結(jié)構(gòu)體變量利用操作符"."訪問成員

8.3 結(jié)構(gòu)體數(shù)組

作用：將自定義的結(jié)構(gòu)體放入到數(shù)組中方便維護(hù)
語法：struct 結(jié)構(gòu)體名 數(shù)組名[元素個(gè)數(shù)] = { {} ， {}， … {}}

#include<iostream>
using namespace std;
#include<string>// 結(jié)構(gòu)體數(shù)組
// 1.定義結(jié)構(gòu)體數(shù)組
struct Student
{string name; // 姓名int age; // 年齡int score; // 分?jǐn)?shù)
}; 
int main()
{// 2.創(chuàng)建結(jié)構(gòu)體數(shù)組并賦值struct Student stuArray[3] ={{"張三", 18, 100},{"李四", 28, 99},{"王五", 38, 95},};// 3.修改結(jié)構(gòu)體數(shù)組中的值stuArray[2].name = "哈哈";// 4.遍歷結(jié)構(gòu)體數(shù)組for (int i = 0; i < 3; i++){cout << "姓名：" << stuArray[i].name << endl;cout << "年齡：" << stuArray[i].age << endl;cout << "分?jǐn)?shù)：" << stuArray[i].score << endl;}system("pause");return 0;
}

8.4 結(jié)構(gòu)體指針

作用：通過指針訪問結(jié)構(gòu)體中的成員
利用操作符->可以通過結(jié)構(gòu)體指針訪問結(jié)構(gòu)體屬性

#include<iostream>
using namespace std;
#include<string>
// 結(jié)構(gòu)體指針
// 定義學(xué)術(shù)結(jié)構(gòu)體
struct student
{string name; // 姓名int age; // 年齡int score; // 分?jǐn)?shù)
};
int main()
{// 創(chuàng)建學(xué)生結(jié)構(gòu)體變量struct student s = { "張三",18, 100 };// 通過指針指向結(jié)構(gòu)體變量struct student* p = &s;// 通過指針訪問結(jié)構(gòu)體變量中的數(shù)據(jù)cout << "姓名：" << p->name << "年齡：" << p->age << "分?jǐn)?shù)：" << p->score << endl;system("pause");return 0;
}

總結(jié)：結(jié)構(gòu)體指針可以通過->操作符來訪問結(jié)構(gòu)體中的成員

8.5 結(jié)構(gòu)體嵌套結(jié)構(gòu)體

作用：結(jié)構(gòu)體中的成員可以是另一個(gè)結(jié)構(gòu)體
例如：每個(gè)老師輔導(dǎo)一個(gè)學(xué)員，一個(gè)老師的結(jié)構(gòu)體中，記錄一個(gè)學(xué)生的結(jié)構(gòu)體

#include<iostream>
using namespace std;
#include<string>
// 定義學(xué)生結(jié)構(gòu)體
struct student 
{string name; // 學(xué)生姓名int age; // 學(xué)生年齡int score; //考試分?jǐn)?shù)
};
// 定義老師結(jié)構(gòu)體
struct teacher
{int id; // 教師編號(hào)string name; // 教師姓名int age; // 年齡struct student stu;
};
int main()
{// 創(chuàng)建老師結(jié)構(gòu)體變量struct teacher t;t.id = 1000;t.name = "老王";t.age = 50;t.stu.name = "小王";t.stu.age = 20;t.stu.score = 60;cout << "教師姓名：" << t.name << "編號(hào):" << t.id << "年齡：" << t.age << endl;cout << "學(xué)生姓名：" << t.stu.name << "年齡:" << t.stu.age << "分?jǐn)?shù)：" << t.stu.score << endl;system("pause");return 0;
}

8.6 結(jié)構(gòu)體做函數(shù)參數(shù)

作用：將結(jié)構(gòu)體作為參數(shù)向函數(shù)中傳遞
傳遞方式有兩種:
1.值傳遞
2.地址傳遞

#include<iostream>
using namespace std;
#include<string>
// 定義學(xué)生結(jié)構(gòu)體
struct student 
{string name; // 學(xué)生姓名int age; // 學(xué)生年齡int score; //考試分?jǐn)?shù)
};
// 1.值傳遞
void printStudentInfo(struct student s)
{s.name = "哈哈";cout << "子函數(shù)中:" << "學(xué)生姓名：" << s.name << "年齡：" << s.age << "分?jǐn)?shù)：" << s.score << endl;}
// 2.地址傳遞
void printStudentInfo2(struct student* s)
{ s->name = "哈哈";cout << "子函數(shù)中:" << "學(xué)生姓名：" << s->name << "年齡：" << s->age << "分?jǐn)?shù)：" << s->score << endl;}int main()
{// 創(chuàng)建學(xué)生結(jié)構(gòu)體變量struct student s;s.name = "張三";s.age = 20;s.score = 85;printStudentInfo(s);printStudentInfo2(&s);cout << "main函數(shù)中:" << "學(xué)生姓名：" << s.name << "年齡：" << s.age << "分?jǐn)?shù)：" << s.score << endl;system("pause");return 0;
}

總結(jié)：如果不想修改主函數(shù)中的數(shù)據(jù)，用值傳遞，反之用地址傳遞

8.7 結(jié)構(gòu)體中的const使用場(chǎng)景

作用：用const來防止誤操作
當(dāng)進(jìn)行值傳遞時(shí)，實(shí)參和形參不是同一份數(shù)據(jù)，而當(dāng)函數(shù)為結(jié)構(gòu)體時(shí)，結(jié)構(gòu)體內(nèi)有多個(gè)成員變量，就會(huì)拷貝多少份數(shù)據(jù)，加大了內(nèi)存負(fù)擔(dān)。
因此，使用指針進(jìn)行地址傳遞就減少了內(nèi)存占用， 指針只占4個(gè)字節(jié)，但是為了更改的誤操作，對(duì)結(jié)構(gòu)體指針進(jìn)行const修飾，防止誤操作。

#include<iostream>
using namespace std;
#include<string>
// const使用場(chǎng)景
// 定義學(xué)生結(jié)構(gòu)體
struct student 
{string name; // 學(xué)生姓名int age; // 學(xué)生年齡int score; //考試分?jǐn)?shù)
};
// 將函數(shù)中的形參改為指針，可以減少內(nèi)存空間，并且不會(huì)復(fù)制出新的副本
void printStudentInfo(const struct student* s)
{//s->name = "哈哈"; //加入const后，就可以防止更改操作cout << "學(xué)生姓名：" << s->name << "年齡：" << s->age << "分?jǐn)?shù)：" << s->score << endl;}
int main()
{// 創(chuàng)建學(xué)生結(jié)構(gòu)體變量struct student s = { "張三",20, 85 };printStudentInfo(&s);system("pause");return 0;
}

二、C++核心編程

本階段主要針對(duì)C++面向?qū)ο蟮木幊碳夹g(shù)

1.內(nèi)存分區(qū)模型

C++程序在執(zhí)行時(shí)，將內(nèi)存大方向劃分為4個(gè)區(qū)域：
1.代碼區(qū):存放函數(shù)體的二進(jìn)制代碼，由操作系統(tǒng)進(jìn)行管理的
2.全局區(qū):存放全局變量和靜態(tài)變量以及常量
3.棧區(qū)︰由編譯器自動(dòng)分配釋放,存放函數(shù)的參數(shù)值,局部變量等
4.堆區(qū):由程序員分配和釋放,若程序員不釋放,程序結(jié)束時(shí)由操作系統(tǒng)回收
內(nèi)存四區(qū)意義
不同區(qū)域存放的數(shù)據(jù)，賦予不同的生命周期,給我們更大的靈活編程

1.1 程序運(yùn)行前

在程序編譯后，生成了exe可執(zhí)行程序，未執(zhí)行該程序前分為兩個(gè)區(qū)域
代碼區(qū)：
存放CPU執(zhí)行的機(jī)器指令
代碼區(qū)是共享的，共享的目的是對(duì)于頻繁被執(zhí)行的程序，只需要在內(nèi)存中有一份代碼即可
代碼區(qū)是只讀的，使其只讀的原因是防止程序意外地修改了它的指令
全局區(qū)：
全局變量和靜態(tài)變量存放在此.
全局區(qū)還包含了常量區(qū),字符串常量和其他常量（比如const修飾的）也存放在此.
該區(qū)域的數(shù)據(jù)在程序結(jié)束后由操作系統(tǒng)釋放
只要帶“局部”的，哪怕加了const進(jìn)行修飾，也不在全局區(qū)。

#include<iostream>
using namespace std;
// 全局變量
int g_a = 10;
int g_b = 10;
const int c_g_a = 10;
const int c_g_b = 10;
int main()
{// 全局區(qū)// 全局變量、靜態(tài)變量、常量// 創(chuàng)建普通局部變量int a = 10;int b = 10;cout << "局部變量a的地址為：" << (int)&a << endl;cout << "局部變量b的地址為：" << (int)&b << endl;/*局部變量a的地址為：9829476局部變量b的地址為：9829476*/cout << "全局變量g_a的地址為：" << (int)&g_a << endl;cout << "全局變量g_b的地址為：" << (int)&g_b  << endl;/*全局變量g_a的地址為：11976756全局變量g_b的地址為：11976760*/// 靜態(tài)變量  在普通變量前面加static，屬于靜態(tài)變量static int s_a = 10;static int s_b = 10;cout << "靜態(tài)變量s_a的地址為：" << (int)&s_a << endl;cout << "靜態(tài)變量s_b的地址為：" << (int)&s_b << endl;/*靜態(tài)變量s_a的地址為：11976764靜態(tài)變量s_b的地址為：11976768*/// 常量// 字符串常量cout << "字符串常量的地址為：" << (int)&"hello world" << endl;// 字符串常量的地址為：11967324// const修飾的變量// const修飾的全局變量cout << "全局常量c_g_a的地址為：" << (int)&c_g_a << endl;cout << "全局常量c_g_b的地址為：" << (int)&c_g_b << endl;/*全局常量c_g_a的地址為：11968136全局常量c_g_b的地址為：11968140*/// const修飾的局部變量const int c_1_a = 10;const int c_1_b = 10;cout << "局部常量c_g_a的地址為：" << (int)&c_1_a << endl;cout << "局部常量c_g_b的地址為：" << (int)&c_1_b << endl;/*局部常量c_g_a的地址為：9829452局部常量c_g_b的地址為：9829440*/system("pause");return 0;
}

總結(jié)：
1.C++中在程序運(yùn)行前分為全局區(qū)和代碼區(qū)
2.代碼區(qū)特點(diǎn)是共篡和只讀
3.全局區(qū)中存放全局變量、靜態(tài)變量、常量
4.常量區(qū)中存放const修飾的全局常量和字符串常量

1.2 程序運(yùn)行后

棧區(qū)：
由編譯器自動(dòng)分配釋放,存放函數(shù)的參數(shù)值,局部變量等
注意事項(xiàng)：不要返回局部孌量的地址，棧區(qū)開辟的數(shù)據(jù)由編譯器自動(dòng)釋放

#include<iostream>
using namespace std;
int* func(int b) // 形參也是放在棧區(qū)的
{b = 100;int a = 10; //局部變量  存放在棧區(qū)，棧區(qū)的數(shù)據(jù)在函數(shù)執(zhí)行完后自動(dòng)釋放return &a; // 返回局部變量的地址
}
int main()
{// 注意事項(xiàng)：不要返回局部孌量的地址，棧區(qū)開辟的數(shù)據(jù)由編譯器自動(dòng)釋放int* p = func(1);// 第一次正確輸出，是因?yàn)榫幾g器做了保留cout << *p << endl;// 第二次不再保留了，輸出產(chǎn)生亂碼cout << *p << endl; system("pause");return 0;
}

堆區(qū)：
曲程序員分配釋放,若程序員不釋放,程序結(jié)束時(shí)由操作系統(tǒng)回收
在C++中主要利用new在堆區(qū)開辟內(nèi)存
newint (10)創(chuàng)建的數(shù)據(jù)，并不是把數(shù)據(jù)本身返回出來，而是把數(shù)據(jù)的地址返回出來，所以用指針接受/

#include<iostream>
using namespace std;
int* func() 
{// 利用new關(guān)鍵字，可以將數(shù)據(jù)開辟到堆區(qū)// 指針本質(zhì)也是變量，放在棧上，只是指針保存的數(shù)據(jù)放在堆區(qū)int* p = new int(10);return p; 
}
int main()
{// 在堆區(qū)開辟數(shù)據(jù)int* p = func();cout << *p << endl;system("pause");return 0;
}

總結(jié)：
堆區(qū)數(shù)據(jù)由程序員管理開辟和釋放堆區(qū)
數(shù)據(jù)利用new關(guān)鍵字進(jìn)行開辟內(nèi)存

1.3 new操作符

C++中利用new操作符在堆區(qū)開辟數(shù)據(jù)
堆區(qū)開辟的數(shù)據(jù)，由程序員手動(dòng)開辟，手動(dòng)釋放，釋放利用操作符delete
語法：new 數(shù)據(jù)類型
利用new創(chuàng)建的數(shù)據(jù)，會(huì)返回該數(shù)據(jù)對(duì)應(yīng)的數(shù)據(jù)類型的指針

#include<iostream>
using namespace std;
int* func() 
{// 在堆區(qū)創(chuàng)建整型數(shù)據(jù)// new返回的是該數(shù)據(jù)類型的指針int* p = new int(10);return p; 
}
void test01()
{int* p = func();cout << *p << endl;cout << *p << endl;cout << *p << endl;// 堆區(qū)的數(shù)據(jù) 由程序員管理開發(fā)，管理釋放// 如果想釋放， 利用關(guān)鍵字deletedelete p;//cout << *p << endl; // 內(nèi)存已經(jīng)被釋放，再次訪問就是非法操作，會(huì)報(bào)錯(cuò)
}
// 2、在堆區(qū)利用new開辟數(shù)組
void test02()
{// 創(chuàng)建10個(gè)整型數(shù)據(jù)的數(shù)組int* arr = new int[10]; // []時(shí)，10代表數(shù)組有10個(gè)元素for (int i = 0; i < 10; i++){arr[i] = i + 100;}for (int i = 0; i < 10; i++){cout << arr[i] << endl;}// 釋放堆區(qū)數(shù)組// 釋放數(shù)組的時(shí)候，要加[]才可以delete[] arr;
}
int main()
{//test01();test02();system("pause");return 0;
}

2. 引用

2.1 引用的基本使用

作用：給變量起別名
語法：數(shù)據(jù)類型 &別名 = 原名

// 引用基本語法
// 數(shù)據(jù)類型 &別名 = 原名
int a = 10;
// 創(chuàng)建引用
int& b = a;
b = 20;
cout << "a = " << a << endl;
cout << "b = " << b << endl;

2.2 引用的注意事項(xiàng)

1.引用必須初始化
2.引用在初始化后，不可以改變

int a = 10;
// 引用必須初始化
// int& b;
int& b = a;// 引用在初始化后，不可以改變
// 創(chuàng)建引用
int c = 20;
b = c; //這是賦值操作，而不是更改引用
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;

2.3 引用做函數(shù)參數(shù)

作用：函數(shù)傳參時(shí)，可以利用引用的技術(shù)讓形參修飾實(shí)參
優(yōu)點(diǎn)：可以簡(jiǎn)化指針修改實(shí)參

#include<iostream>
using namespace std;
// 交換函數(shù)
// 1.值傳遞
void mySwap01(int a, int b)
{int temp = a;a = b;b = temp;
}// 2.地址傳遞
void mySwap02(int* a, int* b)
{int temp = *a;*a = *b;*b = temp;
}
// 3.引用傳遞
void mySwap03(int& a, int& b)
{int temp = a;a = b;b = temp;
}
int main()
{int a = 10;int b = 20;//mySwap01(a, b);  // 值傳遞，形參并不會(huì)修飾實(shí)參//mySwap02(&a, &b); // 地址傳遞，形參可以修飾實(shí)參mySwap03(a, b); // 引用傳遞，形參可以修飾實(shí)參cout << "a = " << a << endl;cout << "b = " << b << endl;system("pause");return 0;
}

總結(jié)：通過引用參數(shù)產(chǎn)生的效果同按地址傳遞是—樣的。引用的語法更清楚簡(jiǎn)單

2.4 引用做函數(shù)返回值

作用：引用是可以作為函數(shù)的返回值存在的
注意：不要返回局部變量引用
用法：函數(shù)調(diào)用作為左值

#include<iostream>
using namespace std;// 1.不返回局部變量的引用
int& test01()
{int a = 10; //局部變量存在在四區(qū)中的棧區(qū)return a;
}int& test02()
{static int a = 10; //靜態(tài)變量存在在四區(qū)中的全局區(qū)，由系統(tǒng)管理釋放return a;
}int main()
{//int& ref = test01();int& ref = test02();cout << "ref = " << ref << endl;  //第一次結(jié)果正確，是因?yàn)榫幾g器做了保留cout << "ref = " << ref << endl;  //第二次結(jié)果正確，是因?yàn)閍的內(nèi)存已經(jīng)做了釋放// 2.如果函數(shù)的調(diào)用返回值是引用，函數(shù)的調(diào)用可以作為左值test02() = 1000;cout << "ref = " << ref << endl;  cout << "ref = " << ref << endl;  system("pause");return 0;
}

2.5 引用的本質(zhì)

本質(zhì)：引用的本質(zhì)在c++內(nèi)部實(shí)現(xiàn)是一個(gè)指針常量

總結(jié)：C++推薦用引用技術(shù)，因?yàn)檎Z法方便，引用本質(zhì)是指針常量，但是所有的指針操作編譯器都幫我們做了

2.6 常量引用

本質(zhì)：常量引用主要用來修飾形參，防止誤操作
在函數(shù)形參列表中，可以加const修飾形參，防止形參改變實(shí)參

#include<iostream>
using namespace std;void showValue(const int& val)
{//val = 1; // 為了防止誤操作，在形參之前加上const進(jìn)行修飾cout << "val = " << val << endl;
}int main()
{// 常量引用// 使用場(chǎng)景：用來修飾形參，防止誤操作int a = 10;//int& ref = 10; // 引用必須引一塊合法的內(nèi)存空間// 加上const后，編譯器將代碼修改為 int temp 10; const int& ref = temp;const int& ref = 10;//ref = 20; // 加入const之后變?yōu)橹蛔x，不可以修改int b = 100;showValue(b);system("pause");return 0;
}

3. 函數(shù)提高

3.1 函數(shù)默認(rèn)參數(shù)

在C++中，函數(shù)的形參列表中的形參是可以有默認(rèn)值的。
語法：返回值類型 函數(shù)名 (參數(shù)=默認(rèn)值) {}

#include<iostream>
using namespace std;// 函數(shù)默認(rèn)參數(shù)
// 如果我們自己傳入數(shù)據(jù)，就用自己的數(shù)據(jù)，如果沒有，那么用默認(rèn)值
// 語法:返回值類型 函數(shù)名（形參=默認(rèn)值）{}// 注意事項(xiàng)
// 1.如果某個(gè)位置已經(jīng)有了默認(rèn)參數(shù)，那么從這個(gè)位置往后，從左到右都必須有默認(rèn)值
int func(int a, int b = 20, int c = 30)
{return a + b + c;
}// 2.如果函數(shù)聲明有默認(rèn)參數(shù)，函數(shù)實(shí)現(xiàn)就不能有默認(rèn)參數(shù)
// 聲明和實(shí)現(xiàn)只能有一個(gè)有默認(rèn)參數(shù)
int func2(int a = 10, int b = 10);int func2(int a = 10, int b = 10)
{return a + b;
}
int main()
{//cout << func(10) << endl;//cout << func(10, 30) << endl;cout << func2(10, 30) << endl;system("pause");return 0;
}

3.2 函數(shù)占位參數(shù)

C++中函數(shù)的形參列表里可以有占位參數(shù)，用來做占位，調(diào)用函數(shù)時(shí)必須填補(bǔ)該位置
語法：返回值類型 函數(shù)名（數(shù)據(jù)類型){}

#include<iostream>
using namespace std;// 占位參數(shù)
// 返回值類型 函數(shù)名（數(shù)據(jù)類型){}
// 占位參數(shù)還可以有默認(rèn)參數(shù) void func(int a, int = 10)void func(int a, int)
{cout << "this is func" << endl;
}int main()
{func(10, 10); // 占位參數(shù)必須要補(bǔ)system("pause");return 0;
}

3.3 函數(shù)重載

3.3.1 函數(shù)重載概述

作用：函數(shù)名可以相同，提高復(fù)用性
函數(shù)重載滿足條件:
1.同一個(gè)作用域下
2.函數(shù)名稱相同
3.函數(shù)參數(shù)類型不同，或者個(gè)數(shù)不同，或者順序不同
注意：函數(shù)的返回值不可以作為函數(shù)重載的條件

#include<iostream>
using namespace std;// 函數(shù)重載
// 可以讓函數(shù)名相同，提高復(fù)用性// 函數(shù)重載滿足條件:
// 1.同一個(gè)作用域下
// 2.函數(shù)名稱相同
// 3.函數(shù)參數(shù)類型不同，或者個(gè)數(shù)不同，或者順序不同void func()
{cout << "func 的調(diào)用" << endl;
}void func(int a)
{cout << "func(int a) 的調(diào)用" << endl;
}void func(double a)
{cout << "func(double a) 的調(diào)用" << endl;
}void func(int a, double b)
{cout << "func(int a, double b) 的調(diào)用" << endl;
}void func(double b, int a)
{cout << "func(double b, int a) 的調(diào)用" << endl;
}// 注意事項(xiàng)：函數(shù)的返回值不可以作為函數(shù)重載的條件
// // 因?yàn)椴还苁莢oid func還是int func，函數(shù)調(diào)用都是func()，就會(huì)產(chǎn)生歧義。
//int func(double b, int a)
//{
//	cout << "void func(double b, int a) 的調(diào)用" << endl;
//}int main()
{func();func(10);func(3.14);func(10, 3.14);func(3.14, 10);system("pause");return 0;
}

3.3.2 函數(shù)重載的注意事項(xiàng)

函數(shù)重載滿足條件:
1.引用作為重載條件
2.函數(shù)重載碰到函數(shù)默認(rèn)參數(shù)

#include<iostream>
using namespace std;// 函數(shù)重載滿足條件:
// 1.引用作為重載條件
void func(int& a)  // int& =10 不合法
{cout << "func(int& a) 的調(diào)用" << endl;
}void func(const int& a) // const int& =10 會(huì)創(chuàng)建一個(gè)temp臨時(shí)空間，合法
{cout << "func(const int& a) 的調(diào)用" << endl;
}// 2.函數(shù)重載碰到函數(shù)默認(rèn)參數(shù)
void func2(int a, int b = 10) 
{cout << "func2(int a, int b) 的調(diào)用" << endl;
}void func2(int a)
{cout << "func2(int a) 的調(diào)用" << endl;
}int main()
{// a是一個(gè)變量，可讀可寫，所以當(dāng)引用作為重載條件時(shí)，編譯器默認(rèn)走void func(int& a)的版本int a = 10;// func(a); // 調(diào)用無const// 相當(dāng)于 int& =10，這個(gè)沒有引用一個(gè)合法空間，編譯器不會(huì)通過的，編譯器默認(rèn)走void func(const int& a)的版本// func(10);  // 調(diào)用有const// func2(10); // 兩種都能調(diào)，因?yàn)槟J(rèn)參數(shù)b可以不傳形參，出現(xiàn)了歧義system("pause");return 0;
}

4. 面向?qū)ο?/h3>

C++面向?qū)ο蟮娜筇匦詾?封裝、繼承、多態(tài)
C++認(rèn)為萬事萬物都皆為對(duì)象，對(duì)象上有其屬性和行為
例如：
人可以作為對(duì)象，屬性有姓名、年齡、身高、體重…，行為有走、跑、跳、吃飯、唱歌…
車也可以作為對(duì)象，屬性有輪胎、方向盤、車燈…行為有載人、放音樂、放空調(diào)…
具有相同性質(zhì)的對(duì)象，我們可以抽象稱為類，人屬于人類，車屬于車類

4.1 封裝

4.1.1 封裝的意義

封裝是C++面向?qū)ο笕筇匦灾?br /> 封裝的意義：
1.將屬性和行為作為一個(gè)整體，表現(xiàn)生活中的事物
2.將屬性和行為加以權(quán)限控制
封裝意義一：
在設(shè)計(jì)類的時(shí)候，屬性和行為寫在一起，表現(xiàn)事物
語法：class 類名 { 訪問權(quán)限 : 屬性 / 行為 };

#include<iostream>
using namespace std;
// 設(shè)計(jì)一個(gè)圓類，求圓的周長(zhǎng)
const double PI = 3.14;// class代表設(shè)計(jì)一個(gè)類
class Circle
{// 訪問權(quán)限// 公共權(quán)限
public:// 類中的屬性和行為我們統(tǒng)一稱為：成員// 屬性 成員屬性、成員變量// 行為 成員函數(shù)、成員方法// 屬性// 半徑int m_r;// 行為// 獲取圓的周長(zhǎng)double calculateZC(){return 2 * PI * m_r;}// 也可設(shè)置一個(gè)給屬性賦值的行為void setR(int r){m_r = r;}
};
int main()
{// 通過圓類 創(chuàng)建具體的圓(對(duì)象)// 實(shí)例化 (通過一個(gè)類創(chuàng)建一個(gè)對(duì)象的過程)Circle c1;// 給圓對(duì)象的屬性進(jìn)行賦值c1.m_r = 10;cout << "圓的周長(zhǎng)為：" << c1.calculateZC() << endl;Circle c2;c2.setR(20); // 通過定義好的屬性給行為直接賦值cout << "圓的周長(zhǎng)為：" << c2.calculateZC() << endl;system("pause");return 0;
}

封裝意義二：
類在設(shè)計(jì)時(shí)，可以把屬性和行為放在不同的權(quán)限下，加以控制
訪問權(quán)限有三種:
1.public公共權(quán)限
2.protected保護(hù)權(quán)限
3.private私有權(quán)限

#include<iostream>
using namespace std;// 訪問權(quán)限， 三種：
// public     公共權(quán)限    成員， 類內(nèi)可以訪問，類外也可以訪問 
// protected  保護(hù)權(quán)限    成員， 類內(nèi)可以訪問，類外不可以訪問    兒子可以訪問父親中的保護(hù)內(nèi)容
// private    私有權(quán)限    成員， 類內(nèi)可以訪問，類外也可以訪問    兒子不可以訪問父親中的保護(hù)內(nèi)容class Person
{// 訪問權(quán)限
public:// 公共權(quán)限string m_Name; // 姓名protected:// 保護(hù)權(quán)限string m_Car;  //汽車
private:// 私有權(quán)限int m_Password;  //銀行卡密碼public:// 行為void func(){m_Name = "張三";m_Car = "拖拉機(jī)";m_Password = 12346;}
};
int main()
{// 實(shí)例化具體對(duì)象Person p1;p1.m_Name = "李四";//p1.m_Car = "奔馳";  //m_Car是保護(hù)權(quán)限，類外不可以訪問//p1.m_Password = 123;  //m_Car是私有權(quán)限，類外不可以訪問system("pause");return 0;
}

4.1.2 struct和class區(qū)別

在C++中struct和class唯一的區(qū)別就在于：
默認(rèn)的訪問權(quán)限不同
區(qū)別:
1.struct 默認(rèn)權(quán)限為公共
2.class默認(rèn)權(quán)限為私有

#include<iostream>
using namespace std;// struct和class唯一的區(qū)別就在于默認(rèn)的訪問權(quán)限不同// 1.struct 默認(rèn)權(quán)限為公共
// 2.class  默認(rèn)權(quán)限為私有class C1
{int m_A;  // 默認(rèn)權(quán)限為私有
};struct C2
{int m_A;  // 默認(rèn)權(quán)限為公共
};int main()
{C1 c1;//c1.m_A = 100;  // 私有權(quán)限，類外不可以訪問C2 c2;c2.m_A = 100;    // 公共權(quán)限，類外可以訪問system("pause");return 0;
}

4.1.3 成員屬性設(shè)置為私有

在C++中struct和class唯一的區(qū)別就在于：
優(yōu)點(diǎn)1：將所有成員屬性設(shè)置為私有，可以自己控制讀寫權(quán)限
優(yōu)點(diǎn)2：對(duì)于寫權(quán)限，我們可以檢測(cè)數(shù)據(jù)的有效性
其實(shí)，就是將屬性設(shè)置私有后，設(shè)置public接口函數(shù)來控制對(duì)屬性的讀與寫的狀態(tài)。

#include<iostream>
using namespace std;// 成員屬性設(shè)置為私有// 1、將所有成員屬性設(shè)置為私有，可以自己控制讀寫權(quán)限
// 2、對(duì)于寫權(quán)限，我們可以檢測(cè)數(shù)據(jù)的有效性// 定義一個(gè)人類
class Person
{
public:// 設(shè)置姓名void setName(string name){m_Name = name;}// 獲取姓名string getName(){return m_Name;}// 獲取年齡int getAge(){return m_Age;}// 設(shè)置年齡  用于2，檢測(cè)數(shù)據(jù)有效性時(shí)，設(shè)置為可寫，但是年齡必須在0-150之間void setAge(int age){if (age < 0 || age > 150){cout << "年齡輸入有誤，賦值失敗" << endl;return;}m_Age = age;}// 設(shè)置偶像void setIdol(string idol){m_Idol = idol;}private:string m_Name; // 姓名 可讀可寫int m_Age =18; // 年齡 只讀  用于2，檢測(cè)數(shù)據(jù)有效性時(shí)，設(shè)置為可寫，但是年齡必須在0-150之間string m_Idol; // 偶像 只寫
};int main()
{Person p;// 姓名的設(shè)置//p.m_Name = "張三";p.setName("張三");cout << "姓名為：" << p.getName() << endl; // 設(shè)置了可讀可寫狀態(tài)// 年齡的設(shè)置//p.m_Age = 20;  // 只設(shè)置了可讀狀態(tài)，不可寫cout << "年齡為：" << p.getAge() << endl;// 偶像的設(shè)置p.setIdol("小明");//cout << "偶像為：" << p.m_Idol << endl; // 只設(shè)置了寫的狀態(tài)，不可讀// 用于2，檢測(cè)數(shù)據(jù)有效性時(shí)，設(shè)置為可寫，但是年齡必須在0-150之間p.setAge(160);cout << "年齡為：" << p.getAge() << endl;  //輸出仍為18system("pause");return 0;
}

補(bǔ)充：和結(jié)構(gòu)體類似，類里面還可以讓另一個(gè)類來作為本類中的成員！！！

4.1.4 類的分文件編寫

1.首先，先在頭文件中進(jìn)行類的申明，將所有成員函數(shù)的函數(shù)體去掉，只留下申明就行。
其實(shí)，類的分文間編寫和上面的函數(shù)分文件編寫類似，只要管函數(shù)就行。

#pragma once  //防止頭文件重復(fù)申明
#include<iostream>
using namespace std;class Circle
{
public:// 成員行為只留下函數(shù)的申明就行// 設(shè)置半徑void setR(int r);// 獲取半徑int getR();
private:int m_R; //半徑
};

2.接著，進(jìn)行函數(shù)體的實(shí)現(xiàn)，新建.cpp文件
進(jìn)行頭文件的導(dǎo)入，類的申明中成員屬性也不用管，只要實(shí)現(xiàn)成員函數(shù)的實(shí)現(xiàn)就行，在每個(gè)函數(shù)名之前加上函數(shù)的作用域（不然就是全局函數(shù)，是不對(duì)的），最后進(jìn)行一個(gè)縮進(jìn)就完成了。

#include"circle.h"// 設(shè)置半徑
void Circle::setR(int r)
{m_R = r;
}
// 獲取半徑
int Circle::getR()
{return m_R;
}