?一、數(shù)據(jù)類(lèi)型 數(shù)據(jù)的輸入輸出

1.數(shù)據(jù)類(lèi)型 常量變量

1.1 數(shù)據(jù)類(lèi)型

1.2 常量

?? 程序運(yùn)行中值不發(fā)生變化的量，常量又可分為整型、實(shí)型(也稱(chēng)浮點(diǎn)型)、字符型和字符串型

1.3 變量

變量代表內(nèi)存中具有特定屬性的存儲(chǔ)單元，用來(lái)存放數(shù)據(jù)，即變量的值，這些值在程序的執(zhí)行過(guò)程中是可以改變的

命名規(guī)則：只能由字母、數(shù)字、下劃線組成，并且第一個(gè)字符必須為字母或下劃線。
大寫(xiě)和小寫(xiě)是不同的字符。

1.4 整型數(shù)據(jù)

???1.4.1符號(hào)常量

#include<stdio.h>
//符號(hào)常量
#define PI 3+2//符號(hào)常量不需要=賦值，也不需要分號(hào)
int main(){int i=PI*2;//i就是一個(gè)整型變量printf("i=%d\n",i);//printf是用來(lái)輸出的
}

????//最終的輸出結(jié)果是7 ，符號(hào)常量PI是直接替換的效果 。3+2*2=7，不等于8

????1.4.2整型變量 int i

? ? 整型變量i是4個(gè)字節(jié)

printf("i size=%d\n",sizeof(i));//sizeof可以用來(lái)計(jì)算某個(gè)變量的空間大小

? ? //輸出i size =4

1.5 浮點(diǎn)型數(shù)據(jù)

? ? 1.5.1 浮點(diǎn)型常量

????1.5.2 浮點(diǎn)型變量

? ? ?通過(guò)float f來(lái)定義浮點(diǎn)變量，f占用4個(gè)字節(jié)的空間

#include<stdio.h>
int main(){float f=3e-3;printf("f=%f\n",f);
}
//輸出f=0.003000

1.6 字符型數(shù)據(jù)

1.6.1 字符型常量

用單引號(hào)括起來(lái)的一個(gè)字符是字符型常量，且只能包含一個(gè) 字符！例如，'a'、'A'、'l'、' '是正確的字符型常量，而'abc'、"a"、" "是錯(cuò)誤的字符型常量

轉(zhuǎn)義字符及其作用

\n	換行
\b	退格
\\	反斜杠

1.6.2 字符數(shù)據(jù)在內(nèi)存中的存儲(chǔ)形式及其使用方法

字符用char定義，一個(gè)字符變量占一個(gè)字節(jié)

一個(gè)字符常量存放到字符型變量中，實(shí)際上是把該字符的ASCII碼值存放到內(nèi)存單元中。

#include<stdio.h>
//大寫(xiě)表小寫(xiě)
int main(){char c='A'; //ASCII表中A=65 a=97printf("%c\n",c+32);//以字符形式輸出? %c打印出來(lái)的都是字符printf("%d\n",c);//以數(shù)值形式輸出? %d打印出來(lái)的都是ASCII碼值
}

1.7 字符串型常量

由一對(duì)雙引號(hào)括起來(lái)的字符序列 例如"How do you do"、"CHINA"、"$123.45"、"a"等都是合法的字符串常量

注意"a" 占用的是兩個(gè)字節(jié)

"CHINA"占用的是6個(gè)字節(jié)，最后一個(gè)字符為'\0' 輸出是不輸出，因?yàn)闊o(wú)法顯示

C

H

I

N

A

\0

如上面，為CHINA在內(nèi)存中的存儲(chǔ)結(jié)果，所以字符的字節(jié)都比里面的字母要多一個(gè)

1.8 ASCII碼表

2.混合運(yùn)算

2.1 類(lèi)型強(qiáng)制轉(zhuǎn)換場(chǎng)景

整型數(shù)進(jìn)行除法運(yùn)算時(shí)，如果運(yùn)算結(jié)果為小數(shù)，那么浮點(diǎn)數(shù)時(shí)一定要進(jìn)行強(qiáng)制類(lèi)型轉(zhuǎn)換

#include<stdio.h>
//強(qiáng)制類(lèi)型轉(zhuǎn)換
int main(){int i=5;float f=i/2;//這里做的是整型運(yùn)算，因?yàn)樽笥也僮鲾?shù)都是整型float k=(float)i/2; //(float)i 強(qiáng)制類(lèi)型轉(zhuǎn)換式  是浮點(diǎn)型printf("%f\n",f);printf("%f\n",k);return 0;
}
f得到的是2
k得到的才是2.5

2.2 printf函數(shù)介紹

printf函數(shù)可以輸出各種類(lèi)型的數(shù)據(jù)，包括整型、浮點(diǎn)型、字符型、字符串型等，實(shí)際原理是printf函數(shù)將這些類(lèi)型的數(shù)據(jù)格式化為字符串后，放入標(biāo)準(zhǔn)緩沖區(qū)，然后將結(jié)果顯示到屏幕上

語(yǔ)法如下：

#include<studio.h>
int printf(const char*format,…);

printf函數(shù)根據(jù)format給出的格式打印輸出到stdout（標(biāo)準(zhǔn)輸出）和其他參數(shù)中

int age =21;
printf("Hello %s,you are %d years old \n","Bob",age);

代碼的輸出如下：

Hello Bob,you are 21 years old

其中，%s表示在該位置插入首個(gè)參數(shù)(一個(gè)字符串)，%d表示第二個(gè)參數(shù)(一個(gè)整數(shù))應(yīng)該放在那里，不同的%codes表示不同的變量類(lèi)型，也可以限制變量的長(zhǎng)度，printf函數(shù)如下:

代碼	格式
%c	字符
%d	帶符號(hào)整數(shù)
%f	浮點(diǎn)數(shù)
%s	一串字符
%u	無(wú)符號(hào)整數(shù)
%x	無(wú)符號(hào)十六進(jìn)制數(shù)，用小寫(xiě)字母
%X	無(wú)符號(hào)十六進(jìn)制數(shù)，用大寫(xiě)字母
%p	一個(gè)指針
%%	一個(gè)'%'符號(hào)

位于%和格式化命令之間的一個(gè)整數(shù)被稱(chēng)為最小字段寬度說(shuō)明符，通常會(huì)加上空格來(lái)控制格式。

• 用%f精度修飾符指定想要的小數(shù)位數(shù)，例如，%5.2f會(huì)至少顯示5位數(shù)字并帶有2位小數(shù)點(diǎn)的浮點(diǎn)數(shù)。
• 用%s精度修飾符簡(jiǎn)單地表示一個(gè)最大的長(zhǎng)度，以補(bǔ)充句點(diǎn)前的最小字段長(zhǎng)度

printf函數(shù)的所有輸出都是右對(duì)齊的，除非在%符號(hào)后放置了負(fù)號(hào)

例如：%-5.2f會(huì)顯示5位字符、2位小數(shù)位的浮點(diǎn)數(shù)并且左對(duì)齊

#include<stdio.h>
//練習(xí)printf
int main(){int i=10;float f=96.3;printf("student number=%-3d,score=%5.2f\n",i,f);//默認(rèn)是右對(duì)齊，加一個(gè)負(fù)號(hào)代表左對(duì)齊i=100;f=98.21;printf("studentnumber=%3d,score=%5.2f\n",i,f);? //3d表示后面 的數(shù)據(jù)輸出時(shí)會(huì)占三個(gè)空格的位置return 0;
}

3.整型進(jìn)制轉(zhuǎn)換

3.1整型常量的不同進(jìn)制表示

計(jì)算機(jī)中只能存儲(chǔ)二進(jìn)制數(shù)，即0和1，而在對(duì)應(yīng)的物理硬件上則是高、低電平.為了更方便地觀察內(nèi)存中的二進(jìn)制數(shù)情況，除我們正常使用的十進(jìn)制數(shù)外，計(jì)算機(jī)還提供了十六進(jìn)制數(shù)和八進(jìn)制數(shù).

在計(jì)算機(jī)中,1字節(jié)為8位,1位即二進(jìn)制的1位，它存儲(chǔ)0或1。 int型常量的大小為4字節(jié)，即32位。

二進(jìn)制 0和1

0101 0101 1個(gè)字節(jié)byte ，有8個(gè)位,bit

1KB = 1024 字節(jié)

1MB = 1024Kb

1GB = 1024MB

十進(jìn)制 0-9

八進(jìn)制 0-7???????????? 十進(jìn)制轉(zhuǎn)八進(jìn)制 除18

十六進(jìn)制 0-9 A-F?? 十進(jìn)制轉(zhuǎn)十六進(jìn)制 除16

123為十進(jìn)制???? 轉(zhuǎn)二進(jìn)制? 除2 余數(shù)倒看

2? |123??? 1

2??? |61??? 1

2??? |30??? 0

2??? |15??? 1

2????? |7??? 1

2????? |3??? 1

2????? |1??? 1
???????? 0???????????????? 從下往上為二進(jìn)制 即0000 0000 0000 0000 0000 0111 1011

123轉(zhuǎn)十六進(jìn)制

16? |123??? 11???? 由于十六進(jìn)制沒(méi)有11? 所以為7b

??????????? 7

二進(jìn)制轉(zhuǎn)十六進(jìn)制

每四位對(duì)應(yīng)十六進(jìn)制的一個(gè)數(shù)字

0000 0000 0000 0000 0000 0111 1011? 二進(jìn)制

?

? ? ?7? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? b

二進(jìn)制轉(zhuǎn)八進(jìn)制??

每三位對(duì)應(yīng)一個(gè)

001 111 011

1???? 7???? 3

八進(jìn)制轉(zhuǎn)十進(jìn)制

