|
|
《上》2021-09-03
《C程序設(shè)計(jì)---譚浩強(qiáng)》
1.1991年編寫的
2.C神器
《C目錄》
1.程序設(shè)計(jì)與C語言
2.算法--程序的靈魂
3.最簡(jiǎn)單的程序設(shè)計(jì)--順序程序設(shè)計(jì)
4.選擇程序設(shè)計(jì)
5.循環(huán)程序設(shè)計(jì)
6.利用數(shù)組批量處理數(shù)據(jù)
7.使用函數(shù)實(shí)現(xiàn)模塊設(shè)計(jì)
8.善用指針
9.用戶建立自己的數(shù)據(jù)類型
10.文件的輸入輸出
《為什么學(xué)程序設(shè)計(jì)》
1.理解計(jì)算機(jī)如何工作
2.理解計(jì)算機(jī)工作原理
3.應(yīng)用計(jì)算機(jī)解決問題
《為什么學(xué)C》
1.功能豐富
2.表達(dá)能力強(qiáng)
3.使用靈活方便
4.應(yīng)用面廣
5.目標(biāo)程序效率高
6.可移植性好
7.既有高級(jí)語言的優(yōu)點(diǎn)，又有低級(jí)語言的許多特點(diǎn)
8.既適于編寫系統(tǒng)軟件、又能方便地用來編寫應(yīng)用軟件
《C建議》
1.大學(xué)生畢業(yè)前一定要學(xué)好C，C語言是當(dāng)前程序員的共同語言
2.在編寫底層設(shè)備驅(qū)動(dòng)和內(nèi)嵌應(yīng)用程序應(yīng)用廣泛
《如何學(xué)習(xí)C》
1.著眼于培養(yǎng)能力
（1）分析問題的能力
（2）構(gòu)造算法能力
（3）編程能力
（4）調(diào)試程序能力
2.重視實(shí)踐環(huán)節(jié)
（1）C是一門應(yīng)用課程、而非純理論課程
（2）學(xué)得好環(huán)不是看你知不知道，而是看你會(huì)不會(huì)干
（3）打好基礎(chǔ)很重要，為學(xué)習(xí)更高級(jí)的知識(shí)做準(zhǔn)備
3.構(gòu)造算法
（1）算法是程序的靈魂
（2）積累算法是必須的
《什么是計(jì)算機(jī)程序》
1.一組計(jì)算能識(shí)別和執(zhí)行的指令
2.計(jì)算機(jī)的一切操作都是由程序控制
3.計(jì)算機(jī)的本質(zhì)是程序的機(jī)器
《什么是計(jì)算機(jī)語言》
1.用于人與計(jì)算機(jī)交流的語言
2.計(jì)算機(jī)基于二進(jìn)制工作，只能識(shí)別二進(jìn)制----機(jī)器語言
3.符號(hào)語言、便于記憶，使用---又稱匯編語言
匯編---將符號(hào)語言裝換成機(jī)器語言
匯編語言與機(jī)器語言完全依賴具體的機(jī)器特性--低級(jí)語言
4.不依賴具體的機(jī)器的語言---高級(jí)語言--C系統(tǒng)描述語言
《C標(biāo)準(zhǔn)》
1.ANSI C和C89和C90是同一個(gè)標(biāo)準(zhǔn)
2.C99--對(duì)C89的擴(kuò)充
3.TC1\TC2--技術(shù)修正
4.嵌入式系統(tǒng)編程以C89為準(zhǔn)
《C語言的特點(diǎn)》
1.語言簡(jiǎn)潔緊湊、使用靈活方便
2.運(yùn)算符、數(shù)據(jù)類型豐富
3.結(jié)構(gòu)化控制語句
4.語言限制不太嚴(yán)格、程序設(shè)計(jì)自由度大
5.允許直接訪問物理地址、能進(jìn)行位操作、能實(shí)現(xiàn)匯編大部分功能
6.可移植性好、生成目標(biāo)代碼質(zhì)量高、程序執(zhí)行效率高
《C語言的有多少個(gè)關(guān)鍵字》
C89 --32個(gè)
C99 --37個(gè)
《C語言的9種流程控制語句》
1.選擇
if
switch
2.循環(huán)
while
do while
for
3.跳轉(zhuǎn)
continue
break
return
goto
《C語言的34種運(yùn)算符》
優(yōu)先級(jí) 運(yùn)算符 含義 結(jié)合方向
1 （） 圓括號(hào) 自左向右
1 [] 下標(biāo)運(yùn)算符 自左向右
1 -> 指向結(jié)構(gòu)體成員運(yùn)算符 自左向右
1 . 結(jié)構(gòu)體成員運(yùn)算符 自左向右
2 ！ 邏輯非運(yùn)算符 自右向左
2 ~ 按位取反運(yùn)算符 自右向左
2 ++ 自增運(yùn)算符 自右向左
2 -- 自減運(yùn)算符 自右向左
2 - 負(fù)號(hào)運(yùn)算 自右向左
2 （類型） 類型轉(zhuǎn)換運(yùn)算符 自右向左
2 * 指針運(yùn)算符 自右向左
2 & 取地址運(yùn)算符 自右向左
2 sizeof 長(zhǎng)度運(yùn)算符 自右向左
3 * 乘法運(yùn)算符 自左向右
3 / 除法運(yùn)算符 自左向右
3 % 求余運(yùn)算符 自左向右
4 + 加法運(yùn)算符 自左向右
4 - 減法運(yùn)算符 自左向右
5 << 左移運(yùn)算符 自左向右
5 >> 右移運(yùn)算符 自左向右
6 <、<=、>、>= 關(guān)系運(yùn)算符 自左向右
7 == 等于運(yùn)算符 自左向右
7 != 不等于運(yùn)算符 自左向右
8 & 按位與運(yùn)算符 自左向右
9 ^ 按位異或運(yùn)算符 自左向右
10 | 按位或運(yùn)算符 自左向右
11 && 邏輯與運(yùn)算符 自左向右
12 || 邏輯或運(yùn)算符 自左向右
13 ?: 條件運(yùn)算符 自右向左
14 =、+=、-=、 賦值運(yùn)算符 自右向左
14 *=、/=、%= 賦值運(yùn)算符 自右向左
14 <<=、>>= 賦值運(yùn)算符 自右向左
14 &=、^=、|= 賦值運(yùn)算符 自右向左
15 , 逗號(hào)運(yùn)算符 自左向右
記憶口訣：
密不可分
四對(duì)半
四則
大于小于號(hào)多的
位高于邏輯，與高于或，異或夾中間
條件
賦值--四則與位（除了按位取反沒有復(fù)合運(yùn)算）
逗號(hào)
結(jié)合方向：
單目、三目與賦值從右向左結(jié)合
其他的都是從左到右
《C語言的32關(guān)鍵字---ASIN C/C89/C90》
數(shù)據(jù)類型關(guān)鍵字(20)
基本數(shù)據(jù)類型關(guān)鍵字
1.void
2.char
3.int
4.float
5.double
類型修飾關(guān)鍵字
1.short
2.long
3.signed
4.unsigned
復(fù)雜類型關(guān)鍵字
1.struct
2.union
3.enum
4.typedef
5.sizeof
存儲(chǔ)類型關(guān)鍵字
1.auto
2.static
3.register
4.extern
5.const
6.volatile
流程控制關(guān)鍵字(12)
分支結(jié)構(gòu)
1.if
2.else
3.switch
4.case
5.default
循環(huán)結(jié)構(gòu)
1.while
2.do
3.for
跳轉(zhuǎn)結(jié)構(gòu)
1.continue
2.break
3.return
4.goto
《C99新增的5個(gè)關(guān)鍵字》
1.inline
2.restric
3.Bool
4._Complex
5._Imaginary
《C語言注釋》
1.注釋是給人看的
2.在預(yù)處理時(shí)將注釋替換為空格，所以不產(chǎn)生目標(biāo)代碼
3.單行注釋是C99標(biāo)準(zhǔn)的--//
4.多行注釋不可嵌套注釋--/**/
錯(cuò)誤代碼：
#include<stdio.h>
int main(void)
{
/*
/*
*/
*/---報(bào)錯(cuò)
return 0;
}
5.在字符串中的//與/**/不作為注釋的開始
#include<stdio.h>
int main(void)
{
printf("/*你好*/\n");--/*你好*/
printf("//我好");--//我好
return 0;
}
《C語言程序結(jié)構(gòu)》
1.一個(gè)程序由一個(gè)或多個(gè)源文件組成
2.函數(shù)是C程序的主要組成部分
3.程序總是從main函數(shù)開始執(zhí)行
4.C語言本身不提供輸入輸出語句
5.程序應(yīng)當(dāng)包含注釋
《程序設(shè)計(jì)的任務(wù)》
1.問題分析
2.設(shè)計(jì)算法
3.編寫程序
4.對(duì)源程序進(jìn)行編輯、編譯、鏈接
5.運(yùn)行程序，分析結(jié)果
6.編寫程序文檔
《算法的初探》
1.為解決某一問題采取的方法和步驟
2.數(shù)值運(yùn)算算法、非數(shù)值運(yùn)算算法（主要的）
3.采用方法簡(jiǎn)單、運(yùn)算步驟少的
4.算法的目的是求解，解就是輸出，沒用輸出的算法是沒有意義的
5.設(shè)計(jì)算法、實(shí)現(xiàn)算法
《算法的特性》
1.有窮性
2.確定性
3.有零個(gè)輸入或多個(gè)輸入
4.有一個(gè)輸出或多個(gè)輸出
5.有效性
《怎樣表示一個(gè)算法》
1.自然語言
2.傳統(tǒng)流程圖
3.結(jié)構(gòu)化流程
4.N-S流程圖
5.偽代碼
《結(jié)構(gòu)化程序的設(shè)計(jì)》
分而治之的思想
1.自頂向下
2.逐步細(xì)化
3.模塊化設(shè)計(jì)
4.結(jié)構(gòu)化編碼
《編寫C程序必須具備的》
1.心中要有算法
2.掌握C語言的語法
《數(shù)據(jù)的表現(xiàn)形式》
1.常量--在程序運(yùn)行過程中，其值不能被改變的量
整型常量
十進(jìn)制
八進(jìn)制
十六進(jìn)制
二進(jìn)制
實(shí)型常量
十進(jìn)制小數(shù)形式
指數(shù)形式
E或e--以10為底的指數(shù)
E或e--前必須有數(shù)，后必須為整數(shù)
字符常量
普通字符--單引號(hào)引起來的一個(gè)字符
轉(zhuǎn)義字符--以\開頭的字符序列
把\后面的字符轉(zhuǎn)換成另外的意思
\n---n不是字母，n表示換行
\ooo--八進(jìn)制表示 最大\177
\xoo--十六進(jìn)制表示 最大\7F
因?yàn)锳SCII表示的數(shù)的范圍0~127
字符串常量--用雙引號(hào)引起來的若干字符
符號(hào)常量--使用#define指定定義的
好處：
1.見名知意
2.一改全改
符號(hào)常量與常變量的理解
1.符號(hào)常量是一個(gè)符號(hào)、沒有地址，在預(yù)編譯后這個(gè)符號(hào)就不見了
2.常變量量--有地址、在編譯后存在
3.符號(hào)常量才是真正的常量，因?yàn)闆]有地址，無法通過指針修改
#include<stdio.h>
#define PI 3.14
const int a=1;
int main(void)
{
printf("%x",&a);//0x404004
//printf("%d",&PI);//報(bào)錯(cuò)
return 0;
}
2.變量---一個(gè)有名字的、具有特定屬性的一個(gè)存儲(chǔ)單元，在程序運(yùn)行過程中，可以被改變
C89規(guī)定：變量必須先定義，后使用
C99規(guī)定：變量可以在函數(shù)或復(fù)合語句中定義
變量名：
代表一個(gè)存儲(chǔ)地址
通過變量寫入或獲取值的本質(zhì)：
通過變量名找到相應(yīng)內(nèi)存地址
通過地址確定相應(yīng)存儲(chǔ)單元
通過相應(yīng)存儲(chǔ)單元中獲取值
變量值
存儲(chǔ)單元
3.標(biāo)識(shí)符
1.用于對(duì)象命名的有效字符序列
數(shù)字、字母、下劃線
不能以數(shù)字開頭
不能是關(guān)鍵字
《數(shù)據(jù)的類型》
1.對(duì)數(shù)據(jù)分配存儲(chǔ)單元的安排
數(shù)據(jù)的長(zhǎng)度
數(shù)據(jù)的存儲(chǔ)形式
2.結(jié)構(gòu)圖
數(shù)據(jù)類型
基本數(shù)據(jù)類型
整型型
基本整型 int
短整型 short int
長(zhǎng)整型 long int
字符型 char
C99增加的：
*雙長(zhǎng)整型 long long int
*布爾 bool
浮點(diǎn)型
單精度浮點(diǎn)型 float
雙精度浮點(diǎn)型 double
復(fù)數(shù)浮點(diǎn)型 float_complex,double_comple,long long_comple
派生數(shù)據(jù)類型
指針類型 *
數(shù)組類型 []
結(jié)構(gòu)體類型 struct
共用體類型 union
函數(shù)類型
枚舉類型 enum
空類型 void
《整型數(shù)據(jù)》
1.數(shù)據(jù)的存儲(chǔ)是以補(bǔ)碼形式存儲(chǔ)在內(nèi)存中
2.C標(biāo)準(zhǔn)并沒有具體規(guī)定各種數(shù)據(jù)類型所占用的存儲(chǔ)空間，有各編譯系統(tǒng)自行決定
3.C標(biāo)準(zhǔn)值要求long類型長(zhǎng)度不不短于int類型，short類型不長(zhǎng)與int類型
sizeoof(short)<=sizeof(int)<=sizeof(long)<=sizeof(long long)
通常規(guī)定short占16位，long占32位，int的可以是16位，也可以是32位
int 在16或8位系統(tǒng)中 占16位
int 在32或64位系統(tǒng)中 占32位
無符號(hào)---表示不能表示負(fù)數(shù)，只能表示0和正數(shù)
若未指定signed或unsigned,則默認(rèn)使signed
只有整型數(shù)據(jù)可以加signed或unsigned,實(shí)型不能加
字符是按其代碼（整數(shù)）形式存儲(chǔ)的，因此C99把字符數(shù)據(jù)作為整型類型中的一種
所以字符1與整數(shù)1不是一個(gè)概念
《浮點(diǎn)型數(shù)據(jù)》
1.用來表示小數(shù)
2.實(shí)數(shù)以指數(shù)形式存儲(chǔ)
一個(gè)小數(shù)使用指數(shù)形式表示不止有一種形式
只要在小數(shù)點(diǎn)移動(dòng)的同時(shí)改變指數(shù)的值，就能保證小數(shù)的值不變
實(shí)數(shù)的指數(shù)形式--浮點(diǎn)數(shù)
3.規(guī)范指數(shù)形式
小數(shù)點(diǎn)前的數(shù)字為0，小數(shù)點(diǎn)后的數(shù)字不為0
3.14159 ----- 0.3.14159E1
4.浮點(diǎn)型 --小數(shù)部分 ---指數(shù)部分
小數(shù)位數(shù)越多，精度越高，表示范圍越小
小數(shù)位數(shù)越少，精度越低，表示范圍越大
類型 有效位數(shù)
float 6
double 15
整數(shù)默認(rèn)使int 浮點(diǎn)數(shù)默認(rèn)是double
《運(yùn)算符》
1. /
兩個(gè)實(shí)數(shù)相除結(jié)果是雙精度實(shí)數(shù)
兩個(gè)整數(shù)相除結(jié)果是整數(shù)
有負(fù)數(shù)的除法向零取整
#include<stdio.h>
int main(void)
{
printf("%d\n",sizeof(5.0/3.0));//8--雙精度
printf("%d\n",5/3);//1
printf("%d\n",-5/3);//-1
return 0;
}
2. %
要求參加的運(yùn)算對(duì)象為整數(shù)
實(shí)數(shù)沒有求余的說法
除%外的運(yùn)算符的操作數(shù)可以是任意數(shù)據(jù)類型
#include<stdio.h>
int main(void)
{
printf("%d\n",5%3);//2
printf("%d\n",-5%3);//-2
printf("%d\n",5.0%3);//報(bào)錯(cuò)
return 0;
}
3.字符
字符是整數(shù)代碼形式存儲(chǔ)的---ASCII
輸出形式有兩種
整數(shù)輸出
字符輸出
《語句》
1.表達(dá)式---運(yùn)算符+操作數(shù)
2.語句---表達(dá)式+分號(hào)
3.空語句--沒有表達(dá)式，只有分號(hào)
4.復(fù)合語句--用花括號(hào)括起來的語句--又稱語句塊
#include<stdio.h>
int main(void)
{
int a=0,b=0;
a+b//表達(dá)式 ---報(bào)錯(cuò)
a+b;//語句
; //空語句
{
a+b;//復(fù)合語句
}
return 0;
}
5.左值--出現(xiàn)在賦值運(yùn)算符的左側(cè)
6.右值--出現(xiàn)在賦值運(yùn)算符的右側(cè)
凡是是左值都可以作為右值
變量是左值--可被賦值改變
常量是右值--不可被賦值改變
表達(dá)是右值--不可被賦值改變
#include<stdio.h>
#define N 10
int main(void)
{
int a=0,b=0;
a=1;//左值可通過賦值改變
a=b;//左值可以作為右值
(a+b)=3*4;//報(bào)錯(cuò) (a+b)是表達(dá)式，是右值，不能作為左值，不能通過賦值改變
N=10;//報(bào)錯(cuò) N是常量，是右值，不能左值，不能通過賦值改變
printf("%d",a);
}
《有關(guān)輸入輸出的概念》
1.輸入輸出是以計(jì)算機(jī)為主體而言
2.C語言本身不提供輸入輸出語句，輸入輸出操作是由C標(biāo)準(zhǔn)庫(kù)函數(shù)來實(shí)現(xiàn)
好處：
使C編譯系統(tǒng)簡(jiǎn)單精煉
在編譯階段避免處理有關(guān)硬件有關(guān)問題、提高可移植性
庫(kù)函數(shù)在鏈接階段與源目標(biāo)文件連接，生成可執(zhí)行文件
3.標(biāo)準(zhǔn)輸入輸出函數(shù)
putchar---輸出字符
輸出一個(gè)字符
顯示字符
控制字符
getchar---輸入字符
顯示字符
控制字符
說明：
1.在鍵盤上輸入信息時(shí)，并不是在鍵盤上敲一個(gè)字符就馬上送到計(jì)算機(jī)中去的
2.這些字符存儲(chǔ)在鍵盤的緩沖器中，只有按下Enter鍵才把這些字符輸入到計(jì)算機(jī)中去
3.最后按順序分別賦值給相應(yīng)的變量
printf----格式化輸出
格式控制
%d--有符號(hào)的十進(jìn)制整數(shù)
%c--輸出一個(gè)字符
%s--輸出字符串
%f--輸出實(shí)數(shù)
%f---整數(shù)部分全部輸出，小數(shù)部分輸出6位
%m.nf
m--數(shù)據(jù)的寬度
n--輸出的小數(shù)位數(shù)
默認(rèn)右對(duì)齊
數(shù)據(jù)在右，左端補(bǔ)空格
%-m.n
m--輸出的列數(shù)
n--輸出的小數(shù)位數(shù)
- 左對(duì)齊
數(shù)據(jù)在左，右端補(bǔ)空格
#include<stdio.h>
int main(void)
{
int a=0;
char c=65;
char s[10]="nihao";
float f = 123.456;
printf("%d\n",a); //0
printf("%c\n",c); //A
printf("%s\n",s); //nihao
printf("%f\n",f); //123.456001---默認(rèn)6位有效位
printf("%20.4f\n",f); // 123.4560---默認(rèn)右對(duì)齊
printf("%-20.4f\n",f);//123.4560---加負(fù)號(hào)，左對(duì)齊
}
%e--指數(shù)形式輸出實(shí)數(shù)
小部分占6位
指數(shù)部分占5位
e占1列
指數(shù)符號(hào)占1列
指數(shù)占3列
#include<stdio.h>
int main(void)
{
float f = 123.456;
float f1 = 1234.4456;
printf("%e\n",f);//1.234560e+002
printf("%e\n",f1);//1.234446e+003
}
其他不常用
%i--與%d相同--按十進(jìn)制整數(shù)數(shù)據(jù)實(shí)際長(zhǎng)度輸出
%o--以八進(jìn)制整數(shù)形式輸出
%x--以十六進(jìn)制整數(shù)形式輸出
%u--以無符號(hào)十進(jìn)制整數(shù)輸出
%g--輸出浮點(diǎn)數(shù)、選擇%f\%e輸出寬度較短的格式輸出，不輸出沒有意義的0
格式控制的一般形式
% 附加字符 格式字符
附加字符
l--長(zhǎng)整型整數(shù)
m--數(shù)據(jù)的最小寬度
n--
實(shí)數(shù)--輸出n個(gè)小數(shù)
字符串--截取字符的個(gè)數(shù)
- 輸出的數(shù)字或字符在域內(nèi)向左靠
#include<stdio.h>
int main(void)
{
char s[20]="hello word!";
printf("%s\n",s); //hello word!
printf("%10.7s\n",s); // hello w
printf("%-10.7s\n",s); //hello w
}
輸出列表
說明：
1.printf輸出時(shí)，輸出對(duì)象的類型要跟格式類型一致，否則會(huì)出現(xiàn)錯(cuò)誤
2.除了X、E、G外，其他格式字符必須使用小寫
3.格式控制字符串內(nèi)可以包含轉(zhuǎn)義字符
4.想輸出%，需要寫兩個(gè)
總結(jié)：
格式控制字符串=[格式聲明]+[轉(zhuǎn)義字符]+[普通字符]
格式聲明=%+[附加字符]+格式字符
附加字符={l,m,n,-}
格式字符={d,i,o,x,X,u,c,s,f,e,E,g,G}
scanf-----格式化輸入
格式控制--同printf
地址列表--地址
gets------輸入字符串
#include<stdio.h>
int main(void)
{
char s[20];//緩沖區(qū)
printf("%s",gets(s));//打印獲取到的數(shù)據(jù)
}
puts------輸出字符串
#include<stdio.h>
int main(void)
{
char s[30]="我在景德鎮(zhèn)等你";//緩沖區(qū)
puts(s);//打印緩沖區(qū)的數(shù)據(jù) 并自動(dòng)換行
}
#include<stdio.h>
int main(void)
{
char s[20]="我說橋邊姑娘";//緩沖區(qū)
puts(gets(s));//覆蓋原來的數(shù)據(jù)，打印獲取到的數(shù)據(jù) 并自動(dòng)換行
}
《流程控制》
if與switch的理解
switch使用同一個(gè)條件去匹配，每個(gè)匹配項(xiàng)共用這個(gè)條件，可以對(duì)這個(gè)條件進(jìn)修改，到達(dá)狀態(tài)轉(zhuǎn)換的目的
if的多條件更多描述區(qū)間，switch描述的是某一點(diǎn)
if else 與 ?:的關(guān)系
等價(jià)
使用?:只需要一條語句就能達(dá)到同樣的效果
使用?:在不使用關(guān)鍵字的情況下就能達(dá)到同樣的效果
閏年的理解
1.能被4整除，不能被100整除
2.能被400整數(shù) 如：2000年是閏年 1900不是閏年
為什么需要循環(huán)？
程序處理的問題需要重復(fù)處理
continue 與 break
continue 結(jié)束本次循環(huán)
break 結(jié)束整個(gè)循環(huán)
《數(shù)組》
1.反映數(shù)據(jù)的特點(diǎn)與內(nèi)在聯(lián)系
2.下標(biāo)從零開始
長(zhǎng)度的理解
程序運(yùn)行過程中，不允許對(duì)同一數(shù)組的長(zhǎng)度進(jìn)行改變--C89
#include<stdio.h>
int main(void)
{
int len;
scanf("%d",&len);//獲取長(zhǎng)度
int arr[len];//作為數(shù)組的長(zhǎng)度
for(int i=0;i<sizeof(arr)/sizeof(int);i++)//循環(huán)獲取值
scanf("%d",&arr[ i]);
for(int i=0;i<sizeof(arr)/sizeof(int);i++)//循環(huán)顯示
printf(" %d ",arr[ i]);
return 0;
}
#include<stdio.h>
int main(void)
{
int len;
for(int i=0;i<5;i++) //循環(huán)獲取長(zhǎng)度
scanf("%d",&len);
int arr[len];//作為數(shù)組的長(zhǎng)度--最后一個(gè)起作用
for(int i=0;i<sizeof(arr)/sizeof(int);i++)//循環(huán)獲取值
scanf("%d",&arr[ i]);
for(int i=0;i<sizeof(arr)/sizeof(int);i++)//循環(huán)顯示
printf(" %d ",arr[ i]);
return 0;
}
C99支持變長(zhǎng)數(shù)組
Fibonacci數(shù)列---斐波那契數(shù)列
1 1 2 3 5 8 13 21 35 ....
1.從第三項(xiàng)開始，每一項(xiàng)等于前兩項(xiàng)之和
冒泡算法--三段法理解
1.如果有2個(gè)數(shù)，需要比較2-1趟
2.如果有3個(gè)數(shù)，需要比較3-1趟
....
3.如果有n個(gè)數(shù)，需要比較n-1趟
1.第1趟需要比較n-1次
2.第2趟需要比較n-2次
.....
3.第j趟需要比較n-j次
算法實(shí)現(xiàn)：
#include<stdio.h>
int main(void)
{
puts("請(qǐng)輸入要比較的個(gè)數(shù)：");
int len;
scanf("%d",&len);
int arr[len];
/* 循環(huán)獲取用戶的輸入 */
for(int i=0;i<sizeof(arr)/sizeof(int);i++)
scanf("%d",&arr[ i]);
/* 排序之前 */
puts("排序之前") ;
for(int i=0;i<sizeof(arr)/sizeof(int);i++)
printf(" %d ",arr[ i]);
puts("") ;
/* 冒泡算法實(shí)現(xiàn) */
for(int i=0;i<len-1;i++)
for(int j=0;j<len-1-i;j++)
{
if(arr[j+1]<arr[j])
{
int temp;//放最大的數(shù)
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;//把最大的數(shù)交換到最后
}
}
/* 排序之后 */
puts("排序之后") ;
for(int i=0;i<sizeof(arr)/sizeof(int);i++)
printf(" %d ",arr[ i]);
}
《二維數(shù)組》
二維數(shù)組可以看成一個(gè)特殊的一維數(shù)組，這個(gè)特殊的數(shù)組的元素是一個(gè)個(gè)一維數(shù)組
內(nèi)存存儲(chǔ)--按行存儲(chǔ)
int[3][4];
存儲(chǔ)結(jié)構(gòu)：
a[0][0]
a[0][1]
a[0][2]
a[0][3]
a[1][0]
a[1][1]
a[1][2]
a[1][3]
a[2][0]
a[2][1]
a[2][2]
a[2][3]
邏輯結(jié)構(gòu)：
a[0][0] a[0][1] a[0][2] a[0][3]
a[1][0] a[1][1] a[1][2] a[1][3]
a[2][0] a[2][1] a[2][2] a[2][3]
初始化時(shí)，行號(hào)可以省略，列號(hào)不可省略--看邏輯結(jié)構(gòu)理解
《字符數(shù)組》
字符串的有效長(zhǎng)度與字符數(shù)組的長(zhǎng)度不是一個(gè)概念
字符串：雙引號(hào)引起來的字符，以'\0'為結(jié)束標(biāo)志
字符串有效長(zhǎng)度：'\0'之前的有效字符個(gè)數(shù)
字符數(shù)組：存放字符的數(shù)組
字符數(shù)組的長(zhǎng)度：定義時(shí)寫的大小
因?yàn)镃語言沒有字符串的數(shù)據(jù)類型，所以使用字符數(shù)組來表示
由上可知，字符數(shù)組的長(zhǎng)度比字符串的長(zhǎng)度大
字符串的輸入輸出
%s--一次性輸入\輸出
scanf("%s",字符數(shù)組名);
printf("%s",字符數(shù)組名);
#include<stdio.h>
int main(void)
{
char arr[30];
scanf("%s",arr);
printf("%s",arr);
}
《字符串處理函數(shù)》
puts(字符數(shù)組);
gets(字符數(shù)組);
#include<stdio.h>
int main(void)
{
char arr[10];
puts(gets(arr));//獲取直接輸出
}
#include<stdio.h>
int main(void)
{
char arr[10];
char *a;
a=gets(arr);//返回值為char *
puts(a);
}
#include<stdio.h>
int main(void)
{
char arr[10];
char *a;
a=gets(arr);//返回值為char *
*a=65;//把第一位改為A
puts(a);
}
strcat(字符數(shù)組1,字符數(shù)組2);
將字符數(shù)組2連接到字符數(shù)組1的后面
#include<stdio.h>
#include<string.h>//需要引入字符處理函數(shù)頭文件
int main(void)
{
char arr1[20]="hello";//被連接的數(shù)組要足夠大，否則會(huì)有意想不到的后果
char arr2[10]="word!";
puts(arr1);//連接之前 hello
strcat(arr1,arr2);
puts(arr1);//連接之后 helloword!
}
strcpy(字符數(shù)組1,字符數(shù)組2);
將字符數(shù)組2復(fù)制到字符數(shù)組1的中去
#include<stdio.h>
#include<string.h>//需要引入字符處理函數(shù)頭文件
int main(void)
{
char arr1[6]="hello";
char arr2[10]="word!";
puts(arr1);//復(fù)制之前 hello
strcpy(arr1,arr2);
puts(arr1);//復(fù)制之后 word! ---完全覆蓋原來的字符
}
strcmp(字符數(shù)組1,字符數(shù)組2);
將字符數(shù)組2與字符數(shù)組1比較
根據(jù)ASCII表進(jìn)行比較，直到出現(xiàn)不同的字符或遇到'\0'為止
#include<stdio.h>
#include<string.h>//需要引入字符處理函數(shù)頭文件
int main(void)
{
int result;
char arr1[6]="hello";
char arr2[10]="aord!";
result=strcmp(arr1,arr2);
printf("%d",result) ;//1 字符串1>字符串2 正數(shù)
}
#include<stdio.h>
#include<string.h>//需要引入字符處理函數(shù)頭文件
int main(void)
{
int result;
char arr1[6]="hello";
char arr2[10]="word!";
result=strcmp(arr1,arr2);
printf("%d",result) ;//1 字符串1<字符串2 負(fù)數(shù)
}
#include<stdio.h>
#include<string.h>//需要引入字符處理函數(shù)頭文件
int main(void)
{
int result;
char arr1[6]="hello";
char arr2[10]="hello";
result=strcmp(arr1,arr2);
printf("%d",result) ;//0 字符串1等于字符串2 0
}
strlen(字符數(shù)組);
求字符的長(zhǎng)度
#include<stdio.h>
#include<string.h>//需要引入字符處理函數(shù)頭文件
int main(void)
{
int result;
char arr[]="hello";
result=strlen(arr);
printf("%d\n",result) ;//5 字符串的有效長(zhǎng)度
printf("%d",sizeof(arr)/sizeof(char));//6 字符數(shù)組的長(zhǎng)度
}
strlwr(字符數(shù)組);
轉(zhuǎn)為小寫的函數(shù)
#include<stdio.h>
#include<string.h>//需要引入字符處理函數(shù)頭文件
int main(void)
{
char arr[]="WORD";
char *a;
a=strlwr(arr);//返回char *類型轉(zhuǎn)小寫
printf("%s\n",a);//word
}
strupr(字符數(shù)組);
轉(zhuǎn)為大寫的函數(shù)
#include<stdio.h>
#include<string.h>//需要引入字符處理函數(shù)頭文件
int main(void)
{
char arr[]="hello";
char *a;
a=strupr(arr);//返回char *類型轉(zhuǎn)大寫
printf("%s\n",a); //HELLO
}
《統(tǒng)計(jì)單詞個(gè)數(shù)》
1.一個(gè)空格對(duì)應(yīng)一個(gè)新詞
#include<stdio.h>
#include<string.h>//需要引入字符處理函數(shù)頭文件
int main(void)
{
char string[100];//存放單詞的容器
int word=0;//統(tǒng)計(jì)單詞標(biāo)志
int flag=0;//判斷是否以空格開頭標(biāo)志
int number=0;//計(jì)數(shù)器
char c;//存放每個(gè)字符
gets(string);//獲取數(shù)據(jù)
for(int i=0;(c=string[ i])!='\0';i++)
{
if(string[0]!=' ')//不是以空格開始
{
flag=1;
if(c==' ')//一個(gè)空格對(duì)應(yīng)一個(gè)單詞
{
word=1;
}
else
if(word==1)
{
word=0;
number++;
}
}
else//以空格開始
{
if(c==' ')
{
word=1;
}
else
if(word==1)
{
word=0;
number++;
}
}
}
if(flag)
printf("%d\n",number+1);//給第一個(gè)單詞加個(gè)空格
else
printf("%d\n",number);
}
《函數(shù)》
1.讓代碼可重用
2.使程序便于維護(hù)和閱讀
3.模塊化設(shè)計(jì)的需要
函數(shù)包括兩個(gè)部分
函數(shù)首部
函數(shù)的返回值
函數(shù)名
參數(shù)列表
函數(shù)體
具體實(shí)現(xiàn)
空函數(shù)的作用
提高程序的擴(kuò)展性
實(shí)參與形參
實(shí)參：在調(diào)用函數(shù)時(shí)傳遞的參數(shù)
形參：在定義函數(shù)時(shí)寫的參數(shù)
調(diào)用函數(shù)的過程
1.實(shí)參把數(shù)據(jù)傳給形參
2.形參把數(shù)據(jù)轉(zhuǎn)入函數(shù)內(nèi)部進(jìn)行處理
函數(shù)的類型決定返回值類型
函數(shù)的原型=函數(shù)的首部
函數(shù)的聲明=函數(shù)的首部+分號(hào)
函數(shù)的遞歸調(diào)用--函數(shù)直接或間接的調(diào)用自己
《求0~15內(nèi)的階乘》
#include<stdio.h>
int dg(int number);
int main(void)
{
int result;
int number=15;//最大階乘15
for(int i=1;i<=number;i++)
{
result=dg(i);
printf("%2d!=%d\n",i,result);
}
}
int dg(int number)
{
if(number == 1 || number==0)//0與1的階乘都是1
return 1;
else
return dg(number-1)*number;//遞歸到number的值為1位止
}
遞歸的次數(shù)不宜過多，太多會(huì)使棧溢出
遞歸思想
漢諾塔：漢諾塔（又稱河內(nèi)塔）問題是源于印度一個(gè)古老傳說的益智玩具
一維數(shù)組和二維數(shù)組都做函數(shù)的形參
變量作用域
局部變量：
1.在復(fù)合語句內(nèi)定義的變量
2.函數(shù)的形參
全局變量
1.函數(shù)之外定義
變量只能在作用域內(nèi)有效
全局變量用于增加函數(shù)間數(shù)據(jù)聯(lián)系
全局變量與局部變量重名，局部變量有效---就近原則
#include<stdio.h>
int number=20;
int main(void)
{
{
int result;
int number=15;
printf("%d\n",number);//15
}
printf("%d",number);//20
}
變量存儲(chǔ)方式
1.靜態(tài)存儲(chǔ)--分配固定的存儲(chǔ)空間
2.動(dòng)態(tài)存儲(chǔ)--根據(jù)需要分配存儲(chǔ)存儲(chǔ)空間
存儲(chǔ)空間可分為
1.程序區(qū)
2.靜態(tài)存儲(chǔ)區(qū)
3.動(dòng)態(tài)存儲(chǔ)區(qū)
動(dòng)態(tài)存儲(chǔ)區(qū)中存放的
1.函數(shù)形參
2.函數(shù)中定義的沒有使用static的變量
3.調(diào)用函數(shù)時(shí)現(xiàn)場(chǎng)保護(hù)和返回地址
對(duì)于這些數(shù)據(jù)，調(diào)用函數(shù)時(shí)動(dòng)態(tài)分配存儲(chǔ)空間，函數(shù)結(jié)束時(shí)釋放這些空間。
所以兩次調(diào)用這個(gè)函數(shù)，分配的局部變量地址可能不一樣
函數(shù)和變量都有兩個(gè)屬性
1.數(shù)據(jù)類型
2.存儲(chǔ)類別
變量
自動(dòng)變量
auto
不寫默認(rèn)就是
值釋放
動(dòng)態(tài)存儲(chǔ)
每次都會(huì)給初值
靜態(tài)變量
static
值不釋放
靜態(tài)存儲(chǔ)
只會(huì)給一次初值---靜態(tài)變量在第一次調(diào)用才會(huì)執(zhí)行
寄存器變量
register
對(duì)于頻繁使用的值，把值存儲(chǔ)在寄存器中，提高程序效率
但是對(duì)應(yīng)現(xiàn)在的計(jì)算機(jī)，速度很快，所以這個(gè)操作不是很必要了
全局變量
函數(shù)外定義的變量
作用域：從定義處到文件末尾
靜態(tài)存儲(chǔ)
使用extern可以擴(kuò)展全局變量的"作用域"
1.在文件中擴(kuò)展
2.擴(kuò)展到其他文件
使用statc可以把全局變量的作用域限制在本文件中
作用域與生存期
作用域---空間角度
生存期---時(shí)間角度
定義與聲明
需要建立存儲(chǔ)空間的聲明--- 定義性聲明---定義 int a;
不需要建立存儲(chǔ)空間的聲明-- 引用性聲明---聲明 extern a;
內(nèi)部函數(shù)與外部函數(shù)
加static的函數(shù)--內(nèi)部函數(shù)
1.靜態(tài)函數(shù)
2.只能在本文件內(nèi)使用
加extern的函數(shù)--外部函數(shù)
1.可以省略寫extern
2.默認(rèn)是外部的
《結(jié)構(gòu)體》
用戶建立用于存放不同數(shù)據(jù)類型的組合型的數(shù)據(jù)結(jié)構(gòu)
聲明結(jié)構(gòu)體的格式
struct 結(jié)構(gòu)體名 {成員列表};
結(jié)構(gòu)體類型名=truct+結(jié)構(gòu)體名(結(jié)構(gòu)體標(biāo)記)
#include<stdio.h>
struct Student
{
int num;
char name[20];
char sex;
int age;
float score;
char addr[30];
};//聲明結(jié)構(gòu)體
int main(void)
{
printf("%d",sizeof(struct Student));//68--獲取結(jié)構(gòu)在內(nèi)存中占的字節(jié)數(shù)
/*
計(jì)算機(jī)對(duì)內(nèi)存的管理是以字為單位的，許多計(jì)算機(jī)系統(tǒng)以4個(gè)字節(jié)為一個(gè)字
類型 占空間 求余4剩余的空間
int num 4 0
char name[20] 20 0
char sex 1 3
int age 4 0
float score 4 0
char addr[30] 30 2
4+20+1+4+4+30=63 0+0+3+0+0+2=5
總：63+5=68個(gè)字節(jié)
*/
}
定義結(jié)構(gòu)體類型變量
1.先聲明結(jié)構(gòu)體類型，再定義該類型變量
struct 結(jié)構(gòu)體名{成員列表};//聲明結(jié)構(gòu)體
struct 結(jié)構(gòu)體名 結(jié)構(gòu)體變量名;//定義結(jié)構(gòu)體
2.在聲明類型的同時(shí)定義變量
struct 結(jié)構(gòu)體名{成員列表}結(jié)構(gòu)體變量名列表;//聲明類型的同時(shí)定義
3.不指定結(jié)構(gòu)體名而直接定義結(jié)構(gòu)體類型的變量
struct{成員列表}變量名列表;
不能在去定義其他變量，用法不多
說明：
1.結(jié)構(gòu)體類型名
2.結(jié)構(gòu)體名
3.結(jié)構(gòu)體變量名
要分清他們
4.結(jié)構(gòu)體成員名可以與普通變量名重名，但是他們沒有任何關(guān)系，屬于不同的對(duì)象，互不干擾
結(jié)構(gòu)體的初始化與引用
1.在定義結(jié)構(gòu)體變量時(shí)對(duì)它的成員初始化
2.C99允許只對(duì)某一成員初始化
3.其他未初始化的成員
數(shù)值型初始化 0
字符型 '\0'
指針類型 NULL
其實(shí)他們的值都為0
4.通過結(jié)構(gòu)體變量名引用成員
結(jié)構(gòu)體變量名.成員名
5.對(duì)結(jié)構(gòu)體的成員只能每個(gè)的輸入或輸出
6.結(jié)構(gòu)體的成員中有結(jié)構(gòu)體，通過成員運(yùn)算符一級(jí)一級(jí)地找到最低的一級(jí)成員
7.結(jié)構(gòu)體變量的成員的變量可以像普通變量一樣進(jìn)行各種運(yùn)算
8.同類型的結(jié)構(gòu)體變量可以相互賦值
聲明、定義、初始化
#include<stdio.h>
struct Student
{
int num;//學(xué)號(hào)
char name[30];//姓名
char sex;//性別
int age;//年齡
float score;//成績(jī)
char addr[30];//地址
}student={1605406202,"藍(lán)祥樂",'M',18,99.0,"廣西"};//直接初始化
int main(void)
{
/* 輸出類型要抑制 */
printf("學(xué)號(hào)=%d\n",student.num); //學(xué)號(hào)=1605406202
printf("姓名=%s\n",student.name); //姓名=藍(lán)祥樂
printf("性別=%c\n",student.sex); //性別=M
printf("成績(jī)=%f\n",student.score);//成績(jī)=99.000000
printf("地址=%s\n",student.addr); //地址=廣西
}
聲明、定義、分別初始化
#include<stdio.h>
struct Student
{
int num;//學(xué)號(hào)
char name[30];//姓名
char sex;//性別
int age;//年齡
float score;//成績(jī)
char addr[30];//地址
};
int main(void)
{
struct Student student;//定義結(jié)構(gòu)體變量
/* 分別賦值 */
student.num=1605406202;
student.name[0]='l';
student.name[1]='x';
student.name[2]='l';
student.name[3]='\0';//最好加'\0',字符串的結(jié)束標(biāo)志
student.sex='男';//亂碼 ASCII沒有中文
student.score=90.0;
student.addr[0]='g';
student.addr[1]='x';
student.addr[2]='\0';
printf("學(xué)號(hào)=%d\n",student.num); //學(xué)號(hào)=1605406202
printf("姓名=%s\n",student.name); //姓名=lxl
printf("性別=%c\n",student.sex); //性別=? //因?yàn)锳SCII沒有相應(yīng)中文編碼 --單個(gè)字符
printf("成績(jī)=%f\n",student.score);//成績(jī)=99.000000
printf("地址=%s\n",student.addr); //地址=gx
}
至簡(jiǎn)至美---能讓用戶喜歡
聲明、定義、使用掃描函數(shù)初始化
#include<stdio.h>
struct Student
{
int num;//學(xué)號(hào)
char name[30];//姓名
char sex[10];//性別 ---需要存中文請(qǐng)這樣寫
int age;//年齡
float score;//成績(jī)
char addr[30];//地址
}student;//聲明的同時(shí)定義
int main(void)
{
/* 初始化 格式控制要與變量類型一致，不然會(huì)有意想不到的效果 */
scanf("%d%s%s%d%f%s",
&student.num,
student.name,
student.sex,
&student.age,
&student.score,
student.addr);
printf("學(xué)號(hào)=%d\n",student.num); //學(xué)號(hào)=1605406202
printf("姓名=%s\n",student.name); //姓名=lxl
printf("性別=%s\n",student.sex); //性別=男
printf("成績(jī)=%f\n",student.score);//成績(jī)=99.000000
printf("地址=%s\n",student.addr); //地址=廣西
}
《枚舉》
概念
變量的值只有幾種可能
變量的值只限于列舉出來的值的范圍內(nèi)
聲明枚舉的一般形式
enum [枚舉名]{枚舉元素列表};
說明：
1.C編譯對(duì)枚舉元素按常量處理--枚舉常量
2.C語言編譯時(shí)默認(rèn)認(rèn)為他們的值為0,1,2,3,4,...
3.可以在聲明時(shí)指定枚舉的值
4.可以聲明沒有名字的枚舉，直接定義枚舉變量
作用
限制輸入?yún)?shù)的值在枚舉范圍內(nèi)，若果賦予其他值，就會(huì)出現(xiàn)錯(cuò)誤信息，便于檢測(cè)
#include<stdio.h>
enum Data
{
one,two,three,four
};
int main(void)
{
/* 初值自動(dòng)從零，自動(dòng)加1 */
printf("%d\n",one);//0
printf("%d\n",two);//1
printf("%d\n",three);//2
printf("%d\n",four);//3
}
#include<stdio.h>
enum Data
{
/* 初值從2開始，自動(dòng)加1 */
one=2,two,three,four
};
int main(void)
{
printf("%d\n",one);//2
printf("%d\n",two);//3
printf("%d\n",three);//4
printf("%d\n",four);//5
}
#include<stdio.h>
enum Data
{
/* 初值從0開始，自己觀察，自動(dòng)加1 */
one,two,three=10,four
};
int main(void)
{
printf("%d\n",one);//0
printf("%d\n",two);//1
printf("%d\n",three);//10
printf("%d\n",four);//11
}
#include<stdio.h>
enum Data
{
one=2,two=1,three=10,four=3
}; //聲明枚舉
int main(void)
{
enum Data date;//定義枚舉變量
date=one; //把枚舉成員賦給枚舉變量
printf("%d\n",date);//2
printf("%d\n",two);//1
printf("%d\n",three);//10
printf("%d\n",four);//3
}
#include<stdio.h>
enum
{
one,two=2,three=10,four
}; //聲明無名枚舉
int main(void)
{
printf("%d\n",one);//0
printf("%d\n",two);//2
printf("%d\n",three);//10
printf("%d\n",four);//11
}
#include<stdio.h>
enum
{
one,two=2,three=10,four//在定義時(shí)可以賦值--第一次賦值
}; //聲明無名枚舉
int main(void)
{
printf("%d\n",one=2);//報(bào)錯(cuò) 常量不能再被賦值
printf("%d\n",two);//2
printf("%d\n",three);//10
printf("%d\n",four);//11
}
#include<stdio.h>
enum hehe
{
one,two=2,three=10,four,five=10//在定義時(shí)可以賦值--第一次賦值
}; //聲明枚舉
int main(void)
{
printf("%d\n",sizeof(enum hehe));// 枚舉的大小是4個(gè)字節(jié) 所以枚舉是以int常量來處理
printf("%d\n",two);//2
printf("%d\n",three);//10
printf("%d\n",four);//11
}
《typedef》
概念
指定新的類型名來替代已有的類型名
應(yīng)用
1.簡(jiǎn)單的用一個(gè)新類型名替代原有的類型名
2.命名一個(gè)簡(jiǎn)單的類型名替代復(fù)雜類型名
定義新類型名的方法
1.先按定義變量的方法寫出定義體
2.將變量名換成新類型名
3.在最前面加typedef
4.然后就可以使用新類型名去定義變量了
習(xí)慣把新類型名的第一個(gè)字母用大寫
typedef只是對(duì)已存在的類型指定一個(gè)新的類型名字，而沒有創(chuàng)造新的類型
用typedef給數(shù)組類型、指針類型、結(jié)構(gòu)體、共用體、枚舉起別名，使編程更加方便
typedef與#define的理解
#define ---預(yù)處理階段、簡(jiǎn)單字符串替換
typedef ----編譯階段，不是字符串簡(jiǎn)單替換
使用typedef聲明的類類放在頭文件中，便于移植
《共用體》
概念
幾個(gè)變量共用同一段內(nèi)存的結(jié)構(gòu)
格式
union 共用體名{成員列表}變量表列;
說明
共用體所占內(nèi)存長(zhǎng)度等于最長(zhǎng)的成員的長(zhǎng)度
共用體的變量地址和各成員的地址都是同一個(gè)值
#include<stdio.h>
union uu
{
int i;
char c;
float f;
double b;
}; //聲明共用體
int main(void)
{
union uu uu; //定義共用體變量 共用體名與共用體變量名一樣不影響
printf("%d\n",sizeof(uu.i));// 4個(gè)字節(jié)
printf("%d\n",sizeof(uu.c));// 1個(gè)字節(jié)
printf("%d\n",sizeof(uu.f));// 4個(gè)字節(jié)
printf("%d\n",sizeof(uu.b));// 8個(gè)字節(jié)
printf("%d\n",sizeof(union uu));// 8個(gè)字節(jié)，共用體以最長(zhǎng)類型的字節(jié)為準(zhǔn)
}
union uu
{
int i;
char c;
float f;
double b;
}; //聲明共用體
int main(void)
{
union uu uu; //定義共用體變量 共用體名與共用體變量名一樣不影響
uu.i=65;
printf("%d\n",uu.i);// 65
printf("%c\n",uu.c);// 'A' 共用一個(gè)內(nèi)存空間，數(shù)據(jù)都一樣
printf("%f\n",uu.f);// 0.000000 //解析失敗
printf("%f\n",uu.b);// 0.000000 //解析失敗
}
《結(jié)構(gòu)體數(shù)組》
格式
struct 結(jié)構(gòu)體名 {成員列表}數(shù)組名[數(shù)組長(zhǎng)度];
《結(jié)構(gòu)體指針》
概念
指向結(jié)構(gòu)體變量的指針
1.指向結(jié)構(gòu)體變量的指針
訪問成員的方法
1.結(jié)構(gòu)體變量.成員名
2.*（指向結(jié)構(gòu)體變量的指針）.成員名
3.指向結(jié)構(gòu)體變量的指針->成員名----這個(gè)是第二中的簡(jiǎn)化
運(yùn)算符
. 成員訪問符
-> 指向運(yùn)算符
2.指向結(jié)構(gòu)體數(shù)組的指針
不管指向結(jié)構(gòu)體變量還是結(jié)構(gòu)體數(shù)組，定義的指針類型要和指向類型要一致
《用指針處理鏈表》
鏈表
是一種數(shù)據(jù)結(jié)構(gòu)
組成
頭指針
結(jié)點(diǎn)
1.用戶需要的實(shí)際數(shù)據(jù)
2.下一個(gè)結(jié)點(diǎn)的地址
尾指針
在內(nèi)存中是不連續(xù)的--手拉手
靜態(tài)鏈表
動(dòng)態(tài)鏈表
《簡(jiǎn)單的指針》
指針是什么？
指針是存地址的變量，因此我們認(rèn)為指針是一種地址類型。
地址是什么？
是內(nèi)存空間的字節(jié)編號(hào)，因此一個(gè)字節(jié)對(duì)應(yīng)一個(gè)地址。
指針的意義？
靈活訪問一塊空間。
指針的目的？
找對(duì)象，搞對(duì)象
定義變量的格式？
類型 變量名；
指針的三要素？
指針變量名、指針變量類型、指針對(duì)象類型。
指針變量名、指針變量類型、指針對(duì)象類型如何分辨？
定義 指針變量名 指針類型 指針對(duì)象類型
int *p p int * int
為什么指針對(duì)象類型為int,因?yàn)?p代表的含義是指針的指向?qū)ο螅葍r(jià)于對(duì)象的變量名，因此類型為int.
變量名與類型？
定義 變量名 類型 說明
int a a int 基本類型
int a[10] a int [10] 數(shù)組類型
int a(int a,int b) a int (int a,int b) 函數(shù)類型
int *a a int * 指針類型
指針對(duì)象與指針對(duì)象類型？
定義 指針對(duì)象 指針對(duì)象類型 說明
int *p *p int 本質(zhì)是指針，指向一個(gè)整型型空間（整型指針）
int (*p)[10] *p int [10] 本質(zhì)是指針，指向一個(gè)數(shù)組空間（數(shù)組指針）
int (*p)(int a,int b) *p int int(int a,int b) 本質(zhì)是指針，指向一個(gè)函數(shù)空間（函數(shù)指針）
int **p *p int * 本質(zhì)是指針，指向一個(gè)指針空間（二級(jí)指針）
如果p=&a,就是p指向a空間，上下對(duì)比可知*p是a。
推理：p=&a ---> *p = *&a ---> *p = a
由上可知 *& = 1，*p表示就是指針對(duì)象的空間，所以抹去*p剩下就是指針對(duì)象的類型。
類型如何看？
把變量名找出來，剩下的就是類型。
int a; 變量名是a 類型int
如果是指針，我們要找的一般是對(duì)象類型，把對(duì)象找出來，剩下的就是類型。
int *p; 對(duì)象為*p 對(duì)象類型為int
以上文字的Word格式文檔下載(內(nèi)容和本網(wǎng)頁(yè)上的一模一樣,方便保存):
譚浩強(qiáng)C學(xué)習(xí)（上）.docx
(45.03 KB, 下載次數(shù): 42)
2021-9-3 23:14 上傳
點(diǎn)擊文件名下載附件
下載積分: 黑幣 -5
|
|
QQ好友和群
QQ空間
騰訊微博
騰訊朋友
收藏
淘帖
頂
踩