#include<stdio.h>
int main(){int i=0x7b;? //賦值八進(jìn)制前面需要加個(gè)0 【0173】 十六進(jìn)制前面需要加個(gè)0x 【0x7b】 十進(jìn)制直接輸123printf("%d\n",i);//十進(jìn)制輸出 ???123printf("%o\n",i);//%o八進(jìn)制?? ???173printf("%x\n",i);//%s十六進(jìn)制 ???7breturn 0;
}

debug查看 打斷點(diǎn) 點(diǎn)開(kāi)內(nèi)存視圖 輸入&i 回車(chē)查看

4.scanf讀取標(biāo)準(zhǔn)輸入

4.1?scanf函數(shù)的原理

C語(yǔ)言未提供輸入/輸出關(guān)鍵字，其輸入和輸出是通過(guò)標(biāo)準(zhǔn)函數(shù)庫(kù)來(lái)實(shí)現(xiàn)的。C語(yǔ)言通過(guò)scanf 函數(shù)讀取鍵盤(pán)輸入，鍵盤(pán)輸入又被稱(chēng)為標(biāo)準(zhǔn)輸入，當(dāng)scanf函數(shù)讀取標(biāo)準(zhǔn)輸入時(shí)，如果還沒(méi)有輸入任何內(nèi)容，那么scanf函數(shù)會(huì)被卡住（專(zhuān)業(yè)用語(yǔ)為阻塞)．如下例

#include<stdio.h>
//scanf用來(lái)讀取標(biāo)準(zhǔn)輸入，scanf把標(biāo)準(zhǔn)輸入內(nèi)的內(nèi)容，需要放到某個(gè)變量空間里，因此變量必須取地址
//scanf會(huì)阻塞，是因?yàn)闃?biāo)準(zhǔn)輸入緩沖區(qū)是空的
int main(){int i;char c;float f;scanf("%d",&i); //注意一定要取地址&iprintf("i=%d\n",i);//把標(biāo)準(zhǔn)緩沖區(qū)中的整型數(shù)讀走了fflush(stdin);//清空標(biāo)準(zhǔn)輸入緩沖區(qū)? 不清空的話(huà)下面的輸出會(huì)卡住scanf("%c",&c);printf("c=%c\n",c);//輸出字符變量c//scanf("%f",&f);//printf("f=%f\n",f);return 0;
}

執(zhí)行時(shí)輸入20,然后回車(chē),顯示結(jié)果為
20
20
c=c
進(jìn)程已結(jié)束，退出代碼為0

4.2 多種數(shù)據(jù)類(lèi)型混合輸入

????????? 當(dāng)我們讓 scanf函數(shù)一次讀取多種類(lèi)型的數(shù)據(jù)時(shí)，要注意當(dāng)一行數(shù)據(jù)中存在字符型數(shù)據(jù)讀取時(shí)，讀取的字符并不會(huì)忽略空格和'\n'(回車(chē)符)，所以編寫(xiě)代碼時(shí)，我們需要在%d與%c之間加入一個(gè)空格。輸入格式和輸出效果如下圖所示, scanf 函數(shù)匹配成功了4個(gè)成員,所以返回值為4,我們可以通過(guò)返回值來(lái)判斷scanf函數(shù)匹配成功了幾個(gè)成員，中間任何有一個(gè)成員匹配出錯(cuò)，后面的成員都會(huì)匹配出錯(cuò).

#include<stdio.h>
//scanf一次讀多種數(shù)據(jù)類(lèi)型
int main(){int i,ret;? //定義ret變量 是因?yàn)閟canf是由返回值的float f;char c;ret=scanf("%d %c%f",&i,&c,&f);//ret是指scanf匹配成功的個(gè)數(shù)? 注意要在%c之前加個(gè)空格 不然后面的無(wú)法輸出 遇到%c前面就加空格printf("i=%d,c=%c,f=%5.2f\n",i,c,f);return 0;
}

二、運(yùn)算符與表達(dá)式

1.運(yùn)算符分類(lèi)

C語(yǔ)言提供了13種類(lèi)型的運(yùn)算符，如下所示。

(1)算術(shù)運(yùn)算符(+-*/ %) .

(2)關(guān)系運(yùn)算符(><= >=<= !=).

(3)邏輯運(yùn)算符(!&& ll) .

(4)位運(yùn)算符(<< >> ~|^ &).

(5)賦值運(yùn)算符(=及其擴(kuò)展賦值運(yùn)算符).

(6)條件運(yùn)算符(?:).

(7)逗號(hào)運(yùn)算符(,).

(8)指針運(yùn)算符(*和&)---講指針時(shí)講解

(9)求字節(jié)數(shù)運(yùn)算符(sizeof).

(10)強(qiáng)制類(lèi)型轉(zhuǎn)換運(yùn)算符（(類(lèi)型)).

(11)分量運(yùn)算符(.->) 。---講結(jié)構(gòu)體時(shí)講解

(12)下標(biāo)運(yùn)算符([]) 。—---講數(shù)組時(shí)講解

(13)其他(如函數(shù)調(diào)用運(yùn)算符()) 。---講函數(shù)時(shí)講解

2.算術(shù)運(yùn)算符及算術(shù)表達(dá)式

算術(shù)運(yùn)算符包含+、一、*、/和%，當(dāng)一個(gè)表達(dá)式中同時(shí)出現(xiàn)這5種運(yùn)算符時(shí),先進(jìn)行乘(*)、除（/)、取余(%)，取余也稱(chēng)取模，后進(jìn)行加(+)、減(-).

也就是乘、除、取余運(yùn)算符的優(yōu)先級(jí)高于加、減運(yùn)算符.

#include<stdio.h>
//練習(xí)算術(shù)運(yùn)算符
int main(){int? result=4+5*2-6/3+11%4;printf("result=%d\n",result);return 0;
}
result=15

3.關(guān)系運(yùn)算符與關(guān)系表達(dá)式

關(guān)系運(yùn)算符>、<、==、>=、<=、!=依次為大于、小于、是否等于、大于等于、小于等于和不等于。由關(guān)系運(yùn)算符組成的表達(dá)式稱(chēng)為關(guān)系表達(dá)式。

關(guān)系表達(dá)式的值只有真和假，對(duì)應(yīng)的值為1和0。由于C語(yǔ)言中沒(méi)有布爾類(lèi)型，所以在C語(yǔ)言中0值代表假，非0值即為真。

例如，關(guān)系表達(dá)式3>4為假，因此整體值為0，而關(guān)系表達(dá)式5>2為真，因此整體值為1。關(guān)系運(yùn)算符的優(yōu)先級(jí)低于算術(shù)運(yùn)算符

如果要判斷三個(gè)變量a、b、c是否相等，那么不能寫(xiě)為a==b==c,而應(yīng)寫(xiě)為a==b &&b==C

#include<stdio.h>
//關(guān)系運(yùn)算符，優(yōu)先級(jí)小于算術(shù)運(yùn)算符
int main(){int? a;while(scanf("%d",&a)){if(3<a&&a<10)//a大于3同時(shí)a小于10要這樣寫(xiě) 不能寫(xiě)成3<a<10{printf("a is between 3 and10\n");}else{printf("a is not between 3 and 10\n");}}return 0;
}

運(yùn)算符的優(yōu)先級(jí)表

4.邏輯運(yùn)算符與邏輯表達(dá)式

邏輯運(yùn)算符!、&&、ll依次為邏輯非、邏輯與、邏輯或，這和數(shù)學(xué)上的與、或、非是一致的.邏輯非的優(yōu)先級(jí)高于算術(shù)運(yùn)算符，邏輯與和邏輯或的優(yōu)先級(jí)低于關(guān)系運(yùn)算符．

邏輯表達(dá)式的值只有真和假，對(duì)應(yīng)的值為1和0.

下例中的代碼是計(jì)算一年是否為閏年的例子，因?yàn)樾枰貜?fù)測(cè)試，所以我們用了一個(gè) while循環(huán)。

#include<stdio.h>
//記住優(yōu)先級(jí)目的，不能夠加多余的括號(hào)
int main(){int year,i,j=6;while(scanf("%d",&year)){if(year%4==0&&year%100!=0||year%400==0){printf("%d is leap year\n",year);}else{printf("%d is not leap year\n",year);}}i=!!j;? //邏輯非? 非非j? 自右至左printf("i value=%d\n",i);return 0;
}

//邏輯與和邏輯或短路運(yùn)算
int main(){int i=0;i&&printf("you can't see me!\n");//當(dāng)i為假時(shí)，不會(huì)執(zhí)行邏輯與后的表達(dá)式，稱(chēng)為短路運(yùn)算? 等價(jià)于if(為真){}else{} 簡(jiǎn)潔代碼i=1;i||printf("you can't see me!\n");return 0;
}

5.賦值運(yùn)算符

a = b+ 25;

?a是一個(gè)左值，它標(biāo)識(shí)了一個(gè)可以存儲(chǔ)結(jié)果值的地點(diǎn); b+25是一個(gè)右值，因?yàn)樗付艘粋€(gè)值。

#include<stdio.h>
int main(){int a=1,b=2;b+25=a;? ? ? ? //b+25不能作為左值，因?yàn)樗⑽礃?biāo)識(shí)一個(gè)特定的位置(并不對(duì)應(yīng)特定的內(nèi)存空間)return 0;
}

上面的例子執(zhí)行時(shí)會(huì)報(bào)下面的編譯錯(cuò)誤

Error:lvalue required as left operand of assignment

5.1復(fù)合賦值運(yùn)算符

復(fù)合賦值運(yùn)算符操作是一種縮寫(xiě)形式，復(fù)合賦值運(yùn)算符能使對(duì)變量的賦值操作變得更加簡(jiǎn)潔。

iNum = iNum + 5;

對(duì)變量 iNum的賦值進(jìn)行操作，值為這個(gè)變量本身與一個(gè)整型常量5相加的結(jié)果.使用復(fù)合語(yǔ)句可以實(shí)現(xiàn)同樣的操作。例如，上面的語(yǔ)句可以修改為

iNum+=5;

賦值運(yùn)算符與復(fù)合賦值運(yùn)算符的區(qū)別如下:

(1)復(fù)合賦值運(yùn)算符簡(jiǎn)化了程序，可使程序精煉,提升閱讀速度。

(2)復(fù)合賦值運(yùn)算符提高了編譯效率.

int main(){int a=1,b=2;a+=3;b*=5;printf("a=%d\n",a);printf("b=%d\n",b);return 0;
}

6.求字節(jié)運(yùn)算符sizeof

sizeof不是一個(gè)函數(shù),而是一個(gè)運(yùn)算符，不像其他運(yùn)算符是一個(gè)符號(hào)，sizeof是字母組成的，用于求常量或變量所占用的空間大小

#include<stdio.h>
//sizeof運(yùn)算符
int main(){int i=0;printf("i size is%d\n",sizeof(i));return 0;
}

運(yùn)行結(jié)果為i size is 4，可以求得整型變量占用的空間大小是4個(gè)字節(jié)。

三、選擇、循環(huán)

關(guān)系表達(dá)式與邏輯表達(dá)式

算術(shù)運(yùn)算符的優(yōu)先級(jí)高于關(guān)系運(yùn)算符、

關(guān)系運(yùn)算符的優(yōu)先級(jí)高于邏輯與和邏輯或運(yùn)算符

相同優(yōu)先級(jí)的運(yùn)算符從左至右進(jìn)行結(jié)合

表達(dá)式5>3&&8<4-!0的最終值是多少?其計(jì)算過(guò)程如下圖所示。

1.if-else語(yǔ)句

int main(){int year;scanf("%d",&year);if(year%4==0&&year%100!=0||year%400==0){printf("yes\n");}else{printf("no\n");}return 0;
}

if語(yǔ)句和else語(yǔ)句也可以多個(gè)同時(shí)使用(多分支語(yǔ)句)

2.while循環(huán)

while 語(yǔ)句用來(lái)實(shí)現(xiàn)“當(dāng)型”循環(huán)結(jié)構(gòu)，其一般形式為“while(表達(dá)式）語(yǔ)句;”，當(dāng)表達(dá)式的值非0時(shí)，執(zhí)行while語(yǔ)句中的內(nèi)嵌語(yǔ)句。

其特點(diǎn)是:先判斷表達(dá)式，后執(zhí)行語(yǔ)句。

//計(jì)算從1到100的和
int main(){int i=1,total=0;while(i<=100)//在這里加分號(hào)會(huì)造成死循環(huán){if(i%2==0){i++;continue;//continue下面的代碼均不會(huì)得到執(zhí)行}total=total+i;//把i加到total上i++;//i++等價(jià)于i+=1;在循環(huán)體內(nèi)沒(méi)有讓while判斷表達(dá)式趨近于假的操作，死循環(huán)}printf("total=%d\n",total);return 0;
}

3.for循環(huán)

for循環(huán)語(yǔ)句中必須且只能有兩個(gè)分號(hào)，用于分割表達(dá)式1、表達(dá)式2、和表達(dá)式3

//for循環(huán)實(shí)現(xiàn)從1加到100
int main(){int i,total;for(i=1,total=0;i<=100;i++)//for小括號(hào)后不要加分號(hào){total+=i;}printf("total=%d\n",total);return 0;
}

for循環(huán)的可讀性比while循環(huán)要好，所以能使用for循環(huán)時(shí)不要強(qiáng)制改為while循環(huán)

4.continue語(yǔ)句

continue語(yǔ)句的作用為結(jié)束本次循環(huán)，即跳過(guò)循環(huán)體中下面尚未執(zhí)行的語(yǔ)句，接著進(jìn)行是否執(zhí)行下一次循環(huán)的判斷

continue；

//for循環(huán)實(shí)現(xiàn)從1加到100
//使用continue
int main(){int i,total;for(i=1,total=0;i<=100;i++)//for小括號(hào)后不要加分號(hào){if(i%2==0){continue;//continue下面的代碼均不會(huì)得到執(zhí)行    }total+=i;}printf("total=%d\n",total);return 0;
}

5.break語(yǔ)句

break語(yǔ)句的作用是結(jié)束整個(gè)循環(huán)過(guò)程，不再判斷執(zhí)行循環(huán)的條件是否成立

例：從1開(kāi)始累加，當(dāng)累加的和大于2000時(shí)，結(jié)束for循環(huán)，同時(shí)打印此時(shí)total的值和i的值，一旦執(zhí)行break語(yǔ)句，下一句要執(zhí)行的就是“printf("total=%d,i=%d\n",total,i);”，break語(yǔ)句也可以用在while循環(huán)和do while循環(huán)中，起到結(jié)束對(duì)應(yīng)循環(huán)的作用

int main(){int i,total;for(i=1,total=0;i<=100;i++)//for小括號(hào)后不要加分號(hào)    {if(total>2000){break;//當(dāng)和大于2000時(shí)，循環(huán)結(jié)束    }total+=i;}printf("total=%d,i=%d\n",total,i);return 0;
}

??四、一維數(shù)組與字符數(shù)組

1.一維數(shù)組

1.1數(shù)組的定義

數(shù)組，是指一組具 有相同數(shù)據(jù)類(lèi)型的數(shù)據(jù)的有序集合。可通過(guò)一個(gè)符號(hào)來(lái) 訪問(wèn)多個(gè)元素

一維數(shù)組的定義格式為

類(lèi)型說(shuō)明符 數(shù)組名 [常量表達(dá)式];

int a[10];

?定義一個(gè)整型數(shù)組，數(shù)組名為 a，它有 10 個(gè)元素。

?聲明數(shù)組時(shí)要遵循以下規(guī)則：

（1）數(shù)組名的命名規(guī)則和變量名的相同，即遵循標(biāo)識(shí)符命名規(guī)則。

（2）在定義數(shù)組時(shí)，需要指定數(shù)組中元素的個(gè)數(shù)，方括號(hào)中的常量表達(dá)式用來(lái)表示元素的 個(gè)數(shù)，即數(shù)組長(zhǎng)度。

（3）常量表達(dá)式中可以包含常量和符號(hào)常量，但不能包含變量。也就是說(shuō)，C 語(yǔ)言不允許 對(duì)數(shù)組的大小做動(dòng)態(tài)定義，即數(shù)組的大小不依賴(lài)于程序運(yùn)行過(guò)程中變量的值

以下是錯(cuò)誤的聲明示例（最新的 C 標(biāo)準(zhǔn)支持，但是最好不要這么寫(xiě)）：

int n;

scanf("%d", &n); /* 在程序中臨時(shí)輸入數(shù)組的大小 */

int a[n];

數(shù)組聲明的其他常見(jiàn)錯(cuò)誤如下：

① float a[0]; /* 數(shù)組大小為 0 沒(méi)有意義 */

② int b(2)(3); /* 不能使用圓括號(hào) */

③ int k=3, a[k]; /* 不能用變量說(shuō)明數(shù)組大小*/

1.2 一維數(shù)組在內(nèi)存中的存儲(chǔ)

語(yǔ)句 int mark[100];定義的一維數(shù)組 mark 在內(nèi)存中的存放情況如下圖所示，每個(gè)元素都是 整型元素，占用 4 字節(jié)，數(shù)組元素的引用方式是“數(shù)組名[下標(biāo)]”，所以訪問(wèn)數(shù)組 mark 中的元素 的方式是 mark[0],mark[1],…,mark[99]。注意，沒(méi)有元素 mark[100]，因?yàn)閿?shù)組元素是從 0 開(kāi) 始編號(hào)的

一維數(shù)組的初始化方法。

（1）在定義數(shù)組時(shí)對(duì)數(shù)組元素賦初值。例如，

int a[10]={0,1,2,3,4,5,6,7,8,9};

不能寫(xiě)成

int a[10];a[10]={0,1,2,3,4,5,6,7,8,9}

（2）可以只給一部分元素賦值。例如，

int a[10]={0,1,2,3,4};

定義 a 數(shù)組有 10 個(gè)元素，但花括號(hào)內(nèi)只提供 5 個(gè)初值，這表示只給前 5 個(gè)元素賦初值，后 5 個(gè)

元素的值為 0。

（3）如果要使一個(gè)數(shù)組中全部元素的值為 0，那么可以寫(xiě)為

int a[10]={0,0,0,0,0,0,0,0,0,0};

或

int a[10]={0};

（4）在對(duì)全部數(shù)組元素賦初值時(shí)，由于數(shù)據(jù)的個(gè)數(shù)已經(jīng)確定，因此可以不指定數(shù)組的長(zhǎng)度。

int a[]={1,2,3,4,5};

2.數(shù)組的訪問(wèn)越界

下面借助一個(gè)數(shù)組的實(shí)例來(lái)掌握數(shù)組元素的賦值、訪問(wèn)越界。

int main()
{int a[5]={1,2,3,4,5}; //定義數(shù)組時(shí)，數(shù)組長(zhǎng)度必須固定int j=20;int i=10;a[5]=6; //越界訪問(wèn)a[6]=7; //越界訪問(wèn)會(huì)造成數(shù)據(jù)異常printf("i=%d\n",i); //i 發(fā)生改變r(jià)eturn 0;
}

下圖顯示了代碼運(yùn)行情況。在內(nèi)存視圖依次輸入&j、&a、&i 來(lái)查看整型變量 j、整型數(shù)組 a、整型變量 i 的地址，即可看到三個(gè)變量的地址，這里就像我們給衣柜的每個(gè)格子的編號(hào)，第一格、第二格……一直到柜子的最后一格。操作系統(tǒng)對(duì)內(nèi)存中的每個(gè)位置也給予一個(gè)編號(hào)，對(duì)于 Windows 32 位控制臺(tái)應(yīng)用程序來(lái)說(shuō)，這個(gè)編號(hào)的范圍是從 0x00 00 00 00 到 0xFF FF FF FF，總計(jì)為 2 的 32 次方，大小為4G。這些編號(hào)稱(chēng)為地址（我們是 64 位程序，地址顯示的是 64）

在變量窗口中輸入sizeof(a)，可以看到數(shù)組a的大小為20字節(jié)，計(jì)算方法其實(shí)就是sizeof(int)*5： 數(shù)組中有 5 個(gè)整型元素，每個(gè)元素的大小為 4 字節(jié)，所以共有 20 字節(jié)。訪問(wèn)元素的順序是依次從 a[0]到 a[4]，a[5]=6、a[6]=7 均為訪問(wèn)越界。下圖顯示了代碼運(yùn)行情況，從中看出，執(zhí)行到第 12 行時(shí)，變量 i 的值被修改了，這就是訪問(wèn)越界的危險(xiǎn)性——未對(duì)變量 i 賦值，其值卻發(fā)生了改變

數(shù)組另一個(gè)值得關(guān)注的地方是，編譯器并不檢查程序?qū)?shù)組下標(biāo)的引用是否在數(shù)組的合法范圍內(nèi)。如果下標(biāo)值 是通過(guò)那些已知正確的值計(jì)算得來(lái)的，那么就無(wú)須檢查；如果下標(biāo)值是由用戶(hù)輸入的數(shù)據(jù)產(chǎn)生的， 那么在使用它們之前就必須進(jìn)行檢查，以確保它們位于有效范圍內(nèi)。

3.數(shù)組的傳遞

//一維數(shù)組的傳遞，數(shù)組長(zhǎng)度無(wú)法傳遞給子函數(shù)
//C 語(yǔ)言的函數(shù)調(diào)用方式是值傳遞
void print(int b[],int len)
{int i;for(i=0;i<len;i++){printf("%3d",b[i]);}b[4]=20; //在子函數(shù)中修改數(shù)組元素
printf("\n");
}//數(shù)組越界
//一維數(shù)組的傳遞
#define N 5
int main()
{int a[5]={1,2,3,4,5}; //定義數(shù)組時(shí)，數(shù)組長(zhǎng)度必須固定print(a,5);printf("a[4]=%d\n",a[4]); //a[4]發(fā)生改變r(jià)eturn 0;
}

如下圖 1 所示，進(jìn)入 print 函數(shù)，發(fā)現(xiàn)數(shù)組 b 的大小變?yōu)? 字節(jié)，如下圖 2 所示，這是因?yàn)橐痪S數(shù)組在傳遞時(shí)，其長(zhǎng)度是傳遞不過(guò)去的，所以我們通過(guò) len來(lái)傳遞數(shù)組中的元素個(gè)數(shù)。
實(shí)際數(shù)組名中存儲(chǔ)的是數(shù)組的首地址，在調(diào)用函數(shù)傳遞時(shí)，是將數(shù)組的首地址給了變量 b（其實(shí)變量 b 是指針類(lèi)型，指針8個(gè)字節(jié)），在 b[]的方括號(hào)中填寫(xiě)任何數(shù)字都是沒(méi)有意義的。
這時(shí)我們?cè)?print 函數(shù)內(nèi)修改元素 b[4]=20，可以看到數(shù)組 b 的起始地址和 main 函數(shù)中數(shù)組 a 的起始地址相同，即二者在內(nèi)存中位于同一位置，函數(shù)執(zhí)行結(jié)束時(shí)，數(shù)組 a 中的元素 a[4]就得到了修改

4.字符數(shù)組初始化及傳遞

字符數(shù)組的定義方法與前面介紹的一維數(shù)組類(lèi)似。例如，

char c[10];

字符數(shù)組的初始化可以采用以下方式。

（1）對(duì)每個(gè)字符單獨(dú)賦值進(jìn)行初始化。例如，

c[0]='I';c[1]=' ';c[2]='a';c[3]='m';c[4]='';c[5]='h';c[6]='a';c[7]='p';c[8]='p';c[9]='y';

（2）對(duì)整個(gè)數(shù)組進(jìn)行初始化。例如，

char c[10]={'I','a','m','h','a','p','p','y'}

但工作中一般不用以上兩種初始化方式，因?yàn)樽址麛?shù)組一般用來(lái)存取字符串。通常采用的初始化方式是 char c[10]= "hello"。因?yàn)?C 語(yǔ)言規(guī)定字符串的結(jié)束標(biāo)志為'\0'，而系統(tǒng)會(huì)對(duì)字符串常量自動(dòng)加一個(gè)'\0'，為了保證處理方法一致，一般會(huì)人為地在字符數(shù)組中添加'\0'，所以字符數(shù)組存儲(chǔ)的字符串長(zhǎng)度必須比字符數(shù)組少 1 字節(jié)。例如，char c[10]最長(zhǎng)存儲(chǔ) 9 個(gè)字符，剩余的 1個(gè)字符用來(lái)存儲(chǔ)'\0'。

【例】字符數(shù)組初始化及傳遞
#include <stdio.h>
//print 函數(shù)模擬實(shí)現(xiàn) printf 的%s 打印效果
void print(char c[])
{int i=0;while(c[i]){printf("%c",c[i]);//當(dāng) c[i]為'\0'時(shí)，其值是 0，循環(huán)結(jié)束，也可以寫(xiě)為 c[i]!='\0'。i++;}
printf("\n");
}//字符數(shù)組存儲(chǔ)字符串，必須存儲(chǔ)結(jié)束符'\0' 
int main()
{char c[5]={'h','e','l','l','o'};char d[5]="how";printf("%s\n",c); //會(huì)發(fā)現(xiàn)打印了亂碼 ，printf 通過(guò)%s 打印字符串時(shí)，原理是依次輸出每個(gè)字符，當(dāng)讀到結(jié)束符'\0'時(shí)，結(jié)束打印；printf("%s\n",d);print(d);return 0;
}

?5.scanf 讀取字符串

#include <stdio.h>
//scanf 讀取字符串時(shí)使用%s
int main()
{char c[10];char d[10];scanf("%s",c);printf("%s\n",c);scanf("%s%s",c,d);printf("c=%s,d=%s\n",c,d);return 0;
}

scanf 通過(guò)%s 讀取字符串，對(duì) c 和 d 分別輸入"are"和"you"（中間加一個(gè)空格），scanf在使用%s 讀取字符串時(shí)，會(huì)忽略空格和回車(chē)（這一點(diǎn)與%d 和%f 類(lèi)似）。
輸入順序及執(zhí)行結(jié)果如下圖

6.gets 函數(shù)與 puts 函數(shù)

gets 函數(shù)類(lèi)似于 scanf 函數(shù)，用于讀取標(biāo)準(zhǔn)輸入。 scanf 函數(shù)在讀取字符串時(shí)遇到空格就認(rèn)為讀取結(jié)束，所以當(dāng)輸入的字符串存在空格時(shí)，需要使用 gets 函數(shù)進(jìn)行讀取。gets 函數(shù)的格式如下：

char *gets(char *str);

puts 函數(shù)類(lèi)似于 printf 函數(shù)，用于輸出標(biāo)準(zhǔn)輸出。puts 函數(shù)的格式如下：

int puts(char *str);

函數(shù) puts 把 str（字符串）寫(xiě)入 STDOU（標(biāo)準(zhǔn)輸出）。puts 會(huì)將數(shù)組 c 中存儲(chǔ)的"how areyou"字符串打印到屏幕上，同時(shí)打印換行，相對(duì)于 printf 函數(shù)，puts 只能用于輸出字符串，同時(shí)多打印一個(gè)換行符，等價(jià)于 printf(“%s\n”,c)

//gets 一次讀取一行
int main()
{char c[20];gets(c);puts(c);return 0;
}

7.str 系列字符串操作函數(shù)（機(jī)試重要）

str 系列字符串操作函數(shù)主要包括 strlen、strcpy、strcmp、strcat 等。
strlen 函數(shù)用于統(tǒng)計(jì)字符串長(zhǎng)度，
strcpy 函數(shù)用于將某個(gè)字符串復(fù)制到字符數(shù)組中，
strcmp 函數(shù)用于比較兩個(gè)字符串的大小，
strcat 函數(shù)用于將兩個(gè)字符串連接到一起。
各個(gè)函數(shù)的具體格式如下所示：

#include <string.h> //引入頭文件size_t strlen(char *str);
char *strcpy(char *to, const char *from);
int strcmp(const char *str1, const char *str2);
char *strcat(char *str1, const char *str2);

對(duì)于傳參類(lèi)型 char*，直接放入字符數(shù)組的數(shù)組名即可。

#include <stdio.h>
#include <string.h>
//str 系列字符串操作函數(shù)的使用。
int mystrlen(char c[]) {int i = 0;while (c[i++]);return i - 1;
}
//strlen 統(tǒng)計(jì)字符串長(zhǎng)度int main() {int len; //用于存儲(chǔ)字符串長(zhǎng)度char c[20];char d[100] = "world";gets(c);puts(c);len = strlen(c);printf("len=%d\n", len);len = mystrlen(c);printf("mystrlen len=%d\n", len);strcat(c, d);strcpy(d, c); //c 中的字符串復(fù)制給 dputs(d);printf("c?d %d\n", strcmp(c, d));puts(c);return 0;
}

下圖所示為我們輸入"hello"后的執(zhí)行結(jié)果

???五、指針

5.1 指針的定義

內(nèi)存區(qū)域中的每字節(jié)都對(duì)應(yīng)一個(gè)編號(hào)，這個(gè)編號(hào)就是“地址”.
在程序中定義一個(gè)變量，在對(duì)程序進(jìn)行編譯時(shí)，系統(tǒng)就會(huì)給這個(gè)變量分配內(nèi)存單元.
按變量地址存取變量值的方式稱(chēng)為“直接訪問(wèn)”，如printf(""%d",i);、 scanf("%d",&i);等，
另一種存取變量值的方式稱(chēng)為“間接訪問(wèn)”，即將變量i的地址存放到另一個(gè)變量中.
在C語(yǔ)言中，指針變量是一種特殊的變量，它用來(lái)存放變量地址。
指針變量的定義格式如下:

基類(lèi)型? *指針變量名;

例如

int *i_pointer;?

指針與指針變量是兩個(gè)概念，一個(gè)變量的“地址”成為該變量的“指針”
用來(lái)存放一個(gè)變量的地址(即指針)的變量，稱(chēng)為“指針變量”
如下圖的i_pointer，在64位應(yīng)用程序中，sizeof(i_pointer)=8,即占8個(gè)字節(jié)
如果考研強(qiáng)調(diào)程序是32位的，則尋址范圍為4字節(jié)?

5.2 取地址操作符與取值操作符，指針本質(zhì)

取地址操作符為&，也稱(chēng)引用，通過(guò)&可以獲取一個(gè)變量的地址值;
取值操作符為*，也稱(chēng)解引用，通過(guò)*可以得到一個(gè)地址對(duì)應(yīng)的數(shù)據(jù)。
如下例，通過(guò)&i獲取整型變量i的地址值，然后對(duì)整型指針變量p進(jìn)行初始化, p中存儲(chǔ)的是整型變量i的地址值，所以通過(guò)*p(printf 函數(shù)中的*p)就可以獲取整型變量i的值. p中存儲(chǔ)的是一個(gè)絕對(duì)地址值,

#include <stdio.h>int main() {int i=5;//定義了一個(gè)指針變量，i_pointer就是指針變量名//指針變量的初始化一定是某個(gè)變量取地址來(lái)賦值，不能隨機(jī)寫(xiě)個(gè)數(shù)int *i_pointer;i_pointer=&i;printf("i=%d\n",i); //直接訪問(wèn)printf("*i_pointor=%d",*i_pointer);return 0;
}

注意：

(1）指針變量前面的“*”表示該變量為指針型變量。
例如，float *pointer_1;
指針變量名是pointer_1 ,而不是*pointer_1.
(2）在定義指針變量時(shí)必須指定其類(lèi)型。只有整型變量的地址才能放到指向整型變量的指針變量中。例如，下面的賦值是錯(cuò)誤的:
float a;
int * pointer_1;
pointer_1=&a;//毫無(wú)意義而且會(huì)出錯(cuò)
(3）如果已執(zhí)行了語(yǔ)句
pointer_1=&a; 那&*pointer_1與&a相同，都表示變量a的地址，即pointer_1
即雖然”&“和”*“兩個(gè)運(yùn)算符的優(yōu)先級(jí)相同，但是要按自右向左的方向結(jié)合

*&a表示，先進(jìn)行&a的運(yùn)算，得到a的地址，在進(jìn)行*運(yùn)算,*&a和*pointer_1的作用一樣，都等價(jià)于變量a,即*&a與a等價(jià)

int *a,b,c;表示聲明了一個(gè)指針變量，兩個(gè)int變量
要聲明三個(gè)指針變量需要寫(xiě)成

int *a,*b,*c;

指針的使用場(chǎng)景只有兩個(gè)，即傳遞和偏移

5.3 指針的傳遞?

下例的主函數(shù)通過(guò)子函數(shù)改變量i的值，但是執(zhí)行程序后發(fā)現(xiàn)i的值并未發(fā)生改變
因?yàn)閕的地址和j的地址實(shí)際并不相同，執(zhí)行change函數(shù)改變的并不是之前定義的i的地址

#include <stdio.h>
void change(int j){ //j是形參j=5;
}
int main() {int i=10;printf("before value i=%d\n",i);//在子函數(shù)內(nèi)去改變主函數(shù)的某個(gè)變量值change(i); //C語(yǔ)言的函數(shù)調(diào)用是值傳遞，實(shí)參賦值給形參，j=iprintf("after value i=%d\n",i);return 0;
}//輸出結(jié)果都是10

原理如下圖所示，程序的執(zhí)行過(guò)程其實(shí)就是內(nèi)存的變化過(guò)程，當(dāng)main函數(shù)執(zhí)行時(shí)，系統(tǒng)會(huì)為其開(kāi)辟函數(shù)?？臻g，當(dāng)程序走到int i時(shí)，main函數(shù)的棧空間就會(huì)為變量i分配4字節(jié)大小的空間，調(diào)用change函數(shù)時(shí)，系統(tǒng)會(huì)為change函數(shù)重新分配新的函數(shù)?？臻g，并為形參變量j分配4字節(jié)大小的空間，調(diào)用change(i)實(shí)際是將i的值賦值給j,這就是值傳遞，當(dāng)change()中修改變量j的值后，函數(shù)執(zhí)行結(jié)束，其?？臻g就會(huì)釋放，j就不再存在，i的值不會(huì)改變。

要在子函數(shù)中修改main函數(shù)的值，如下所示，通過(guò)指針進(jìn)行操作?

#include <stdio.h>
void change(int *j){ //j是形參*j=5;    //間接訪問(wèn)得到變量i  *j等價(jià)于變量i
}//指針的傳遞
int main() {int i=10;printf("before value i=%d\n",i);change(&i);     //傳遞變量i的地址  j=&iprintf("after value i=%d\n",i);return 0;
}//執(zhí)行change()后，打印的i的值為5

變量i的地址傳遞給change函數(shù)時(shí)，實(shí)際效果是j=&i,依然是值傳遞，只是這時(shí)候的j是一個(gè)指針變量，內(nèi)部存儲(chǔ)的是變量i的地址，所以通過(guò)*j就間接訪問(wèn)到了與變量i相同的區(qū)域，通過(guò)*j=5就實(shí)現(xiàn)了對(duì)變量i的值的改變。

5.4?指針的偏移使用場(chǎng)景

5.4.1 指針的偏移

拿到指針變量后可以對(duì)他進(jìn)行加減，如找到一棟樓是2棟，那往前就是1棟，往后就是3棟

#include <stdio.h>
//指針的偏移使用場(chǎng)景，也就是對(duì)指針進(jìn)行加減
#define N 5  //符號(hào)常量N
int main() {int a[N]={1,2,3,4,5}; //數(shù)組名內(nèi)存中存儲(chǔ)了數(shù)組的起始地址，a中存儲(chǔ)的就是一個(gè)地址值int *p;//定義指針變量pp=a;//不是取地址a 因?yàn)閿?shù)組名中本來(lái)就有地址int i;for(i=0;i<N;i++){printf("%3d",*(p+i)); //這里*（p+i)和a[i]的結(jié)果是等價(jià)的}printf("\n-------------------------------\n");p=&a[4];    //讓p指向最后一個(gè)元素for(i=0;i<N;i++){   //逆序輸出printf("%3d",*(p-i));}printf("\n");return 0;
}

? 1 ?2 ?3 ?4 ?5
-------------------------------
? 5 ?4 ?3 ?2 ?1

如下圖所示，數(shù)組名中存儲(chǔ)著數(shù)組的起始地址Ox61fdf0，其類(lèi)型為整型指針，所以可以將其賦值給整型指針變量p，可以從監(jiān)視窗口中看到p+1的值為Ox61fdf4．指針變量加1后，偏移的長(zhǎng)度是其基類(lèi)型的長(zhǎng)度，也就是偏移sizeof(int)，這樣通過(guò)*p+1就可以得到元素a[1]。編譯器在編譯時(shí)，數(shù)組取下標(biāo)的操作正是轉(zhuǎn)換為指針偏移來(lái)完成?

float *p; p的加減也是偏移4個(gè)字節(jié)??

?5.4.2?指針與一維數(shù)組

一維數(shù)組中存儲(chǔ)的是數(shù)組的首地址，如下例中數(shù)組名c中存儲(chǔ)的是一個(gè)起始地址，所以子函數(shù)change中其實(shí)傳入了一個(gè)地址，定義一個(gè)指針變量時(shí)，指針變量的類(lèi)型要和數(shù)組的數(shù)據(jù)類(lèi)型保持一致，通過(guò)取值操作，可以將“h”改為“H”,這種方法稱(chēng)為指針?lè)?#xff0c;獲取數(shù)組元素時(shí)，也可以通過(guò)取下標(biāo)的方式來(lái)獲取數(shù)組元素并進(jìn)行修改，這種方法稱(chēng)為下標(biāo)法。

#include <stdio.h>
//指針與一維數(shù)組的的傳遞
//數(shù)組名作為實(shí)參傳遞給子函數(shù)時(shí)，是弱化為指針的 (指針默認(rèn)就是8個(gè)字節(jié))
//練習(xí)傳遞與偏移void change(char *d){*d='H';d[1]='E';   //*(d+1)='E'與其等價(jià)*(d+2)='L';*(d+3)='L';*(d+4)='O';
}
int main(){char c[10]="hello";change(c);puts(c);return 0;
}

5.6指針與malloc動(dòng)態(tài)內(nèi)存申請(qǐng)，棧與堆的差異

5.6.1 指針與動(dòng)態(tài)內(nèi)存申請(qǐng)

C語(yǔ)言的數(shù)組長(zhǎng)度固定，因?yàn)槠涠x的整型、浮點(diǎn)型、字符型變量、數(shù)組變量都在棧空間中，而?？臻g的大小在編譯時(shí)是確定的，如果使用的空間大小不確定，就要使用堆空間。

#include <stdio.h>
#include <stdlib.h> //malloc使用的頭文件
#include <string.h> //strcpy使用的頭文件
int main() {int size;//代表要申請(qǐng)多大字節(jié)的空間char *p;//void*類(lèi)型的指針是不能偏移的，不能進(jìn)行加減 ，因此不會(huì)定義無(wú)類(lèi)型指針scanf("%d",&size);  //輸入要申請(qǐng)的空間大小//malloc返回的void*代表無(wú)類(lèi)型指針p= (char*)malloc(size); //malloc返回的是對(duì)應(yīng)空間起始地址 要強(qiáng)轉(zhuǎn)malloc的類(lèi)型與p一致strcpy(p,"malloc success");//strcpy傳進(jìn)去的也是指針類(lèi)型的 所以可以直接copyputs(p);free(p);//釋放申請(qǐng)的空間時(shí)，必須是最初malloc返回給我們的地址  即free的時(shí)候p不能變 不能填p+1這種 會(huì)異常printf("free success\n");return 0;
}

注意：指針本身的大小和其指向空間的大小是兩碼事，指針本身大小只跟操作系統(tǒng)的位數(shù)有關(guān),指向空間的大小是字節(jié)定義的，需要定義變量單獨(dú)存儲(chǔ)

5.6.2 ?？臻g與堆空間的差異

棧是計(jì)算機(jī)系統(tǒng)提供的數(shù)據(jù)結(jié)構(gòu)，計(jì)算機(jī)會(huì)在底層對(duì)棧提供支持，分配專(zhuān)門(mén)的寄存器存放棧的地址，操作都有專(zhuān)門(mén)的指令執(zhí)行，所以棧的效率比較高。

堆則是C/C++函數(shù)庫(kù)提供的數(shù)據(jù)結(jié)構(gòu)，它的機(jī)制很復(fù)雜，例如為了分配一塊內(nèi)存，庫(kù)函數(shù)會(huì)按照一定的算法在堆內(nèi)存中搜索可用的足夠大小的空間，如果沒(méi)有足夠大小的空間就可能調(diào)用系統(tǒng)功能去增加程序數(shù)據(jù)段的內(nèi)存空間，堆的效率要比棧低得多。

棧不能動(dòng)態(tài)，所以要?jiǎng)討B(tài)還是要使用堆，注意堆使用完要用free釋放

#include <stdio.h>
#include <stdlib.h> //malloc使用的頭文件
#include <string.h> //strcpy使用的頭文件
//堆和棧的差異
char* print_stack(){char c[100]="I am print_stack func"; //c中存了數(shù)組的起始地址char *p;p=c;puts(p);return p;
}
char* print_malloc(){char *p=(char*) malloc(100); //堆空間在整個(gè)進(jìn)程中一直有效，不因?yàn)楹瘮?shù)結(jié)束消亡strcpy(p,"I am print_stack func");puts(p);return p;
}
int main(){char *p;p=print_stack(); //調(diào)用函數(shù)執(zhí)行完之后，操作系統(tǒng)就會(huì)直接釋放掉這個(gè)?？臻gputs(p);//p接到了print_stack()的指針 打印亂碼或nullp=print_malloc();puts(p);free(p);//只有free的時(shí)候，堆空間才會(huì)釋放return 0;
}/*
int main() {int size;//代表要申請(qǐng)多大字節(jié)的空間char *p;//void*類(lèi)型的指針是不能偏移的，不能進(jìn)行加減 ，因此不會(huì)定義無(wú)類(lèi)型指針scanf("%d",&size);  //輸入要申請(qǐng)的空間大小//malloc返回的void*代表無(wú)類(lèi)型指針p= (char*)malloc(size); //malloc返回的是對(duì)應(yīng)空間起始地址 要強(qiáng)轉(zhuǎn)malloc的類(lèi)型與p一致strcpy(p,"malloc success");//strcpy傳進(jìn)去的也是指針類(lèi)型的 所以可以直接copyputs(p);free(p);//釋放申請(qǐng)的空間時(shí)，必須是最初malloc返回給我們的地址  即free的時(shí)候p不能變 不能填p+1這種 會(huì)異常printf("free success\n");return 0;
}
*/

六、函數(shù)

6.1 函數(shù)的聲明與定義—嵌套調(diào)用

6.1.1 函數(shù)的聲明與定義

?函數(shù)間的調(diào)用關(guān)系是，由主函數(shù)調(diào)用其他函數(shù)，其他函數(shù)也可以互相調(diào)用，同一個(gè)函數(shù)可以背一個(gè)或多個(gè)函數(shù)調(diào)用任意次。

?下例中有兩個(gè)c文件, func.c是子函數(shù)printstar和print_message 的實(shí)現(xiàn),也稱(chēng)定義; main.c是main函數(shù), func.h中存放的是標(biāo)準(zhǔn)頭文件的聲明和 main函數(shù)中調(diào)用的兩個(gè)子函數(shù)的聲明，如果不在頭文件中對(duì)使用的函數(shù)進(jìn)行聲明，那么在編譯時(shí)會(huì)出現(xiàn)警告。
【例1】函數(shù)的嵌套調(diào)用

func.c
#include "func.h"int main() {int a=10;a=print_star(a);print_message();//調(diào)用print_messageprint_star(5);return 0;
}

func.h#ifndef FUNCTION_DEFINE_FUNC_H
#define FUNCTION_DEFINE_FUNC_H
#include <stdio.h> //都需要用到這個(gè)頭文件 就都統(tǒng)一寫(xiě)在這里就行 <>表示從標(biāo)準(zhǔn)庫(kù)中找頭文件
void print_message();   //print_message函數(shù)的聲明
int print_star(int i); //print_star函數(shù)聲明。有形參，有返回值
#endif //FUNCTION_DEFINE_FUNC_H

main.c
#include "func.h"  //“”表示在當(dāng)前路徑下找頭文件//print_star的定義
int print_star(int i){printf("************************\n");printf("print_star %d\n",i);return i+3;
}void print_message(){printf("how do you do\n");print_star(6); //調(diào)用print_star
}

C語(yǔ)言的編譯和執(zhí)行有以下特點(diǎn)：
(1)一個(gè)C程序由一個(gè)或多個(gè)程序模塊組成，每個(gè)程序模塊作為一個(gè)源程序文件。對(duì)于較大的程序，通常將程序內(nèi)容分別放在若干源文件中，再由若干源程序文件組成一個(gè)C程序。這樣處理便于分別編寫(xiě)、分別編譯，進(jìn)而提高調(diào)試效率(復(fù)試有用)．一個(gè)源程序文件可以為多個(gè)C程序共用。
(2）一個(gè)源程序文件由一個(gè)或多個(gè)函數(shù)及其他有關(guān)內(nèi)容(如命令行、數(shù)據(jù)定義等）組成.一個(gè)源程序文件是一個(gè)編譯單位,在程序編譯時(shí)是以源程序文件為單位而不是以函數(shù)為單位進(jìn)行編譯的.main.c和 func.c分別單獨(dú)編譯,在鏈接成為可執(zhí)行文件時(shí), main中調(diào)用的函數(shù)printstar和 print_message才會(huì)通過(guò)鏈接去找到函數(shù)定義的位置.
(3)C程序的執(zhí)行是從 main函數(shù)開(kāi)始的，如果在main函數(shù)中調(diào)用其他函數(shù),那么在調(diào)用后會(huì)返回到main函數(shù)中，在 main函數(shù)中結(jié)束整個(gè)程序的運(yùn)行.
(4)所有函數(shù)都是平行的，即在定義函數(shù)時(shí)是分別進(jìn)行的，并且是互相獨(dú)立的。一個(gè)函數(shù)并不從屬于另一函數(shù)，即函數(shù)不能嵌套定義，函數(shù)間可以互相調(diào)用，但不能調(diào)用main函數(shù).main函數(shù)是由系統(tǒng)調(diào)用的,例1.1的 main 函數(shù)中調(diào)用print_message 函數(shù),而 print_message函數(shù)中又調(diào)用printstar 函數(shù).我們把這種調(diào)用稱(chēng)為嵌套調(diào)用.?

6.1.2 函數(shù)的分類(lèi)與調(diào)用?

函數(shù)分為如下兩種
(1)標(biāo)準(zhǔn)函數(shù):即庫(kù)函數(shù)，由系統(tǒng)提供的可以直接使用的，如 printf函數(shù)、scanf 函數(shù).不同的C系統(tǒng)提供的庫(kù)函數(shù)的數(shù)量和功能會(huì)有一些不同，但許多基本的函數(shù)是相同的。
(2)用戶(hù)自己定義的函數(shù):用以解決用戶(hù)的專(zhuān)門(mén)需要.從函數(shù)的形式看,函數(shù)分為如下兩類(lèi).
? ?a.無(wú)參函數(shù):一般用來(lái)執(zhí)行指定的一組操作.調(diào)用無(wú)參函數(shù)時(shí),主調(diào)函數(shù)不向被調(diào)用函數(shù)傳遞數(shù)據(jù)。
? ?無(wú)參函數(shù)的定義形式如下:

類(lèi)型標(biāo)識(shí)符 函數(shù)名()
{聲明部分語(yǔ)句部分
}

? 例1中, print_message就是無(wú)參函數(shù)。
? b.有參函數(shù):主調(diào)函數(shù)在調(diào)用被調(diào)用函數(shù)時(shí)，通過(guò)參數(shù)向被調(diào)用函數(shù)傳遞數(shù)據(jù)。
? 有參函數(shù)的定義形式如下:

類(lèi)型標(biāo)識(shí)符函數(shù)名(形式參數(shù)表列)
{聲明部分語(yǔ)句部分
}

? 例1中,printstar就是有參函數(shù),int i對(duì)應(yīng)的i為形參,主調(diào)函數(shù)和被調(diào)用函數(shù)之間存在數(shù)據(jù)傳遞關(guān)系。

6.2 函數(shù)的遞歸調(diào)用

6.2.1 遞歸調(diào)用

函數(shù)自身調(diào)用自身的操作，稱(chēng)為遞歸函數(shù)，遞歸函數(shù)一定要有結(jié)束條件，否則會(huì)產(chǎn)生死循環(huán)!
【例1】n的階乘的遞歸調(diào)用實(shí)現(xiàn)。
分析：f(n)=n*f(n-1); 如5!=5*4!

#include <stdio.h>int f(int n){//一定要有結(jié)束條件if(1==n){return 1;}return n*f(n-1);    //寫(xiě)公式
}int main() {int n;scanf("%d",&n);printf("f(%d)=%d\n",n, f(n));return 0;
}

【例2】假如有n個(gè)臺(tái)階，一次只能上1個(gè)臺(tái)階或2個(gè)臺(tái)階，請(qǐng)問(wèn)走到第n個(gè)臺(tái)階有幾種走法?

#include <stdio.h>
//上臺(tái)階 ,到第n個(gè)臺(tái)階 一次只能上一個(gè)或兩個(gè),有多少種走法
//分析 step(3)=step(2)+step(1)
//    3 = 2 + 1
int step(int n){if(1==n||2==n){//當(dāng)臺(tái)階是1個(gè)或2個(gè)時(shí)，遞歸結(jié)束，一個(gè)臺(tái)階只有一種走法，2個(gè)臺(tái)階只有兩種走法return n;}return  step(n-1)+ step(n-2);
}int main(){int n;scanf("%d",&n);printf("step(%d)=%d",n, step(n));return 0;
}

?遞歸的核心：找公式，寫(xiě)遞歸結(jié)束條件。

6.3 局部變量與全局變量

6.3.1 全局變量解析-形參-實(shí)參解析

在不同的函數(shù)之間傳遞數(shù)據(jù)時(shí)，可以使用的方法如下:
(1)參數(shù):通過(guò)形式參數(shù)和實(shí)際參數(shù)。
(2)返回值:用return 語(yǔ)句返回計(jì)算結(jié)果。
(3)全局變量:外部變量。

#include <stdio.h>int i=10;//i是一個(gè)全局變量,不建議使用 局部變量全局變量重名不會(huì)報(bào)錯(cuò) 容易搞錯(cuò)
void print(int a)//形參看成一個(gè)局部變量
{printf("I am print i=%d\n",i);
}int main() {{int j=5;}//局部變量只在離自己最近的大括號(hào)內(nèi)有效int i=5;printf("main i=%d\n",i);for(int k=0;k<-1;){}
//    printf("k=%d\n",k);for循環(huán)括號(hào)內(nèi)定義的變量，循環(huán)體外不可用print(3);return 0;
}

全局變量存儲(chǔ)，如下圖所示，全局變量i存儲(chǔ)在數(shù)據(jù)段，所以main函數(shù)和 print函數(shù)都是可見(jiàn)的。全局變量不會(huì)因?yàn)槟硞€(gè)函數(shù)執(zhí)行結(jié)束而消失,在整個(gè)進(jìn)程的執(zhí)行過(guò)程中始終有效，因此工作中應(yīng)盡量避免使用全局變量！
在函數(shù)內(nèi)定義的變量都稱(chēng)為局部變量，局部變量存儲(chǔ)在自己的函數(shù)對(duì)應(yīng)的棧空間內(nèi)，函數(shù)執(zhí)行結(jié)束后，函數(shù)內(nèi)的局部變量所分配的空間將會(huì)得到釋放。如果局部變量與全局變量重名，那么將采取就近原則，即實(shí)際獲取和修改的值是局部變量的值.

形參與實(shí)參的說(shuō)明如下：
(1)定義函數(shù)中指定的形參，如果沒(méi)有函數(shù)調(diào)用，那并不占用內(nèi)存中的存儲(chǔ)單元。只有發(fā)生函數(shù)調(diào)用時(shí)，函數(shù)print 中的形參才被分配內(nèi)存單元。在調(diào)用結(jié)束后，形參所占的內(nèi)存單元也會(huì)被釋放。
(2)實(shí)參可以是常量、變量或表達(dá)式，但要求它們有確定的值，例如, print(i+3)在調(diào)用時(shí)將實(shí)參的值i+3賦給形參。print函數(shù)可以有兩個(gè)形參，如 print( inta,int b)
(3)在被定義的函數(shù)中，必須指定形參的類(lèi)型.如果實(shí)參列表中包含多個(gè)實(shí)參，那么各參數(shù)間用逗號(hào)隔開(kāi)。實(shí)參與形參的個(gè)數(shù)應(yīng)相等，類(lèi)型應(yīng)匹配，且實(shí)參與形參應(yīng)按順序?qū)?yīng)，一一傳遞數(shù)據(jù)。
(4)實(shí)參與形參的類(lèi)型應(yīng)相同或賦值應(yīng)兼容。
(5)實(shí)參向形參的數(shù)據(jù)傳遞是單向“值傳遞”，只能由實(shí)參傳給形參，而不能由形參傳回給實(shí)參．在調(diào)用函數(shù)時(shí)，給形參分配存儲(chǔ)單元，并將實(shí)參對(duì)應(yīng)的值傳遞給形參，調(diào)用結(jié)束后，形參單元被釋放,實(shí)參單元仍保留并維持原值.
(6)形參相當(dāng)于局部變量，因此不能再定義局部變量與形參同名，否則會(huì)造成編譯不通。

6.3.2 外部變量

函數(shù)之外定義的變量稱(chēng)為外部變量.外部變量可以為本文件中的其他函數(shù)共用，它的有效范圍是從定義變量的位置開(kāi)始到本源文件結(jié)束,所以也稱(chēng)全程變量。
關(guān)于全局變量需要注意如下幾點(diǎn)：
(1)全局變量在程序的全部執(zhí)行過(guò)程中都占用存儲(chǔ)單元，而不是僅在需要時(shí)才開(kāi)辟單元。
(2)使用全局變量過(guò)多會(huì)降低程序的清晰性。在各個(gè)函數(shù)執(zhí)行時(shí)都可能改變外部變量的值,程序容易出錯(cuò)，因此要有限制地使用全局變量(初試時(shí)盡量不用)。
(3)因?yàn)楹瘮?shù)在執(zhí)行時(shí)依賴(lài)于其所在的外部變量，如果將一個(gè)函數(shù)移到另一個(gè)文件中，那么還要將有關(guān)的外部變量及其值一起移過(guò)去。然而，如果該外部變量與其他文件的變量同名，那么
就會(huì)出現(xiàn)問(wèn)題，即會(huì)降低程序的可靠性和通用性.C語(yǔ)言一般要求把程序中的函數(shù)做成一個(gè)封閉體，除可以通過(guò)“實(shí)參→形參”的渠道與外界發(fā)生聯(lián)系外，沒(méi)有其他渠道.

七、結(jié)構(gòu)體與C++引用

7.1?結(jié)構(gòu)體的定義、初始化、結(jié)構(gòu)體數(shù)組

C 語(yǔ)言提供結(jié)構(gòu)體來(lái)管理不同類(lèi)型的數(shù)據(jù)組合。通過(guò)將不同類(lèi)型的數(shù)據(jù)組合成一個(gè)整體，方便引用
例如，一名學(xué)生有學(xué)號(hào)、姓 名、性別、年齡、地址等屬性，如果針對(duì)學(xué)生的學(xué)號(hào)、姓名、年齡等都單獨(dú)定義一個(gè)變量，那么在有多名學(xué)生時(shí)，變量就難以分清。就可通過(guò)結(jié)構(gòu)體來(lái)管理

聲明一個(gè)結(jié)構(gòu)體類(lèi)型的一般形式為

struct 結(jié)構(gòu)體名 {成員表列};

struct student 
{ int num;char name[20];char sex; int age;float score;char addr[30]; 
};

先聲明結(jié)構(gòu)體類(lèi)型，再定義變量名。

 struct student student1,student2;

【例1】結(jié)構(gòu)體的scanf讀取和輸出

#include <stdio.h>struct student{int num;char name[20];char sex;int age;float score;char addr[30];
};//結(jié)構(gòu)體類(lèi)型聲明，注意最后一定要加分號(hào)int main() {struct student s={1001,"lele",'M',20,85.4,"Shenzhen"};struct student sarr[3];//定義一個(gè)結(jié)構(gòu)體數(shù)組變量int i;//結(jié)構(gòu)體輸出必須單獨(dú)去訪問(wèn)內(nèi)部的每個(gè)成員s.num=1003; //單獨(dú)賦值 輸出的值會(huì)改變printf("%d %s %c %d %f %s\n",s.num,s.name,s.sex,s.age,s.score,s.addr);printf("--------------------------------------\n");
//    scanf("%d%s %c%d%f%s",&s.num,s.name,&s.sex,&s.age,&s.score,s.addr);for(i=0;i<3;i++){scanf("%d%s %c%d%f%s",&sarr[i].num,sarr[i].name,&sarr[i].sex,&sarr[i].age,&sarr[i].score,sarr[i].addr);}for(i=0;i<3;i++)//結(jié)構(gòu)體數(shù)組的輸出{printf("%d %s %c %d %f %s\n",sarr[i].num,sarr[i].name,sarr[i].sex,sarr[i].age,sarr[i].score,sarr[i].addr);}return 0;
}

結(jié)構(gòu)體類(lèi)型聲明要放在 main 函數(shù)之前，這樣 main 函數(shù)中才可以使用這個(gè)結(jié)構(gòu)體，工作中往往把結(jié)構(gòu)體聲明放在頭文件中。
注意，結(jié)構(gòu)體類(lèi)型聲明最后一定要加分號(hào)，否則會(huì)編譯不通。 定義結(jié)構(gòu)體變量時(shí)，使用 struct student 來(lái)定義，不能只有 struct 或 student，否則也會(huì)編譯不通。
結(jié)構(gòu)體的初始化只能在一開(kāi)始定義，如果 struct student s={1001,"lele",'M',20,85.4,"Shenzhen"}已經(jīng)執(zhí)行，即 struct student s 已經(jīng)定義，就不能再執(zhí) 行 s={1001,"lele",'M',20,85.4,"Shenzhen"}
整型數(shù)據(jù)（%d）、浮點(diǎn)型數(shù)據(jù)（%f）、字符串型數(shù)據(jù)（%s）都會(huì)忽略空格，但字符型數(shù)據(jù)（%c）不會(huì)忽略空格，所以讀取字符型數(shù)據(jù)就要在待讀取的字符數(shù)據(jù)與其他數(shù)據(jù)之間加入空格。

7.2 結(jié)構(gòu)體對(duì)齊

結(jié)構(gòu)體本身的對(duì)齊規(guī)則，考研初試只需要記住，結(jié)構(gòu)體的大小必須是其最大成員的整數(shù)倍

結(jié)構(gòu)體對(duì)齊，是為了cpu高效的去取內(nèi)存中上的數(shù)據(jù)

#include <stdio.h>struct student_type1{double score;//double是一種浮點(diǎn)類(lèi)型，8個(gè)字節(jié)，浮點(diǎn)分為float和double，float占4個(gè)字節(jié)，記住有這兩種即可short age;//short 是整型，占2個(gè)字節(jié)
};struct student_type2{double score;int height;//如果兩個(gè)小存儲(chǔ)之和是小于最大長(zhǎng)度8，那么它們就結(jié)合在一起short age;
};struct student_type3{int height; //4個(gè)字節(jié)char sex;short age;
};
//結(jié)構(gòu)體對(duì)齊
int main() {struct student_type1 s1;struct student_type2 s2={1,2,3};struct student_type3 s3;printf("s1 size=%d\n",sizeof(s1));printf("s2 size=%d\n",sizeof(s2));printf("s3 size=%d\n",sizeof(s3));return 0;
}

注意：兩個(gè)小存儲(chǔ)挨在一起且和小于最大長(zhǎng)度，那兩個(gè)小存儲(chǔ)就結(jié)合在一起看?

s1 size=16? ?//double8 + short 8
s2 size=16? ?//double>int+short 所以長(zhǎng)度為?double8 + (int+short)8
s3 size=8? ? ?//int>char+short 所以長(zhǎng)度為 int 4 + (char+short)4

7.3 結(jié)構(gòu)體指針與typedef的使用

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

一個(gè)結(jié)構(gòu)體變量的指針就是該變量所占據(jù)的內(nèi)存段的起始地址?？梢栽O(shè)置一個(gè)指針變量，用它指向一個(gè)結(jié)構(gòu)體變量，此時(shí)該指針變量的值是結(jié)構(gòu)體變量的起始地址。指針變量也可以用來(lái)指向結(jié)構(gòu)體數(shù)組中的元素，從而能夠通過(guò)結(jié)構(gòu)體指針快速訪問(wèn)結(jié)構(gòu)體內(nèi)的每個(gè)成員。

#include <stdio.h>struct student{int num;char name[20];char sex;
};
//結(jié)構(gòu)體指針的練習(xí)
int main() {struct student s={1001,"wangle",'M'};struct student sarr[3]={1001,"lilei",'M',1005,"zhangsan",'M',1007,"lili",'F'};struct student *p;//定義了一個(gè)結(jié)構(gòu)體指針變量p=&s;//*p要加括號(hào)去訪問(wèn)元素是因?yàn)?的優(yōu)先級(jí)比*高，如果不加括號(hào)就會(huì)報(bào)錯(cuò)printf("%d %s %c\n",(*p).num,(*p).name,(*p).sex);//方式1訪問(wèn)通過(guò)指針對(duì)象去訪問(wèn)成員printf("%d %s %c\n",p->num,p->name,p->sex);//方式2訪問(wèn)通過(guò)結(jié)構(gòu)體指針去訪問(wèn)成員，用這種p=sarr;printf("%d %s %c\n",(*p).num,(*p).name,(*p).sex);//方式1訪問(wèn)通過(guò)指針對(duì)象去訪問(wèn)成員printf("%d %s %c\n",p->num,p->name,p->sex);//方式2訪問(wèn)通過(guò)結(jié)構(gòu)體指針去訪問(wèn)成員，用這種printf("------------------------------\n");p=p+1;printf("%d %s %c\n",(*p).num,(*p).name,(*p).sex);//方式1訪問(wèn)通過(guò)指針對(duì)象去訪問(wèn)成員printf("%d %s %c\n",p->num,p->name,p->sex);//方式2訪問(wèn)通過(guò)結(jié)構(gòu)體指針去訪問(wèn)成員，用這種return 0;
}

1001 wangle M
1001 wangle M
1002 lilei M
1002 lilei M
-------------------------
1003 zhangsan M
1003 zhangsan M

由上面例子可以看到，p 就是一個(gè)結(jié)構(gòu)體指針，可以對(duì)結(jié)構(gòu)體 s 取地址并賦給 p，這樣借助成員選擇操作符，就可以通過(guò) p 訪問(wèn)結(jié)構(gòu)體的每個(gè)成員，然后進(jìn)行打印。
由于數(shù)組名中存儲(chǔ)的是數(shù)據(jù)的首地址，所以可以將 sarr 賦給 p，這樣也可以訪問(wèn)對(duì)應(yīng)的成員。
使用(*p).num 訪問(wèn)成員要加括號(hào)是因?yàn)椤?”成員選擇的優(yōu)先級(jí)高于“*”（即 取值）運(yùn)算符，所以必須加括號(hào)，通過(guò)*p 得到 sarr[0]，然后獲取對(duì)應(yīng)的成員。?

7.3.2 結(jié)構(gòu)體的使用

定義結(jié)構(gòu)體變量時(shí)使用的語(yǔ)句是 struct student s，這樣定義結(jié)構(gòu)體變量有些麻煩，每次都需要寫(xiě) struct student?？梢赃x擇使用 typedef 聲明新的類(lèi)型名來(lái)代替已有的類(lèi)型名

#include <stdio.h>typedef struct student{int num;char name[20];char sex;
}stu,*pstu; //pstu等價(jià)于 struct student*
//typedef的使用，typedef 起別名typedef int INGETER; //在特定的地方使用 給int起別名
int main() {//stu s ={0};//結(jié)構(gòu)體變量初始化為0  stu 等價(jià)于struct studentstu s={1001,"wangle",'M'};stu *p=&s;//定義了一個(gè)結(jié)構(gòu)體指針pstu p1=&s;//定義了一個(gè)結(jié)構(gòu)體指針I(yè)NGETER num=10;printf("num=%d,p->num=%d\n",num,p->num);return 0;
}

7.4 C++的引用

?7.4.1 C++的引用講解

?對(duì)于?C++，建源文件時(shí)，名字需要叫 main.cpp,以 cpp 后綴結(jié)尾
?使用了引用后，在子函數(shù)內(nèi)的 操作和函數(shù)外操作手法一致，這樣編程效率較高
【例1.1】在子函數(shù)內(nèi)修改主函數(shù)的普通變量的值(C++)

#include <stdio.h>
//C++引用的講解//在子函數(shù)中要修改主函數(shù)中變量的值，就用引用，不需要修改，就不用
void modify_num(int &b){//形參中寫(xiě)&,要稱(chēng)為引用b=b+1;
}//在子函數(shù)內(nèi)修改主函數(shù)的普通變量的值
int main() {int a=10;modify_num(a);printf("after modify_num a=%d\n",a);return 0;
}

上面的代碼如果改為純 C，代碼如下：
【例 1.2】在子函數(shù)內(nèi)修改主函數(shù)的普通變量（純 C 代碼）?

#include <stdio.h>
void modify_num(int *b) 
{ *b=*b+1; 
} int main() 
{ int a=10; modify_num(&a); printf("after modify_num a=%d\n",a); return 0；
}

【例 1.3】子函數(shù)內(nèi)修改主函數(shù)的一級(jí)指針變量（這是是重要的！）

#include <stdio.h>
void modify_pointer(int *&p,int *q){//引用必須和變量名緊鄰p=q;
}
//子函數(shù)內(nèi)修改主函數(shù)的一級(jí)指針變量
int main() {int *p=NULL;int i=10;int *q=&i;modify_pointer(p,q);printf("after modify_pointer *p=%d\n",*p);return 0;//進(jìn)程已結(jié)束，退出代碼為 -1073741819，不為0，那么代碼進(jìn)程異常結(jié)束
}

上面的代碼如果改為純 C，就需要使用到二級(jí)指針

#include <stdio.h>
void modify_pointer(int **p,int *q)//相對(duì)于 C++這里是 int **p;
{ *p=q;//這里的寫(xiě)法和例 1.2 中的是非常類(lèi)似的
}
int main() 
{int *p=NULL;int i=10;int *q=&i;modify_pointer(&p,q);//相對(duì)于 C++這里是&pprintf("after modify_pointer *p=%d\n",*p);return 0;
}

7.4.2 C++的布爾類(lèi)型

布爾類(lèi)型在 C 語(yǔ)言沒(méi)有，C++有 true 和 false，值是1和0

【例 2.1】 布爾類(lèi)型也是有值的

#include <stdio.h>
//設(shè)置布爾值的好處是提升了代碼的可閱讀性 
int main() 
{ bool a=true; bool b= false; printf("a=%d,b=%d\n", a,b); return 0;
}

a=1,b=0