關于c語言基礎知識有哪些 IT知識
電腦知識 由優(yōu)爾供稿C語言是世界上最流行、使用最廣泛的高級程序設計語言之一。在操作系統(tǒng)和系統(tǒng)使用程序以及需要對硬件進行操作的場合，用C語言明顯優(yōu)于其它高級語言，許多大型應用軟件都是用C語言編寫的。下面一起來看看9252兒童網(wǎng)小編為大家整理的c語言基礎知識有哪些，歡迎閱讀，僅供參考。
C語言基礎知識
C語言程序的結構認識
用一個簡單的c程序例子，介紹c語言的基本構成、格式、以及良好的書寫風格，使小伙伴對c語言有個初步認識。
例1：計算兩個整數(shù)之和的c程序：
#include main() { int a,b,sum; /*定義變量a,b，sum為整型變量*/ a=20; /*把整數(shù)20賦值給整型變量a*/ b=15; /*把整數(shù)15賦值給整型變量b*/ sum=a+b; /*把兩個數(shù)之和賦值給整型變量sum*/ printf(“a=%d,b=%d,sum=%d\n”,a,b,sum); /*把計算結果輸出到顯示屏上*/ }
重點說明：
1、任何一個c語言程序都必須包括以下格式：
main() { }
這是c語言的基本結構，任何一個程序都必須包含這個結構。括號內(nèi)可以不寫任何內(nèi)容，那么該程序將不執(zhí)行任何結果。
2、main()----在c語言中稱之為“主函數(shù)”，一個c程序有且僅有一個main函數(shù)，任何一個c程序總是從main函數(shù)開始執(zhí)行，main函數(shù)后面的一對圓括號不能省略。
3、被大括號{ }括起來的內(nèi)容稱為main函數(shù)的函數(shù)體，這部分內(nèi)容就是計算機要執(zhí)行的內(nèi)容。
4、在{ }里面每一句話后面都有一個分號(;)，在c語言中，我們把以一個分號結尾的一句話叫做一個c語言的語句，分號是語句結束的標志。
5、printf(“a=%d,b=%d,sum=%d\n”,a,b,sum); ----通過執(zhí)行這條c語言系統(tǒng)提供給我們直接使用的屏幕輸出函數(shù)，用戶即可看到運行結果，本程序運行后，將在顯示器上顯示如下結果：
a=20,b=15,sum=35
6、#include
注意：(1)以#號開頭 (2)不以分號結尾 這一行沒有分號，所以不是語句，在c語言中稱之為命令行，或者叫做“預編譯處理命令”。
7、程序中以 /*開頭并且以*/結尾的部分表示程序的注釋部分，注釋可以添加在程序的任何位置，為了提高程序的可讀性而添加，但計算機在執(zhí)行主函數(shù)內(nèi)容時完全忽略注釋部分，換而言之就是計算機當做注釋部分不存在于主函數(shù)中。
C程序的生成過程
C程序是先由源文件經(jīng)編譯生成目標文件，然后經(jīng)過連接生成可執(zhí)行文件。
源程序的擴展名為 .c ，目標程序的擴展名為 .obj , 可執(zhí)行程序的擴展名為 .exe 。
標識符
在編寫程序時，必須為函數(shù)、變量等命名，這個名字稱為標識符。C語言中標識符的命名規(guī)則如下：
標識符只能由字母、數(shù)字、下劃線組成;
標識符的第一個字母必須是字母和下劃線;
標識符區(qū)分大小寫字母，如If和if是兩個完全不同的標識符。
合法標識符如下： A6, b_3 , _mn 非法的標識符如下： ab#12 , 8m , tr3:4 , yes no
標識符不能與程序中具有特殊意義的關鍵字相同，不能與用戶編制的函數(shù)名、C語言庫函數(shù)相同，在程序中各種標識符盡量不要重復，以便區(qū)分。選擇變量名和其他標識符時，應注意做到 “見名知義”。
標識符分為如下三類：
1、關鍵字
關鍵字是具有特定含義的，專門用來說明c語言特定成分的一類標識符，不能用作用戶的標識符。
auto break case char union do double else enum extern goto if int long short signed static sizof struct switch unsigned void for while typedef continue float return typedef default
2、預定義標識符
預定義標識符在c語言中也有特定的含義，但可以用作用戶標識符，預定義標識符分為兩類：
(1)、庫函數(shù)名字，比如(printf，scanf,sin，isdigit等) (2)、編譯處理命令名，比如(define,include)
3、用戶標識符
用戶根據(jù)需要自己定義的標識符稱為用戶標識符。無論如何自定義標識符，都必須符合標識符的三條命名規(guī)則。
常量
在程序運行中，其值不能被改變的量稱為常量。常量有5種類型：整型常量、實型常量、字符常量、字符串常量和符號常量。
(一)數(shù)值轉換
數(shù)字的四種表現(xiàn)形式：
①：二進制：所有數(shù)字由0,1構成，逢二進一，二進制數(shù)中不會出現(xiàn)2.。 例： ②：八進制：以數(shù)字0(注意不是以字母O,o)開頭，所有數(shù)字由0~7構成，逢八進一，八進制數(shù)中不會出現(xiàn)8。 例：0112,0123,077等 ③：十進制：所有數(shù)字由0~9構成，逢十進一，十進制數(shù)中不會出現(xiàn)10。 例：0,12，-15等 ④：十六進制：以0x或者0X(數(shù)字0加字母x)開頭,所有數(shù)字由0~9，A~F(或者a~f)構成，逢十六進一(其中A、B、C、D、E、F分別代表10、11、12、13、14、15) 例：0x4A、0X14c7等
在計算機內(nèi)部，數(shù)字均以二進制形式表示和存放，用戶輸入的普通十進制數(shù)字都要被計算機轉換成二進制才能在計算機內(nèi)部存儲，同樣計算機的運算結果也為二進制，一般要將其轉換成十進制數(shù)再輸出給用戶閱讀，這種轉換通常由計算機自動實現(xiàn)。
(1)將十進制轉換二進制、八進制和十六進制
除法：將十進制數(shù)除以2，記錄余數(shù)，得到的商繼續(xù)除以2，直到商為0，然后將各次相處所得的余數(shù)從后往前逆序排列，所得余數(shù)數(shù)字序列就是該十進制數(shù)對應的二進制數(shù)。八進制和十六進制轉換方法同上。
例：十進制數(shù)13轉換成二進制數(shù)的值為1101，轉換八進制為015，轉換成十六進制為D.
(2)將二進制、八進制和十六進制轉換成十進制
乘積求和：將二進制的每一位從低位到高位(右邊為低位，左邊為高位)分別乘以20,21,22。。。。，然后將這些積求和。
例如：=(13)10 (317)8= (23E)16=
(3)二進制與八進制、十六進制數(shù)之間的相互轉換
①：二進制轉八進制：從右往左每三位一組轉換成十進制數(shù)，將所得數(shù)據(jù)組合就是對應的八進制數(shù)(注意：高位不足三位補零)。 例：(010 110 111)2=(267)8 ②：二進制轉十六進制：從右往左每四位一組轉換成十進制數(shù)，將所得數(shù)據(jù)組合就是對應的十六進制數(shù)(注意：高位不足四位補零)。 例：(0101 1011)2=(5B)16 ③：八進制轉化二進制：每一位數(shù)字轉換為三位二進制數(shù)字 例：(13)8=(001 011)2= (注意：去掉前面的兩個00,因為0在高位沒有意義) ④：十六進制轉化二進制：每一位數(shù)字轉換為四位二進制數(shù)字 例：(E3)16=(1110 0011)2
(二)整型常量
整型常量有3種形式：十進制整型常量、八進制整型常量和十六進制整型常量。
(注意：c語言中沒有直接表示二進制的整型常量，在c語言源程序中不會出現(xiàn)二進制。)
書寫方式如下：
十進制整型常量：123 ， 0 ，-24 , 85L(長整型常量) 等 八進制整型常量：051 ，-026 ，0773 等 十六進制整型常量：0x55 , 0x1101 , 0x , 0x5AC0 , -0xFF。 其中L為長整型。
(三)實型常量
實型常量有兩種表示形式：小數(shù)形式和指數(shù)形式。
小數(shù)形式：5.4 0.074 -23.0 指數(shù)形式：5.4e0 4.3e-3 -3.3e4
(1)小數(shù)部分為0的實型常量，可以寫為453.0 或453。 (2)用小數(shù)表示時，小數(shù)點的兩邊必須有數(shù)，不能寫成“ .453“和“453.“，而應該寫成“0.453“和“453.0“。 (3)用指數(shù)寫法時，e前必須有數(shù)字，e后面的指數(shù)必須為整數(shù)(注意：整數(shù)階碼可以是正數(shù)，負數(shù)，也可以是八進制數(shù)、十六進制數(shù)，但必須為整數(shù))。
(四)字符常量
字符常量的標志是一對單引號‘ ’，c語言中的字符常量有兩類：
(1)由一對單引號括起來的一個字符，如‘a ’, ‘r’ ,‘#’。注意: ′a′ 和 ′A′ 是兩個不同的字符常量。
(2)由一對單引號括起來，以反斜杠\開頭，后跟若干數(shù)字或者字母，比如‘\n’,其中“\“是轉義的意思,后面跟不同的字符表示不同的意思，這類字符常量叫轉義字符。具體如圖所示 。
轉義字符 轉義字符的意義 ASCII碼
\n 回車換行 10 \t 橫向跳到下一制表位置 9 \b 退格 8 \r 回車 13 \f 走紙換頁 12 \\ 反斜線符"\" 92 \' 單引號符 39 \” 雙引號符 34 \a 鳴鈴 7 \ddd 1～3位八進制數(shù)所代表的字符 \xhh 1～2位十六進制數(shù)所代表的字符
(五)字符串常量
C語言中，以雙引號括起來的，由若干個字符組成的序列即為字符串常量。
例：“ni hao” “happy”等等。
(六)符號常量
符號常量是由宏定義“#define“定義的常量，在C程序中可用標識符代表一個常量。
例：計算圓的面積的c程序。
#include #define PI 3. main() { float r，s; r=12.5; S=PI *r*r; printf(“s= %f ”,s); }
說明：
#define 是宏定義，此程序中所有出現(xiàn)PI的地方都代表3.,同時PI稱為符號常量。習慣上我們用大寫字母來表示符號常量，小寫字母表示變量，這樣比較容易區(qū)別。
變量
變量就是其值可以改變的量。變量要有變量名，在內(nèi)存中占據(jù)一定的存儲單元，存儲單元里存放的是該變量的值。不同類型的變量其存儲單元的大小不同，變量在使用前必須定義。
(一)整型變量
整型變量分為4種：基本型(int)、短整型(short int 或short)、長整型(long int 或 long)和無符號型(unsigned int ，unsigned short，unsigned long)。
不同的編譯系統(tǒng)對上述四種整型數(shù)據(jù)所占用的位數(shù)和數(shù)值范圍有不同的規(guī)定。
類型說明符
字節(jié) 數(shù)值范圍 字符型
基本整型 char 1 C字符集
int 2 -32768 ~ 32767
短整型 short int 2 -32768 ~ 32767
長整型 long int 4 -214783648 ~ 214783647
無符號型 unsigned 2 0~65535
無符號長整型 unsigned long 4 0~4294967295
單精度實型 float 4 3/4E-38 ~3/4E+38
雙精度實型 double 8 1/7E-308~1/7E+308
單詞signed來說明“有符號”(即有正負數(shù)之分)，不寫signed也隱含說明為有符號，unsigned用來說明“無符號”(只表示正數(shù))。
(二)實型變量
C語言中，實型變量分為單精度類型( float )和雙精度類型( double )兩種。如:
float a , b ; double m ;
在vc中，float 型數(shù)據(jù)在內(nèi)存中占4個字節(jié)(32位)，double型數(shù)據(jù)占8個字節(jié)。單精度實數(shù)提供7位有效數(shù)字，雙精度實數(shù)提供15～16位有效數(shù)字。實型常量不分float型和double型，一個實型常量可以賦給一個float 型或double型變量，但變量根據(jù)其類型截取實型常量中相應的有效數(shù)字。
注意：實型變量只能存放實型值，不能用整型變量存放實型值，也不能用實型變量存放整型值。
(三)字符變量
字符變量用來存放字符常量，定義形式：
char 變量名;
其中關鍵字char定義字符型數(shù)據(jù)類型，占用一個字節(jié)的存儲單元。
例：char cr1,cr2; cr1= ‘A’ , cr2=‘B’ ;
將一個字符賦給一個字符變量時，并不是將該字符本身存儲到內(nèi)存中，而是將該字符對應的ASCII碼存儲到內(nèi)存單元中。例如，字符 ′A′ 的ASCII碼為65，在內(nèi)存中的存放形式如下：0
由于在內(nèi)存中字符以ASCII碼存放，它的存儲形式和整數(shù)的存儲形式類似，所以C語言中字符型數(shù)據(jù)與整型數(shù)據(jù)之間可以通用，一個字符能用字符的形式輸出，也能用整數(shù)的形式輸出，字符數(shù)據(jù)也能進行算術運算，此時相當于對它們的ASCII碼進行運算。
類型的自動轉換和強制轉換
當同一表達式中各數(shù)據(jù)的類型不同時，編譯程序會自動把它們轉變成同一類型后再進行計算。轉換優(yōu)先級為：
char < int < float < double
即左邊級別“低“的類型向右邊轉換。具體地說，若在表達式中優(yōu)先級最高的數(shù)據(jù)是double型，則此表達式中的其他數(shù)據(jù)均被轉換成double型，且計算結果也是double型;若在表達式中優(yōu)先級最高的數(shù)據(jù)是float型，則此表達式中的其他數(shù)據(jù)均被轉換成float型，且計算結果也是float型。
在做賦值運算時，若賦值號左右兩邊的類型不同，則賦值號右邊的類型向左邊的類型轉換;當右邊的類型高于左邊的類型時，則在轉換時對右邊的數(shù)據(jù)進行截取。
除自動轉換外，還有強制轉換，表示形式是：
( 類型 )(表達式); 例：(int)(a+b)
討論：當a值賦值為3.4，b值賦值為2.7，(int)(a+b)和(int)a+b的值分別為多少?
C運算符認識
C語言的運算符范圍很廣，可分為以下幾類：
、算術運算符:用于各類數(shù)值運算。包括加(+)、減(-)、乘(*)、除(/)、求余(%)、自增(++)、自減(--)共七種。
、賦值運算符:用于賦值運算，分為簡單賦值(=)、復合算術賦值(+=,-=,*=,/=,%=)和復合位運算賦值(&=,|=,^=,>>=,<<=)三類共十一種。 <="" span="">
、逗號運算符:用于把若干表達式組合成一個表達式(，)。
、關系運算符:用于比較運算。包括大于(>)、小于(<)、等于(==)、 大于等于(="">=)、小于等于(<=)和不等于(!=)六種。 <="" span="">
、邏輯運算符:用于邏輯運算。包括與(&&)、或(||)、非(!)三種。
、條件運算符:這是一個三目運算符，用于條件求值(?:)。
、位操作運算符:參與運算的量，按二進制位進行運算。包括位與(&)、位或(|)、位非(~)、位異或(^)、左移(<<)、右移(>>)六種。
8、指針運算符:用于取內(nèi)容(*)和取地址(&)二種運算。
9、求字節(jié)數(shù)運算符:用于計算數(shù)據(jù)類型所占的字節(jié)數(shù)(sizeof)。
10、特殊運算符:有括號()，下標[]，成員(→，.)等幾種。
另外，按參與運算的對象個數(shù)，C語言運算符可分為：單目運算符 (如 !)、雙目運算符 (如+，- )和三目運算符 (如 ? ： )。
算術運算符和算術表達式
一、 基本的算術運算符
(1)+(加法運算符或正值運算符，如2+5)。
(2)-(減法運算符或負值運算符，如4-2)。
(3)*(乘法運算符，如3*8)。
(4)/(除法運算符，如11/5)。
/的運算分為兩種情況：
a、“除”的左右兩邊都為整數(shù)時，所得結果必然是整數(shù)(注意：僅取整數(shù)部分，不是四舍五入)
比如：5/2的值為2，不是2.5,1/2的值為0。
b、“除”的左右兩邊至少有一個是實型數(shù)據(jù)(即小數(shù))時，所得結果為實型數(shù)據(jù)。
比如：5/2.0的值為2.5,7.0/2.0的值為3.5.
(5)%(模運算符或稱求余運算符，%兩側均應為整型數(shù)據(jù)，如9%7的值為2)。
需要說明的是：當運算對象為負數(shù)時，所得結果隨編譯器不同而不同，在vc中，結果的符號與被除數(shù)相同，比如：13%-2值為1，而-15%2值為-1。
二、 算術表達式和運算符的優(yōu)先級與結合性
算術表達式是用算術運算符和括號將運算量(也稱操作數(shù))連接起來的、符合C語言語法規(guī)則的表達式。運算對象包括函數(shù)、常量和變量等。
在計算機語言中，算術表達式的求值規(guī)律與數(shù)學中的四則運算的規(guī)律類似，其運算規(guī)則和要求如下。
(1)在算術表達式中，可使用多層圓括號，但括號必須配對。運算時從內(nèi)層圓括號開始，由內(nèi)向外依次計算各表達式的值。
(2)在算術表達式中，對于不同優(yōu)先級的運算符，可按運算符的優(yōu)先級由高到低進行運算，若表達式中運算符的優(yōu)先級相同，則按運算符的結合方向進行運算。
(3)如果一個運算符兩側的操作數(shù)類型不同，則先利用自動轉換或強制類型轉換，使兩者具有相同類型，然后進行運算。
三、 自增自減運算符
作用：使變量的值增1或減1。
如：++i，--i (在使用i之前，先使i的值加1、減1)。 i++，i-- (在使用i之后，使i的值加1、減1)。
(1)只有變量才能用自增運算符 (++)和自減運算符(--)，而常量或表達式不能用，如10++或(x+y)++都是不合法的。
(2)++和--的結合方向是“自右向左“，如 -i++ ，i的左邊是負號運算符，右邊是自增運算符，負號運算和自增運算都是 “自右向左“結合的，相當于 -(i++)。
在循環(huán)語句中常用到自增(減)運算符，在指針中也常用到該運算符，考生要弄清楚“i++”和“++i”及“i--”和“--i”的區(qū)別,特別弄清楚表達式的值和變量的值。
賦值運算符與賦值表達式
一、賦值運算符與賦值表達式
賦值符號 “=“就是賦值運算符，作用是將一個數(shù)據(jù)賦給一個變量或將一個變量的值賦給另一個變量，由賦值運算符組成的表達式稱為賦值表達式。一般形式為：
變量名 = 表達式
在程序中可以多次給一個變量賦值，每賦一次值，與它相應的存儲單元中的數(shù)據(jù)就被更新一次，內(nèi)存中當前的數(shù)據(jù)就是最后一次所賦值的那個數(shù)據(jù)。
例：a=12; 此表達式讀作“將10的值賦值給變量a”。
a、如果賦值號兩邊的運算對象類型不一致，系統(tǒng)會自動進行類型轉換，轉換的規(guī)則：將賦值號右邊表達式的值的類型轉換成賦值號左邊變量的類型，
例：int y=3.5; 在變量y中最終存儲的是整數(shù)3。
b、 可以將復制表達式的值再賦值給變量，形成連續(xù)賦值。
例如：x=y=25 是一個連續(xù)賦值表達式，x=y=25 等價于x=(y=25)，所以表達式x=y=25 最終的值為25 。
二、復合的賦值運算符
在賦值運算符之前加上其他運算符可以構成復合賦值運算符。其中與算術運算有關的復合運算符是：+=，-=，*=，/=，%= 。
兩個符號之間不可以有空格，復合賦值運算符的優(yōu)先級與賦值運算符的相同。表達式n+=1等價于n=n+1，作用是取變量n中的值增1再賦給變量n,其他復合的賦值運算符的運算規(guī)則依次類推。
如求表達a+=a-=a*a 的值,其中a的初值為12 。
步驟：
(1)先進行“a-=a*a“運算，相當于a=a-a*a=12-144=-132 。 (2)再進行“a+=-132“運算，相當于 a=a+(-132)==-264 。
逗號運算符和逗號表達式
在c語言中，逗號除了作為分隔符，還可以用作一種運算符----逗號運算符，用逗號運算符將幾個表達式連接起來，例如a=b+c,a=b*c等稱為逗號表達式。
一般形式為：
表達式1 ，表達式2 ，表達式3 ， …，表達式n
例：x=2,y=3,z=4
逗號表達式具有從左至右的結合性，即先求解表達式1，然后依次求解表達式2，直到表達式n的值。表達式n的值就是整個逗號表達式的值。上述的逗號表達式的值就是表達式z=4的值4.需要注意的是，逗號運算符是所有運算符中級別最低的。
例：有如下程序段：
main() { int a=2,b=4,c=6,x,y; y=(x=a+b),(b+c); printf("y=%d,x=%d",y,x); }
程序顯示結果為：y=6,x=6
討論：將y=(x=a+b),(b+c);改為y=((x=a+b),b+c) 的程序結果?
關系運算符和關系表達式
一、 C語言中的邏輯值
C語言中的邏輯值只有兩個：真(true)和假(flase)。用非零代表真，用零代表假。因此，對于任意一個表達式，如果它的值為零，就代表一個假值，如果它的值為非零，就代表一個真值。只要值不是零，不管是正數(shù)，負數(shù)，整數(shù)，實數(shù)，都代表一個真值。例如-5的邏輯值為真。
二、 邏輯表達式
“&&”和“||”的運算對象有兩個，故它們都是雙目運算符，而!的運算對象只有一個，因此它是單目運算符。邏輯運算舉例如下：
(1)a&&b: 當&&兩邊都為“真”時，表達式a&&b的值才是真。
值得注意的是：在數(shù)學中，關系式0
(2)a||b: 當||兩邊有一個為“真”時，表達式a||b的值就是真。
(3)!a: 表示取反，如果a為真，則!A為假，反之亦然。例如!-5的值就為0.
在C語言中，由&&或||組成的邏輯表達式，在某些特定情況下會產(chǎn)生“短路“現(xiàn)象。
(1)x && y && z ，只有當x為真(非0)時，才需要判別y的值;只有x和y都為真時，才需要去判別z的值;只要x為假就不必判別y和z，整個表達式的值為0?？谠E：“一假必假”。
例：(!5==1)&&(++i==0) (!5==1)表達式的值為0，所以計算機運行中就跳過(++i==0)此表達式，(!5==1)&&(++i==0)表達式的值為0.
(2)x||y||z ,只要x的值為真(非零)，就不必判別y和z的值 ，整個表達式的值為1，只有x的值為假，才需要判別y的值，只有x和y的值同時為假才需要判別z的值，口訣：“一真必真”。
位運算
一、 位運算符
在計算機中，數(shù)據(jù)都是以二進制數(shù)形式存放的，位運算就是指對存儲單元中二進制位的運算。C語言提供6種位運算符。
二、位運算
位運算符 & |~<< >> ∧ 按優(yōu)先級從高到低排列的順序是：
位運算符中求反運算“~“優(yōu)先級最高，而左移和右移相同，居于第二，接下來的順序是按位與 “&“、按位異或 “∧“和按位或 “|“。順序為~ << >> & ∧ | 。
例1：左移運算符“<<”是雙目運算符。其功能把“<< ”左邊的運算數(shù)的各二進位全部左移若干位，由“<<”右邊的數(shù)指定移動的位數(shù)，高位丟棄，低位補0。="" <="" span="">
例如： a<<4 指把a的各二進位向左移動4位。如a=00000011(十進制3)，左移4位后為00(十進制48)。
例2：右移運算符“>>”是雙目運算符。其功能是把“>> ”左邊的運算數(shù)的各二進位全部右移若干位，“>>”右邊的數(shù)指定移動的位數(shù)。
例如： 設 a=15， a>>2 表示把右移為十進制3)。
應該說明的是，對于有符號數(shù)，在右移時，符號位將隨同移動。當為正數(shù)時，最高位補0，而為負數(shù)時，符號位為1，最高位是補0或是補1 取決于編譯系統(tǒng)的規(guī)定。
例3：設二進制數(shù)a是00 ，若通過異或運算a∧b 使a的高4位取反，低4位不變，則二進制數(shù)b是。
解析：異或運算常用來使特定位翻轉，只要使需翻轉的位與1進行異或操作就可以了，因為原數(shù)中值為1的位與1進行異或運算得0 ，原數(shù)中值為0的位與1進行異或運算結果得1。而與0進行異或的位將保持原值。異或運算還可用來交換兩個值，不用臨時變量。
如 int a=3 , b=4;，想將a與b的值互換，可用如下語句實現(xiàn)： a=a∧b;
b=b∧a;
a=a∧b;
所以本題的答案為： 。
C語言作為一門非常適合編程入門的語言，打好基礎的重要性不言而喻。
C語言基礎知識總結
主要內(nèi)容：1.C數(shù)據(jù)類型
2.簡單的算術運算和表達式
3.鍵盤輸入和屏幕輸出
4.選擇控制結構
總結風格：分條羅列，主要是知識點，有例題不多
5.循環(huán)控制結構
一、C數(shù)據(jù)類型
1.C語言處理兩種數(shù)據(jù)：常量和變量
2.常量：整形常量、實型常量、字符常量、字符串常量、枚舉常量
3.整形常量：正整數(shù)、負整數(shù)、零 eg: 10,-30,0
4.實型常量：實數(shù)、小數(shù)、浮點數(shù) eg: 3.14,-0.56,18.0
5.字符常量：字符型常量、用單引號括起來的任意字符 eg: 'x' 'X' '?' ',' '9'
6.字符串常量：用雙引號括起來的一個或多個字符 eg: "x" "Hello" "Y78"
7.在C程序中，整型常量可以用十進制、八進制、十六進制形式表示，但編譯器都會自動將
其轉換成二進制存儲
8.整型常量的類型：長整型、短整型、有符號、無符號。
9.不同進制的整型常量的表示形式：
1)十進制：0~9數(shù)字組合，可帶正負號 eg: 256,-128,0,+7
2)八進制：0開頭，后面跟0~7數(shù)字組合 eg: 021,-017
3)十六進制：0x(0X)開頭，后跟0~9,a~f(A~F)數(shù)字組合 eg:0x12,-0x1F
10.不同類型的整形常量的表示形式：
1) 有符號整型常量：默認int型定義為有符號整數(shù)，無需signed eg:10,-30,0
2) 無符號整形常量：常量值后跟u或U,只能表示>=0的數(shù) eg:30u,256U
3) 長整型常量：常量值后跟l或L eg:-256l,1024L
4) 無符號長整型常量：常量值后跟LU、Lu 、lU 、lu eg:30lu
11.C程序中，實型常量兩種表示形式：小數(shù)、指數(shù)
12.不同形式的實型常量的表示形式：
1) 十進制表示形式：數(shù)字和小數(shù)點組成，必須要有小數(shù)點，整數(shù)部分可省略 eg:0.123, -12.35, .98
2) 指數(shù)形式：e或E代表以10為底的指數(shù)， e左邊是數(shù)值部分(有效數(shù)字，可以是整
數(shù)、小數(shù)，不能省略)，e右邊是指數(shù)部分(必須是整數(shù)形式) eg:3.45e-6
13.實型常量有單精度和雙精度之分，無有符號和無符號之分
14.不同類型的實型常量表示形式：
1)單精度實型常量：常量值后跟F或f eg:1.25F,1.25e-2f
2)雙精度實型常量(double)：實型常量默認按雙精度處理 eg:0.123,-12.35, .98
3)長雙精度實型常量(long double)：常量值后跟L或l eg:1.25L
15.變量：在程序執(zhí)行過程中可以改變的量
16.變量在必須先定義后使用，定義時需要聲明變量的類型和變量名，一般形式：類型關鍵
字 變量名;
17.關鍵字是C語言預先規(guī)定具有特殊意義的單詞，類型關鍵字用于聲明變量的類型
18.標準C語言編寫的程序都是以main()作為開頭，指定了C程序執(zhí)行的起點，在C程序中
只能出現(xiàn)一次，稱為主函數(shù)
19.C程序總是從main函數(shù)開始執(zhí)行，與他在程序中的位置無關，main函數(shù)主體部分稱為語
句，用{}括起來，一般C語句以;結束
20.變量的類型決定了編譯器為其分配內(nèi)存單元的字節(jié)數(shù)、數(shù)據(jù)在內(nèi)存單元中的存放形式、
該類型變量合法的取值范圍以及該類型變量可參與的運算種類
21.變量名是用戶定義的標識符，用于標識內(nèi)存中具體的存儲單元，存放的數(shù)據(jù)稱為變量的
值
22.新數(shù)據(jù)存放于存儲單元時，舊數(shù)據(jù)將會被修改，反應變量的值是可以改變的
23.變量名的命名規(guī)則：
1)標識符只能由英文字母、數(shù)字、下劃線組成
2)標識符必須以字母或下劃線開頭
3)不允許使用C關鍵字為標識符命名
4)標識符可以包含任意多個字符，但一般會有最大長度限制，預編譯器有關，一般不會超過，最好不超過8個字符
注意：標識符區(qū)分大小寫
eg:x y3 _imax ELSE X A_to_B (合法)
eg:7x int #No bad one re-input(不合法)
24.標準C規(guī)定所有變量必須在第一條可執(zhí)行語句之前定義
25.在同一條語句中可以同時定義多個相同類型變量，多個變量之間用逗號分隔，沒有順序要求
26.在使用標準輸入/輸出函數(shù)時，必須在程序開頭加上編譯預處理命令
27.中stdio為頭文件，std是standard,i為input,o為output,h為head
28.編譯預處理命令#include的作用：將在輸入/輸出函數(shù)的頭文件stdio.h包含到用戶源文件中
29.%d按十進制整數(shù)個格式輸出，%f按十進制小數(shù)格式輸出，一般輸出6位小數(shù)，%c輸出一個字符，\n換行，雙引號內(nèi)字符原樣輸出
30.不同類型的數(shù)據(jù)在內(nèi)存中占用不同大小的存儲單元，他們所能表示的數(shù)據(jù)的取值范圍各不相同，不同類型的數(shù)據(jù)表示形式及其可以參與的運算種類也不同
31.定義整型變量時，只要不指定為無符號型，其隱含類型為有符號型，signed通常省略不寫
32.C程序中每個變量的值都是按字節(jié)編址，都被存儲在內(nèi)存中特定的存儲單元中，這個存儲空間實際是一個線性地址表，即每個字節(jié)的存儲空間對應一個唯一的地址
33.1個字節(jié)等于8個二進制位，即8個位為一個字節(jié)，一個字節(jié)可以表示的整數(shù)最小為0，最大255，即8個位可以表示0-255之間的數(shù)，一個二進制位的值只能是0或1
34.同種類型在不同的平臺所占字節(jié)數(shù)不同，要計算數(shù)據(jù)類型所占內(nèi)存空間的字節(jié)數(shù)需要用sizeof()運算符
35.sizeof是C語言關鍵字，不是函數(shù)名，sizeof(變量名)計算一個變量所占內(nèi)存的字節(jié)數(shù)
36.計算不同類型運算符的表達式時，要考慮運算符的優(yōu)先級和結合性
37.正數(shù)的反碼、補碼與原碼都相同，負數(shù)的補碼等于反碼加1
38.在計算機內(nèi)存中負數(shù)都是用補碼來表示
39.對于實數(shù)，無論小數(shù)海曙指數(shù)形式，在計算機內(nèi)存中都采用浮點形式來存儲
40.浮點數(shù)分為階碼、尾數(shù)兩部分，實數(shù)N=S*pow(r,j),S為尾數(shù)(無論正負，規(guī)定用存小數(shù))，j為階碼(無論正負，必須是整數(shù))，r是基數(shù) eg:10.0111=0.100111*pow(2,10)
41.階碼所占位數(shù)決定實數(shù)的取值范圍，尾數(shù)所占位數(shù)決定實數(shù)的精度，尾數(shù)的符號決定實數(shù)的正負，階碼和尾數(shù)的字節(jié)大小與編譯器有關
42.float型變量能接收實型常量的7位有效數(shù)字，double型變量能接收16位
43.運算符的優(yōu)先級：單目運算<算術運算<關系運算<邏輯運算<條件運算<賦值運算<逗號運算
44.素數(shù)：又稱質數(shù)，指在大于1的自然數(shù)中，除1和本身不能被其他自然數(shù)整除的數(shù)
45.合數(shù)：指在自然數(shù)中除1和本身外還能被其他自然數(shù)整除的數(shù)
46.因子：所有能整除這個數(shù)的數(shù)，不包括自身，但包括1
47.閏年：能被4整除但不能被100整除，或能被400整除
二、 簡單的算術運算和表達式
1.條件運算符是C語言提供的唯一一個三元運算符，C語言中沒有冪運算符
2.只有計算相反數(shù)是一元運算符，其余運算符都是二元運算符
3.一元運算符也叫單目運算符，二元運算符也叫雙目運算符，三元運算符也叫三目運算符
4.整數(shù)除法的結果是整數(shù)，浮點數(shù)除法的結果是浮點數(shù)
5.求余運算限定參與運算的兩個操作數(shù)必須為整型，余數(shù)的符號與被除數(shù)的符號相同，不能對兩個實型數(shù)進行求余運算
6.所有的算術運算符中只有一元的去相反數(shù)運算符為右結合，其余的結合性都為左結合
7.同一優(yōu)先級的運算符進行混合運算時，從左向右依次進行
8.運算符的優(yōu)先級：單目運算>算術運算>關系運算>邏輯運算>條件運算>賦值運算>逗號運算
9.計算并輸出一個三位整數(shù)的個位、十位、百位數(shù)字之和
#include
void main()
{
int x=321;
int a,b,c,sum;
a=x%10;//a=1
b=(x/10)%10;//b=2
c=x/100;//c=3
sum=a+b+c;
printf("a=%d,b=%d,c=%d\nsum=%d\n",a,b,c,sum);
}
10.涉及算術運算的復合賦值運算符有5個：+=,-=,*=,/=,%=
11.增1運算符也稱自增運算符，減1運算符也稱自減運算符，都是一元運算符，只有一個操作數(shù)必須是變量不能是常量或表達式
12.自增自減運算符作為前綴時，先執(zhí)行加1或減1然后使用;自增自減運算符作為后綴時，先使用再執(zhí)行加1或減1;
13.考慮優(yōu)先級與結合性的實例
m=-n++《=》m=-(n++)《=》m=-n,n=n+1;
//正面：-和++都是一元運算符，優(yōu)先級相同，此時要考慮結合性，結合性都是右結合的，所以先算++后算-
//反面：如果等價m=(-n)++就不合法了，因為表達式不能進行自增操作
14.scanf函數(shù)和printf函數(shù)都是C的標準輸入/輸出函數(shù)，&為取地址運算符
15.宏常量與宏替換：
1) 在程序中直接使用的常數(shù)稱為幻數(shù)，將幻數(shù)定義為宏常量或const常量是為了提高程序的可讀性和可維護性
2) 宏常量也稱符號常量，沒有數(shù)據(jù)類型，編譯器不對其進行類型檢查，只進行字符串替換
3) 宏定義一般形式：#define 標識符 字符串。標識符被稱為宏名,宏名與字符串之間可有多個空白符，不加等號，結尾不加分號
4) 宏常量是由宏定義編譯預處理命令來定義,宏名替換成字符串的過程稱為宏替換，宏替換不做任何語法檢查
5) 當宏定義是一個表達式時，調(diào)用時，是一個數(shù)就可以直接帶入，而是表達式也要看成是一個數(shù)代進宏定義表達式中，
而看成一個數(shù)這就要求把調(diào)用的數(shù)加上圓括號，為了減少不必要的錯誤，最好都加上圓括號
6) 宏替換的過程是將宏名原樣替換成字符串，而不是直接計算出值，所以要用調(diào)用后的結果參與其他運算就需要把調(diào)用的結果加上圓括號
7) 例題:
#include
#define N 2 //N=2
#define M N+1 //M=2+1
#define NUM 2*M+1 //NUM=2*2+1+1=6
void main()
{
int i;
for(i=1;i<=NUM;i++);
printf("%d\n",i); //執(zhí)行完空循環(huán)，i=7
i--; // i=6
printf("%d\n",i);
}
8) 例題:
#include
#define f(x) x*x
void main()
{
int b;
b=f(4+4); //b=4+4*4+4=24，解釋見5)
printf("b=%d\n",b);
}
9) 例題：
#include
#define f(x) x*x
void main()
{
int b;
b=f(4+4)/(2+2); //b=4+4*4+4/(2+2)=21解釋見6)
printf("b=%d\n",b);
}
10) 例題：
#include
#define f(x) x*x
void main()
{
int b;
b=f((4+4)); //b=(4+4)*(4+4)=64
printf("b=%d\n",b);
}
11) 例題：
#include
#define f(x) (x*x)
void main()
{
int b;
b=f((4+4))/(2+2); //b=((4+4)*(4+4))/(2+2)=16
printf("b=%d\n",b);
}
16.const常量
1) const常量只能在定義時賦初值，因為編譯器將其放在只讀存儲區(qū)，不允許在程序中修改
2) const常量的定義一般形式：const 類型名 標識符=字符串;//將標識符聲明為具有該數(shù)據(jù)類型的const常量
3) const是一種類型修飾符，const常量具有數(shù)據(jù)類型，編譯器要對其進行類型檢查
17.表達式中的自動類型轉換：
1) 表達式中，操作數(shù)類型相同，運算的結果類型與操作數(shù)類型相同
2) 表達式中，操作數(shù)類型不相同，C編譯器自動將所有操作數(shù)進行類型提升，轉換成同一類型，所占字節(jié)最大，再計算
18.賦值中的自動類型轉換：
1) 賦值運算符左側變量與右側表達式類型不同時，發(fā)生自動類型轉換：右側表達式的值轉換成左側變量的類型
19.強制類型轉換：
1) 強制類型轉換運算符是一元運算符
2) 強制類型轉換也稱強轉，是將表達式的值轉換為任意類型，并不改變變量本身的數(shù)據(jù)類型
3) 強轉一般形式：(類型)表達式
4) 演示強制類型轉換運算符的使用
#include
void main()
{
int m=5;
printf("m/2=%d\n",m/2);//m=2
printf("(float)(m/2)=%f\n",(float)(m/2));//m=2.000000
printf("(float)m/2=%f\n",(float)m/2);//m=2.500000
printf("m=%d\n",m);//m=5,只是將m強轉為實型數(shù)據(jù)，并不改變m的數(shù)據(jù)類型 }
20.常用的標準數(shù)學函數(shù)：
1) 使用C標準數(shù)學函數(shù)，要在程序開頭加上編譯預處理命令：#include
2) 例：已知三角形三邊長為a,b,c，計算三角形的面積
#include
#include
void main()
{
float a,b,c,s,area;
printf("Input a,b,c:");
scanf("%f,%f,%f",&a,&b,&c);
s=(a+b+c)/2;
area=(float)sqrt(s*(s-a)*(s-b)*(s-c));
printf("area=%f\n",area);
}
21.賦值運算符的左側不能出現(xiàn)表達式，變量與變量之間可以賦值
例1：若有定義：int a,b,c;下列表達式中哪一個是合法的C語言賦值表達式(C、D)
A)a=7+b=c=7 B)a=b++=c=7 C)a=(b=7,c=12) D)a=3,b=a+5,c=b+2
//A.7+b表達式不能做左值 B.b++表達式不能做左值 C.逗號表達式a=12 D.依次賦值
例2：下面不正確的賦值語句是(B)
A)a=++a B)a=b++=10 C)a+=b D)a=1>'a'
//D.算術運算符優(yōu)先級高于賦值運算符，先算1>'a'再將其結果賦給a
例3：若有下列定義：int a=3,b=2,c=1;以下選項錯誤的賦值表達式是(A)
A)a=(b=4)=3 B)a=b=c+1 C)a=(b=4)+c D)a=1+(b=c=4)
//A.先計算圓括號里的值等于4，然后按照賦值表達式的順序從右向左計算，將3賦值給4這是不對的，
即賦值號左側只能是變量，不能出現(xiàn)表達式b=4
三、 鍵盤輸入和屏幕輸出
1.字符常量：
把字符放在一對單引號內(nèi)，適用于多數(shù)可打印字符
2.轉義字符：
以反斜線(\)開頭，也是放在一對單引號內(nèi)，適用于控制字符(如回車符，換行符)
3.常用的轉義字符：
1) '\n' — 換行 8) '\a' — 響鈴報警提示音
2) '\r' — 回車(不換行) 9) '\"' — 一個雙引號
3) '\0' — 空字符 10) '\'' — 一個單引號
4) '\t' — 水平制表 11) '\\' — 一個反斜線
5) '\v' — 垂直制表 12) '\?' — 問號
6) '\b' — 退格 13) '\ddd' —1到3位八進制ASCII碼值所代表的字符
7) '\f' — 走紙換頁 14) '\xhh' —1到2位十六進制ASCII碼值所代表的字符
4.\n,是將光標移到下一行起始位置，\r是將光標移到當前行的起始位置
5.\t,是水平制表符，相當于按下Tab鍵，每次按下Tab鍵并不是從當前光標位置向后移動一個Tab寬度，而是移到下一個制表位
實際移動的寬度視當前光標位置距相鄰的下一個制表位的距離而定
6.制表位，屏幕上的一行被分為若干個域，相鄰域之間的交接點稱為制表位，每個域的寬度就是一個Tab寬度，多數(shù)習慣上為4
7.當轉義序列出現(xiàn)在字符串中時，是按單個字符計數(shù)的
8.一個整形數(shù)在內(nèi)存中是以二進制形式存儲的，而一個字符在內(nèi)存中也是以其對應的ASCII碼的二進制形式存儲的，
但char型數(shù)據(jù)在內(nèi)存中只占一個字節(jié)，而int型數(shù)據(jù)在16位系統(tǒng)中占2個字節(jié)，32位系統(tǒng)占4個字節(jié)
9.在ASCII碼取值范圍內(nèi)，char型數(shù)據(jù)可以和int型數(shù)據(jù)進行混合運算，char型數(shù)據(jù)也能以int型輸出，直接輸出其對應的ASCII碼的十進制值
10.字符的輸入/輸出：
1) getchar()和putchar()是C標準函數(shù)庫中專門用于字符輸入/輸出的函數(shù)，功能是只能輸入/輸出一個字符
2) 例：從鍵盤輸入一個大寫英文字母，將其轉換為小寫字母顯示在屏幕上
#include
void main()
{
char ch;
ch=getchar();//鍵盤輸入一個字符，再按回車表示輸入結束，字符存入變量ch，注意：getchar()沒有參數(shù)，直接返回讀入的字符
ch=ch+32;
putchar(ch);//第二次按回車，將顯示轉換后的結果
putchar('\n');//注意：putchar()內(nèi)一定要有參數(shù)，參數(shù)就是待輸出的字符，可以是可打印字符，也可是轉義字符
}
11.數(shù)據(jù)的格式化屏幕輸出：
1) 函數(shù)printf()的一般格式：printf(格式控制字符串);或者printf(格式控制字符串,輸出值
參數(shù)表);
2) 格式控制字符串包括：格式轉換說明符，需要原樣輸出的普通字符
3) 函數(shù)printf()的格式轉換說明符：
%d — 輸出帶符號十進制整數(shù)，整數(shù)符號省略
%u — 輸出無符號十進制整數(shù)
%o — 輸出無符號八進制整數(shù)，不輸出前導符0
%x — 輸出無符號十六進制整數(shù)(小寫)，不輸出前導符0x
%X — 輸出無符號十六進制整數(shù)(大寫)，不輸出前導符0x
%c — 輸出一個字符
%s — 輸出字符串
%f — 以十進制小數(shù)形式輸出實數(shù)，包含單，雙精度，隱含6位小數(shù)，但并非全是有效數(shù)字，單精度有效7位，雙精度16位
%e — 以指數(shù)形式輸出實數(shù)(小寫e表示指數(shù)部分)，小數(shù)點前有且僅有一位非0數(shù)字
%E — 以指數(shù)形式輸出實數(shù)(大寫E表示指數(shù)部分)
%g — 自動選取f或e格式中寬度較小的一種使用，不輸出無意義的0
%% — 輸出%
4) 輸出值參數(shù)表：需要輸出的數(shù)據(jù)項的列表，可以是變量或表達式，逗號隔開，類型與格式轉換說明符相匹配
5) 每個格式轉換說明符與輸出值參數(shù)表中的輸出值參數(shù)一一對應，沒有輸出值參數(shù)，格式控制字符串就不需要格式轉換說明符
6) 例：從鍵盤輸入一個大寫英文字母，將其轉換為小寫字母和其十進制ASCII碼值顯示在屏幕上
#include
void main()
{
char ch;
printf("Please enter a key:");
ch=getchar();
ch=ch+32;
printf("%c,%d\n",ch,ch);//printf("%c",ch)<<=>>putchar(ch),printf("\n")<<=>>putchar('\n') }
7) 函數(shù)printf()中的格式修飾符：在%和格式符中間插入格式修飾符，用于輸出格式的微調(diào)，如：指定輸出域寬、精度、左對齊等
英文字母l — 修飾格式符d,o,x,u時，用于輸出long型數(shù)據(jù)
英文字母L — 修飾格式符f,e,g時，用于輸出long double型數(shù)據(jù)
英文字母h — 修飾格式符d,o,x時，用于輸出short型數(shù)據(jù)
輸出域寬m — m為整數(shù)，輸出時占m列，若m>0，當數(shù)據(jù)寬度小于m時，域內(nèi)右靠齊，左補空格，當數(shù)據(jù)寬度大于m時，修飾符失效，按實際寬度輸出，若m有前導符0，左邊多余位補0;若m<0,輸出數(shù)據(jù)在域內(nèi)左靠齊
顯示精度 .n — n為大于等于0的整數(shù)，精度修飾符位于最小域寬修飾符之后，由圓點和整數(shù)構成，對于浮點數(shù)，用于指定輸出的浮點數(shù)小數(shù)位數(shù);對于字符串，用于指定從字符串左側開始截取的子串字符個數(shù)
8) 使用const常量定義pi,編程從鍵盤輸入圓的周長和面積，使其輸出數(shù)據(jù)保留兩位小數(shù)
#include
void main()
{
const double pi=3.14159;
double r,circum,area;
printf("Please enter r:");
scanf("%lf",&r);
circum=2*pi*r;
area=pi*r*r;
printf("輸出沒有寬度和精度的值:");
printf("circum=%f,area=%f\n",circum,area);
printf("輸出沒有寬度和精度的值:");
printf("circum=%7.2f,area=%7.2f\n",circum,area);//域寬為7，占7個字符寬度，小數(shù)點也算一個字符，精度為2，小數(shù)點后保留2位
}
12.數(shù)據(jù)的格式化鍵盤輸入：
1) 函數(shù)scanf()的一般格式：scanf(格式控制字符串，參數(shù)地址表);
2) 格式控制字符串：包括格式轉換說明符，分隔符
3) 格式轉換說明符以%開始，以格式字符結束，用于指定各參數(shù)的輸入格式
4) 函數(shù)scanf()的格式轉換說明符：
%d — 輸入十進制整數(shù)
%o — 輸入八進制整數(shù)
%x — 輸入十六進制整數(shù)
%c — 輸入一個字符，空白字符(包括空格、回車、制表符)也作為有效字符輸入 %s — 輸入字符串，遇到第一個空白字符(包括空格、回車、制表符)時結束 %f或%e — 輸入實數(shù)，以小數(shù)或指數(shù)形式輸入均可
%% — 輸入一個%
5) 參數(shù)地址表：由若干變量的地址組成的列表，用逗號分隔
6) 函數(shù)scanf()中的格式修飾符：在%和格式符中間插入格式修飾符
英文字母l — 加在格式符d,o,x,u之前，用于輸入long型數(shù)據(jù);加在f,e之前，用于輸入double型數(shù)據(jù)
英文字母L — 加在格式符f,e之前，用于輸入long double型數(shù)據(jù)
英文字母h — 加在格式符d,o,x時，用于輸入short型數(shù)據(jù)
輸出域寬m — m為正整數(shù)，指定輸入數(shù)據(jù)的寬度，系統(tǒng)自動按此寬度截取所需數(shù)據(jù)
顯示精度 .n — n為0或正整數(shù)，scanf()沒有精度格式修飾符，輸入時不能規(guī)定精度 忽略輸入修飾符* — 表示對應的輸入項在讀入后不賦給相應的變量
7) 函數(shù)scanf()輸入數(shù)值型數(shù)據(jù)時，被認為輸入結束的幾種情況：遇空格符、回車符、制表符;達到輸出域寬;遇非法字符輸入
8) 如果函數(shù)scanf()的格式控制字符串中存在除格式轉換說明符以外的其他字符，必須將這些字符原樣輸入
#include
void main()
{
int a,b;
scanf("%d %d",&a,&b); //以空格作為分隔符，等價于scanf("%d%d",&a,&b),等價于scanf("%d %d",&a,&b)，
printf("a=%d,b=%d\n",a,b);//實際輸入時，空格、回車符、制表符都可作為分隔符，即輸入:12空格34 12回車34 12制表符34均可，
}
#include
void main()
{
int a,b;
scanf("%d,%d",&a,&b);//輸入時必須以逗號作為分隔符，即只能輸入：12,34
printf("a=%d,b=%d\n",a,b);
}
#include
void main()
{
int a,b;
scanf("a=%d,b=%d",&a,&b);//輸入時必須將"a="和"b="原樣輸入，即只能輸入：a=12,b=34 printf("a=%d,b=%d\n",a,b);
}
#include
void main()
{
int a,b;
scanf("%2d%2d",&a,&b);//輸入時將前兩位數(shù)讀入存到a中，接著兩位存到b中，然后結束讀取，即輸入：1234，或123456結果一樣
printf("a=%d,b=%d\n",a,b);
}
#include
void main()
{
int a,b;
scanf("%d %d",&a,&b);
printf("a=\"%d\",b=\"%d\"\n",a,b);//輸出a="12",b="34"
}
#include
void main()
{
int a,b;
scanf("%d%*c%d",&a,&b);//任意字符都可作為分隔符,即輸入：12,34或12?34或12+34結果都一樣
printf("a=%d,b=%d\n",a,b);
}
#include
void main()
{
int a,b;
scanf("%2d%*2d%d",&a,&b);//忽略兩位，輸入123456
printf("a=%d,b=%d\n",a,b);//輸出a=12,b=56
}
對于程序
#include
void main()
{
int a,b;
scanf("%d %d",&a,&b);
printf("a=%d,b=%d\n",a,b);
}
如果輸入12 34a回車，則結果a=12,b=3,程序在遇到非法字符a時，會導致程序輸入終止，此時a會讀入12，b會讀入3
如果輸入123a回車，則結果a=123,b=-858993460,程序在遇到非法字符a時，會導致程序輸入終止，此時a會讀入123，而b未能讀入指定數(shù)據(jù)項數(shù)
如果在scanf()函數(shù)中忘記在變量前加取地址運算符&，會導致非法內(nèi)存訪問
13.%c格式符使用幾種情況：
1) 用%c格式讀入字符時，空格字符和轉義字符(包括回車)都會被當做有效字符讀入 例：鍵盤輸入一個整數(shù)加法算式：操作數(shù)1+操作數(shù)2，輸出：操作數(shù)1+操作數(shù)2=計算結果
#include
void main()
{
int data1,data2;
char op; //輸入：12空格+空格3 回車//輸出：12 -858993460=-858993448
printf("Enter data1+data2\n");//輸入：12空格3 回車//輸出：12 3=15
scanf("%d%c%d",&data1,&op,&data2);//輸入：12+3 回車//輸出：12+3=15 printf("%d%c%d=%d\n",data1,op,data2,data1+data2);
}
2) 先輸入一個數(shù)據(jù)后再輸入字符型變量時，輸入一個數(shù)據(jù)后，輸入的回車符將被當做有效字符讀給字符型變量
例：編程從鍵盤先后輸入int型、char型和float型數(shù)據(jù)，要求每輸入一個數(shù)據(jù)就顯示這個數(shù)據(jù)的類型和數(shù)據(jù)值
void main()
{
int a;
char b;
float c;
printf("Please input an integer:");
scanf("%d",&a);
printf("integer:%d\n",a);
//在輸入一個整型數(shù)據(jù)后，輸入的回車符被當做有效字符讀給了字符型變量b了
printf("Please input a character:");
scanf("%c",&b);
printf("chracter:%c\n",b);
printf("Please input a float number:");
scanf("%f",&c);
printf("float:%f\n",c);
}
14.%c格式符存在問題的解決方法
1) 用函數(shù)getchar()將數(shù)據(jù)輸入時存入緩沖區(qū)中的回車符讀入，以避免被后面的字符型變量作為有效字符讀入
#include
void main()
{
int a;
char b;
float c;
printf("Please input an integer:");
scanf("%d",&a);
printf("integer:%d\n",a);
getchar();//將存于緩沖區(qū)中的回車符讀入，避免在后面作為有效字符讀入
//函數(shù)getchar()的返回值是一個回車符，已經(jīng)避免了錯誤，不需要再將其賦給字符型變量使用
printf("Please input a character:");
scanf("%c",&b);
printf("chracter:%c\n",b);
printf("Please input a float number:");
scanf("%f",&c);
printf("float:%f\n",c);
}
2) 在%c前面加一個空格，將前面數(shù)據(jù)輸入時存于緩沖區(qū)的回車符讀入，避免被后面的字符型變量作為有效字符讀入
void main()
{
int a;
char b;
float c;
printf("Please input an integer:");
scanf("%d",&a);
printf("integer:%d\n",a);
printf("Please input a character:");
scanf(" %c",&b);//在%c前面加空格，將存于緩沖區(qū)中的回車符讀入
printf("chracter:%c\n",b);
printf("Please input a float number:");
scanf("%f",&c);
printf("float:%f\n",c);
}
//解釋：在%c前加空格為什么能將存于緩沖區(qū)中的回車符讀入
因為如果函數(shù)scanf()的格式控制字符串中存在除格式轉換說明符以外的其他字符，必須將這些
字符原樣輸入，所以在%c前加空格，就必須在輸入字符型數(shù)據(jù)前先原樣輸入空格，而空格，回車符，制表符在
函數(shù)scanf()輸入數(shù)值型數(shù)據(jù)時都代表輸入結束，由實踐可知，空格符、回車符、制表符在輸入時等效
所以，緩沖區(qū)中的回車將代替需要原樣輸入的空格，因此，實際上，在%c前增加空格或者Tab鍵都可以完成，
并且與增加的`數(shù)量無關，且可以混合增加
3)*經(jīng)典例題：編程實現(xiàn)鍵盤任意輸入字符，統(tǒng)計字母、數(shù)字、空格、其他字符數(shù)量 首選字符串的方法：
#include
#define N 100
int main()
{
char a[N];
int i,m=0,n=0,b=0,c=0;
printf("請輸入字符：\n");
gets(a);
for(i=0;a[i]!='\0';i++)
{
if((a[i]>='a'&&a[i]<='z')||(a[i]>='A'&&a[i]<='Z')) m++;
else if(a[i]>=0&&a[i]<=9) n++;
else if(a[i]==' ') b++;
else c++;
}
printf("字母個數(shù)：%d\n",m);
printf("數(shù)字個數(shù)：%d\n",n);
printf("空格個數(shù)：%d\n",b);
printf("其他字符個數(shù)：%d\n",c);
return 0;
}
單個字符輸入的方法，但是要解決緩沖區(qū)的問題
#include
int main()
{
char ch;
int a,b,c,d;
a=b=c=d=0;
printf("請輸入字符:\n");
do{
ch=getchar();
getchar();//清除緩沖區(qū)的回車鍵，不然會當做第二個字符讀入
if(ch!=' ')//用Tab鍵控制輸入結束，他在程序中只會出現(xiàn)一次并且統(tǒng)計一次， { //然后結束，所以要去掉它，可以使用if語句，也可在前面初始化為d=-1 if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')) a++;
else if(ch>='0'&&ch<='9') b++;
else if(ch==' ') c++;
else d++;
}
}while(ch!=' ');
printf("字母個數(shù)：%d\n",a);
printf("數(shù)字個數(shù)：%d\n",b);
printf("空格個數(shù)：%d\n",c);
printf("其他字符個數(shù)：%d\n",d);
return 0;
}
//解釋：你可以把Tab控制結束改成其他任意字符，包括字母、數(shù)字、/;都可以，
就是不能直接使用回車控制結束，因為你在實際鍵盤輸入時，需要打回車才能把前面的 字符讀入，當你輸完回車后，就已經(jīng)換行了，再回車就達不到你要的效果了，不可能把 他讀入，但是他會留在緩沖區(qū)下一次使用，所以說，理論上任意字符都可以控制結束， 但是不能直接使用回車再回車的方法，而getchar()函數(shù)一次只能讀一個字符，當你回車 讀入字符后，回車符就會留在緩沖區(qū)下一次使用，你可以試試，你把getchar()這行語句 注釋，然后一次輸入兩個字符再回車的話，那么這時他也只能讀入第一個字符，第二個 字符和回車就會計入第二次、第三次的結果。
總結：這種方式與用字符串的區(qū)別在于，字符串可以統(tǒng)計任何字符，但是這種方式不能統(tǒng)計 你用來控制結束的字符，比如說，你用/控制結束，那么就不能統(tǒng)計/的數(shù)量了，而且你要把 他去掉，因為在整個程序中/只會出現(xiàn)一次，然后就結束了
**當程序中出現(xiàn)兩次或以上的鍵盤輸入時，就有可能出現(xiàn)緩沖區(qū)的問題，只有一次輸入，回車直接結束沒有這種問題
15.考點題型：字符串常量的長度問題：
1)字符串常量"ab\\c\td\376"的長度是(A)
A) 7 B) 12 C) 8 D) 14
// a b \\ c \t d \376
2)語句printf("%d",strlen("abs\no12\1\\"));的輸出結果是(C)
A) 11 B) 10 C) 9 D) 8
// a b s \n o 1 2 \1 \\
16.考點題型：賦值運算、關系運算的混合運算問題：
1)設m,n,a,b,c,d的值均為0，執(zhí)行(m=a==b)||(n=c==d),m,n的值是(C)
A) 0,0 B) 0,1 C) 1,0 D) 1,1
// "=="是算術運算符，"="是賦值運算符，優(yōu)先級：算術運算符>賦值運算符，先判斷a==b?是否正確
正確則為真，把1賦給m,"||"是或運算，前面已經(jīng)為真，所以||后面的就不會再運算了，結果就為真
所以m=1,n=0不變
2)int a,b,m,n;初值依次為4,3,2,1,經(jīng)計算m=(a<=b)&&(n=m
A) 1,1 B) 1,0 C) 0,1 D) 0,0
// a<=b為假，&&是并，前面已經(jīng)為假，后面就不會再運算了，結果就為假，把0賦給m,即m=0,n=1不變
四、 選擇控制結構
1.沃思提出“數(shù)據(jù)結構+算法=程序”只在面向過程的語言(如C語言)成立
2.算法的正確性衡量方法：
1)有窮性 2)確定性 3)有效性 4)允許沒有輸入或者有多個輸入 5)必須有一個或者多個輸出
3.算法的描述方法：
1)自然語言描述 2)流程圖描述 3)NS結構化流程圖描述 4)偽碼描述
4.關系表達式:用作判斷條件，結果只有真和假，(n%2!=0)等價于(n%2),0表示假，非0表示真
5.分支結構：當條件P成立時，執(zhí)行A操作，否則執(zhí)行B操作;如果B操作為空，即為單分支結構;
如果B操作不為空，即為雙分支結構;如果B操作中又包含另一選擇結構，則構成多分支選擇結構;
6.單分支例題：計算輸出兩整數(shù)最大值
單分支(一般形式)：if(表達式P) 語句A
#include
void main()
{
int a,b,max;
printf("Enter a,b:");
scanf("%d%d",&a,&b);
if(a>b) //單分支：if(表達式P) 語句A
max=a;
if(a<=b) //單分支：if(表達式P) 語句A
max=b;
printf("max=%d\n",max);
}
7.雙分支例題：計算輸出兩整數(shù)最大值
雙分支(一般形式):if(表達式P) 語句1
else 語句2
#include
void main()
{
int a,b,max;
printf("Enter a,b:");
scanf("%d%d",&a,&b);
if(a>b)
max=a;
else
max=b;
printf("max=%d\n",max);
}
8.條件運算符是C語言中唯一的三元運算符，需要三個操作數(shù)
9.條件運算符例題：計算輸出兩整數(shù)最大值
條件運算符(一般形式)：表達式1?表達式2：表達式3
含義：若表達式1為非0，則結果為表達式2的值，否則是表達式3的值
#include
void main()
{
int a,b,max;
printf("Enter a,b:");
scanf("%d%d",&a,&b);
max=a>b?a:b;
printf("max=%d\n",max);
}
10.多分支控制條件語句(一般形式)：
if(表達式1) 語句1
else if(表達式2) 語句2
...
else if(表達式m) 語句m
else 語句m+1
11.條件語句在語法上只允許每個條件分支中帶一條語句，而要在分支里處理多條語句 就要使用花括號，構成復合語句
12.隨機數(shù)的使用方法：
1) 符號常量RAND_MAX在頭文件#include中定義，標準C規(guī)定RAND_MAX不大于雙字節(jié)整數(shù)的最大值32767
2)隨機函數(shù)rand()產(chǎn)生的是一個在0~RAND_MAX之間的整數(shù),即[0,32767]之間的整數(shù)
3) 利用求余運算rand()%b可將函數(shù)rand()生成的隨機數(shù)變化到[0,b-1]
4) 利用rand()%b+a可將隨機數(shù)的取值范圍平移到[a,a+b-1]
例：產(chǎn)生1~100的隨機數(shù)： rand()%100+1
13.例題：猜數(shù)游戲：計算機想一個數(shù)，人猜對了提示Right!,否則提示W(wǎng)rong!，并告訴大小 #include
#include
void main()
{
int magic,guess;
magic=rand(); //隨機數(shù)
printf("Please guess a number:");
scanf("%d",&guess);
if(guess>magic) //多分支
{
printf("Wrong!Too big!\n"); //復合語句
}
else if(guess
{
printf("Wrong!Too small!\n");
}
else{
printf("Right!\n");
printf("The number is:%d\n",magic);
}
}
14.switch語句：用于多路選擇，一般情況大于三種，用開關語句代替條件語句
1) switch語句(一般形式)：
switch(表達式)
{
case 常量1：
可執(zhí)行語句序列1 //注意：語句序列不使用花括號
case 常量2:
可執(zhí)行語句序列2
........
case 常量n:
可執(zhí)行語句序列n
default:
可執(zhí)行語句序列n+1
}
2) switch語句相當于一系列的if-else語句
3)switch后圓括號內(nèi)的表達式只能是char型或int型
4)關鍵字case后接常量，類型與表達式類型一致，常量的值必須互不相同
5)常量與case中間至少有一個空格，常量后面是冒號
6)case本身并沒有條件判斷的功能，若case后面的語句省略不寫，則表示它與后續(xù)case執(zhí)行相同的語句
7)switch語句的執(zhí)行過程：
第一步，計算switch后表達式的值
第二步，將表達式的值依次與case后的常量比較
第三步，如果相等，執(zhí)行case后的代碼段，執(zhí)行完畢，可使用break語句跳出switch語句
如果沒有break語句，不會再比較，程序將依次執(zhí)行下面的case后的語句，直到遇到break或者switch的}為止
15.例題：編程實現(xiàn)簡單計算器功能
#include
void main()
{
int data1,data2;
char op;
printf("Enter your expression:");
scanf("%d%c%d",&data1,&op,&data2);
switch(op)
{
case '+':
printf("%d+%d=%d\n",data1,data2,data1+data2);
break;
case '-':
printf("%d-%d=%d\n",data1,data2,data1-data2);
break;
case '*':
case 'x':
case 'X':
printf("%d*%d=%d\n",data1,data2,data1*data2);
break;
case '/':
if(0==data2)//也可寫成data2==0,寫0==data2的好處：
{ //因為賦值表達式左值必須是變量，如果把==誤寫成=，會提示錯誤
printf("Division by zero!\n");
}
else{
printf("%d/%d=%d\n",data1,data2,data1/data2);
}
break;
default:
printf("Invalid operator!\n");
//break;這句一般不需要，因為沒有break就會依次執(zhí)行下面的步驟直到break或者switch的}
} //這里已經(jīng)是switch的}了
}
16.例題：編程實現(xiàn)簡單計算器功能，能進行浮點數(shù)運算，操作數(shù)與運算符之間可加入任意多個空格
#include
#include
void main()
{
float data1,data2;
char op;
printf("Enter your expression:");
scanf("%f %c%f",&data1,&op,&data2);
switch(op)
{
case '+':
printf("%f+%f=%f\n",data1,data2,data1+data2);
break;
case '-':
printf("%f-%f=%f\n",data1,data2,data1-data2);
break;
case '*':
case 'x':
case 'X':
printf("%f*%f=%f\n",data1,data2,data1*data2);
break;
case '/':
if(fabs(data2)<=1e-7)
{
printf("Division by zero!\n");
}
else{
printf("%f/%f=%f\n",data1,data2,data1/data2);
}
break;
default:
printf("Invalid operator!\n");
}
}
//內(nèi)存中的浮點數(shù)所表示的精度是有限的，所以比較實型變量data2與0是否相等時， 不能像整型變量與0比較那樣直接用相等關系運算符與0比較，而應使用如下方式判斷 實型變量data2的值是否位于0附近的一個很小的區(qū)間內(nèi)，即：if(fabs(data2)<=1e-7)
17.邏輯運算符和邏輯表達式
邏輯非：!,單目運算符，右結合, 優(yōu)先級最高
邏輯與：&&,雙目運算符，左結合，優(yōu)先級較高
邏輯或：||,雙目運算符，左結合，優(yōu)先級較低
例：判斷某一年year是否是閏年的條件：
1) 能被4整除，但不能被100整除;
1)能被400整除
邏輯表達式：((year%4==0)&&(year%100!=0))||(year%400==0)
或：(year%4==0)&&(year%100!=0)||(year%400==0)
18.特別注意：在計算含有邏輯運算符(&&和||)的表達式時，通常盡量使用最少的操作數(shù)來 確定表達式的值，這就意味著表達式中的某些操作數(shù)可能不會被計算。
例：if(a>1&&b++>2&&c--!=0)中，僅在條件表達式a>1為真時，才會計算后面的值
19.程序測試：
1)程序測試只能證明程序有錯，不能證明程序無錯
2)例：編程輸入三角形三邊長a,b,c,判斷他們能否構成三角形，能構成什么三角形 #include
#include
#define EPS 1e-1
void main()
{
float a,b,c;
int flag=1;
printf("Enter a,b,c:");
scanf("%f,%f,%f",&a,&b,&c);
if(a+b>c&&b+c>a&&a+c>b)
{
if(fabs(a-b)<=EPS&&fabs(b-c)<=EPS&&fabs(c-a)<=EPS)
{
printf("等邊");
flag=0;
}
else if(fabs(a-b)<=EPS||fabs(b-c)<=EPS||fabs(c-a)<=EPS)
{
printf("等腰");
flag=0;
}
if(fabs(a*a+b*b-c*c)<=EPS||fabs(b*b+c*c-a*a)<=EPS||fabs(a*a+c*c-b*b)<=EPS) {
printf("直角");
flag=0;
}
if(flag)
{
printf("一般");
}
printf("三角形\n");
}
else{
printf("不是三角形\n");
}
}
3)例：編程將輸入的百分制成績轉換為五分制成績輸出
#include
void main()
{
int score,mark;
printf("Enter score:");
scanf("%d",&score);
if(score<0||score>100)
{
mark=-1;//這個if語句很重要，如果去掉，邊界測試101~109，-1~-9會出錯 }
else{
mark=score/10;
}
switch(mark)
{
case 10:
case 9:
printf("%d-優(yōu)!\n",score);
break;
case 8:
printf("%d-良!\n",score);
break;
case 7:
printf("%d-中!\n",score);
break;
case 6:
printf("%d-及格!\n",score);
case 5:
case 4:
case 3:
case 2:
case 1:
case 0:
printf("%d-不及格!\n",score);
break;
default:
printf("Input error!\n");
}
}
20.對輸入非法字符的檢查與處理
1)例：輸入兩個整型數(shù)，計算并輸出兩個整數(shù)的最大值
#include
void main()
{
int a,b,max;
printf("Enter a,b:");
scanf("%d,%d",&a,&b);
max=a>b?a:b;
printf("max=%d\n",max);
}
//隱含問題：在Visual C++下
1.如果輸入3.2,1則輸出3
2.如果輸入1,3.2則輸出3
3.如果輸入q則輸出-858993460
//解決辦法：
#include
void main()
{
int a,b,max,ret;
do{
printf("Enter a,b:");
ret=scanf("%d,%d",&a,&b);
if(ret!=2)//返回在遇到非法字符前已成功讀入的數(shù)據(jù)項數(shù)
{
//但是scanf()函數(shù)不做類型檢查，所以輸入1,3.2會輸出3
printf("Input error!\n");
while(getchar()!='\n');
}
else{
max=a>b?a:b;
printf("max=%d\n",max);
}
}while(ret!=2);
}
21.位運算符的使用
1)位運算是對字節(jié)或字內(nèi)的二進制數(shù)位進行測試、抽取、設置或移位等操作
2) 位運算的操作對象只能是char和int類型
3) C語言中共有6種位運算符，只有按位取反是單目運算符，其他都是雙目運算符
4)關系運算和邏輯運算的結果要么是0，要么是1，而位運算結果可為任意值，但每一位都只能是0或1
5)6種位運算符：
按位取反 ~ 用于加密處理，一次求反加密，二次求反解密
左移位 <<
右移位 >>
按位與 & 用于對字節(jié)中某位清零
按位異或 ^
按位或 | 用于對字節(jié)中某位置1
6)按位取反 ~1=0，~0=1
例：~5=-6
~ 00000101
———————
11111010 是-6的補碼
7)按位與 0&0=0,0&1=0,1&1=1
例：將15的最低位不變，其余位清零 15&1=1
00001111
& 00000001
——————
00000001
8)按位或 0|0=0,0|1=1,1|1=1
例：將15的最高位不變，其余位均置1 15|127=127
00001111
| 01111111
——————
01111111 是127的補碼
9)按位異或 0^0=0,0^1=1,1^1=0
例：3^5=6
00000011
^ 00000101
——————
00000110 是6的補碼
10)左移位
x<
例：將15左移1、2、3位的二進制補碼如下
初始字節(jié)內(nèi)容 00001111 對應十進制15
左移1位字節(jié)內(nèi)容 00011110 對應十進制30
左移2位字節(jié)內(nèi)容 00111100 對應十進制60
左移3位字節(jié)內(nèi)容 01111000 對應十進制120
11)右移位
x>>n 表示把x的每一位向右移n位，當x為有符號數(shù)時，左邊空位補符號位值—算術移位
當x為無符號位時，左邊空位補0—邏輯移位
例1：將15右移1、2、3位的二進制補碼如下
初始字節(jié)內(nèi)容 00001111 對應十進制15
右移1位字節(jié)內(nèi)容 00000111 對應十進制7
右左移2位字節(jié)內(nèi)容 00000011 對應十進制3
右移3位字節(jié)內(nèi)容 00000001 對應十進制1
例2：將-15右移1、2、3位的二進制補碼如下
初始字節(jié)內(nèi)容 11110001 對應十進制-15
右移1位字節(jié)內(nèi)容 11111000 對應十進制-8
右左移2位字節(jié)內(nèi)容 11111100 對應十進制-4
右移3位字節(jié)內(nèi)容 11111110 對應十進制-2
12) 無論左移位還是右移位，從一端移走的位不移入另一端，移走的位的信息就丟失了
13)左移位和右移位可以分表代替整數(shù)的乘法和除法，左移n位相當于乘以2^n,右移n為相當于除以2^n
14) 例：寫出運行結果
#include x 0000 0000 0000 1100
void main() ~x 1111 1111 1111 0011
{ ~x反碼1000 0000 0000 1100
int x=12,y=8; ~x反碼加一1000 0000 0000 1101 -13 printf("%5d%5d%5d\n",!x,x||y,x&&y);
printf("%5u%5d%5d\n",~x,x|y,x&y);
printf("%5d%5d%5d\n",~x,x|y,x&y);
}
輸出： 0 1 1
4294967283 12 8
-13 12 8
五、循環(huán)控制結構
1.循環(huán)：包括計數(shù)控制的循環(huán)和條件控制的循環(huán)
2.結構化程序設計的三種基本結構：順序結構、選擇結構、循環(huán)結構
3.循環(huán)結構的類型：
1)當型循環(huán)結構：for語句(適合循環(huán)次數(shù)已知,計數(shù)控制的循環(huán))
2)直到型循環(huán)結構：while語句、do-while語句(適合循環(huán)次數(shù)未知,條件控制的循環(huán))
4.while語句
1)一般形式為：
while(循環(huán)控制表達式)
{ |
語句系列 |循環(huán)體
} |
2)循環(huán)控制表達式在執(zhí)行循環(huán)體之前測試
3)執(zhí)行過程：
計算循環(huán)控制表達式的值
如果循環(huán)控制表達式的值為真，那么執(zhí)行循環(huán)體中的語句，并返回步驟1
如果循環(huán)控制表達式的值為假，就退出循環(huán)，執(zhí)行循環(huán)體后面的語句
5.do-while語句
1)一般形式為：
do
{ |
語句系列 |循環(huán)體
}while(循環(huán)控制表達式);
2)循環(huán)控制表達式在執(zhí)行循環(huán)體之后測試
3)執(zhí)行過程：
執(zhí)行循環(huán)體中的語句
計算循環(huán)控制表達式的值
如果循環(huán)控制表達式的值為真，那么返回步驟1
如果循環(huán)控制表達式的值為假，就退出循環(huán)，執(zhí)行循環(huán)體后面的語句
6.for語句
1)一般形式為：
for(初始化表達式;循環(huán)控制表達式;增值表達式)
{ |
語句系列 |循環(huán)體
} |
2) 在每次循環(huán)體被執(zhí)行之前，都要對循環(huán)控制條件測試一次，每次循環(huán)體執(zhí)行完以后都要執(zhí)行一次增值表達式
3)初始化表達式作用：循環(huán)變量初始化，即賦初值
4)循環(huán)控制表達式：是控制繼續(xù)執(zhí)行的條件，當表達式的值為非0時重復執(zhí)行循環(huán)
5)增值表達式作用：每執(zhí)行一次循環(huán)，循環(huán)控制變量增值
6)for語句三個表達式之間用分號分隔，有且只能有兩個分號
7)循環(huán)控制表達式若省略，表示循環(huán)條件為永真
8)初始化表達式和增值表達式都可省略，但是必須有其他語句反應其作用
7.例：從鍵盤輸入n,然后計算輸出1+2+3+??n的值
1)while語句編程實現(xiàn)
#include
void main()
{
int i=1,n,sum=0;//sum一定要初始化，不然會是隨機值
printf("Enter n:");
scanf("%d",&n);
while(i<=n)
{
sum+=i;
i++;
}
printf("1+2+3+??+%d=%d\n",n,sum);
}
2)do-while語句編程實現(xiàn)
#include
void main()
{
int i=0,n,sum=0;
printf("Enter n:");
scanf("%d",&n);
do
{
sum+=i;
i++;
}while(i<=n);
printf("1+2+3+??+%d=%d\n",n,sum);
}
3)for語句編程實現(xiàn)
#include
void main()
{
int i=1,n,sum=0;
printf("Enter n:");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
sum+=i;
}
printf("1+2+3+??+%d=%d\n",n,sum);
}
8.逗號運算符
1)所有運算符中優(yōu)先級最低，左結合
2)作用：可實現(xiàn)對各個表達式的順序求值
3)結果：將最后一個表達式的值作為整個逗號表達式的值
4)例：從鍵盤輸入n,然后計算輸出1+2+3+??n的值
#include
void main()
{
int i,j,n,sum=0;
printf("Enter n:");
scanf("%d",&n);
for(i=1,j=n;i<=j;i++,j--)
{
sum+=i+j;
}
printf("1+2+3+??+%d=%d\n",n,sum);
}
9.空語句
1)僅由一個分號構成的語句
2)作用：什么也不做，只起延時作用
3)例：for(i=1;i<50000000;i++)
{
;
}
或for(i=1;i<50000000;i++)
{
}
或for(i=1;i<50000000;i++);
for(i=1;i<=n;i++);
{
sum+=i;
}
等價于
for(i=1;i<=n;i++)
{
;
}
sum+=i;
4) 例：從鍵盤輸入n,然后計算輸出1+2+3+??n的值
#include
void main()
{
int i,j,n,sum=0;
printf("Enter n:");
scanf("%d",&n);
for(i=1,j=n;i<=j;i++,j--);
{
sum+=i+j;
}
printf("1+2+3+??+%d=%d\n",n,sum);
}//輸出結果：101
10.死循環(huán)
1)while語句行末加分號將導致死循環(huán)
2)例:i=1;
while(i<=n);//行末加分號導致死循環(huán)
{
sum+=i;
i++;
}
相當于
i=1;
while(i<=n)//當輸入大于1的n值，循環(huán)體中沒有語句可以改變控制變量i { //使得循環(huán)條件為永真，導致死循環(huán)
;
}
sum+=i;
i++;
11.while語句和do-while語句的區(qū)別
1)while先判斷后執(zhí)行，有可能一次都不執(zhí)行，do-while先執(zhí)行后判斷，至少執(zhí)行一次
2)例：n=101; n=101;
while(n<100) do
{ {
printf("n=%d\n",n); printf("n=%d\n",n);
n++; n++;
} }while(n<100);
//循環(huán)一次也不執(zhí)行 //結果：輸出n=101，循環(huán)執(zhí)行一次
3)例：分別用while和do-while語句編程，輸入一組數(shù)據(jù)，然后顯示每次輸入數(shù)據(jù)進行累加運算的結果，輸入0結束
do-while語句實現(xiàn)：
#include
void main()
{
int num,sum=0;
do{
printf("Enter num:");
scanf("%d",&num);
sum+=num;
printf("sum=%d\n",sum);
}while(num!=0);
}
while語句實現(xiàn)
#include
void main()
{
int num=1,sum=0;//給num賦任意非0值都可以
while(num!=0)
{
printf("Enter num:");
scanf("%d",&num);
sum+=num;
printf("sum=%d\n",sum);
}
}
12.計數(shù)控制的循環(huán)：循環(huán)次數(shù)事先已知的循環(huán)
1)例1：編寫一個程序，從鍵盤輸入n,計算輸出n! #include
void main()
{
int i,n,sum=1;
printf("Enter n:");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
sum*=i;
}
printf("%d!=%ld\n",n,sum);
}
2)例2：編寫一個程序，從鍵盤輸入n,計算輸出1!,2!??n! #include
void main()
{
int i,n,sum=1;
printf("Enter n:");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
sum*=i;
printf("%2d!=%ld\n",i,sum);
}
}
3)例：鍵盤輸入n,編程計算1!+2!+3!+??+n!
#include
void main()
{
int term=1,sum=0,i,n;
printf("Enter n:");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
term*=i;
sum+=term;
}
printf("1!+2!+3!+??+%d!=%ld\n",n,sum);
}
13.條件控制的循環(huán)：循環(huán)次數(shù)事先未知，由條件控制
1)例1：輸入兩個整型數(shù)，計算并輸出兩個整型數(shù)的最大值，如若輸入非法字符，提示錯誤并重新輸入
//解釋：非法字符，需要輸入數(shù)字時，字符相對它來說就是非法字符，而需要輸入字符型，數(shù)字對它不是非法字符，所有都是合法
#include
void main()
{
int a,b,max,ret;
printf("Enter a,b:");
ret=scanf("%d %d",&a,&b);
while(ret!=2)//判斷數(shù)據(jù)個數(shù)或格式是否錯誤
{
while(getchar()!='\n');//清除緩沖區(qū)中的錯誤數(shù)據(jù)
printf("Enter a,b:");
ret=scanf("%d %d",&a,&b);
}
max=a>b?a:b;
printf("max=%d\n",max);
}
//注意：scanf()函數(shù)不做參數(shù)類型匹配檢查，當輸入1 3.2時，scanf返回2，不會導致重新輸入
但是，此后的小數(shù)點仍留在緩沖區(qū)，如果此后還需輸入內(nèi)容，就要先清除緩沖區(qū)內(nèi)容
2)例2：先由計算機想一個1-100之間的數(shù)請人猜，若猜對，則計算機提示Right!結束 游戲，否則提示W(wǎng)rong!,并告訴人是大是小，直到猜對為止，記錄人猜的次數(shù)，反應猜數(shù)的水平
#include
#include
void main()
{
int magic;
int guess;
int counter=0;
magic=rand()%100+1;
do{
printf("Please guess a magic number:");
scanf("%d",&guess);
counter++;
if(guess>magic)
{
printf("Wrong!Too big!\n");
}
else if(guess
{
printf("Wrong!Too small!\n");
}
else{
printf("Right!\n");
}
}while(guess!=magic);
printf("counter=%d\n",counter);
}
14.隨機數(shù)的使用
a.隨機數(shù)的產(chǎn)生： rand()
1) 符號常量RAND_MAX在頭文件#include中定義，標準C規(guī)定RAND_MAX不大于雙字節(jié)整數(shù)的最大值32767
2)隨機函數(shù)rand()產(chǎn)生的是一個在0~RAND_MAX之間的整數(shù),即[0,32767]之間的整數(shù)
3) 利用求余運算rand()%b可將函數(shù)rand()生成的隨機數(shù)變化到[0,b-1]
4) 利用rand()%b+a可將隨機數(shù)的取值范圍平移到[a,a+b-1]
b.隨機數(shù)的產(chǎn)生： srand(time(NULL))
1)用rand()直接產(chǎn)生的隨機數(shù)只是一個偽隨機數(shù)，反復調(diào)用產(chǎn)生的隨機數(shù)序列是一樣的，而且每次都只用第一個
2)隨機化：使程序每次運行時產(chǎn)生不同的隨機數(shù)序列的過程
3)隨機化的實現(xiàn)：通過調(diào)用標準庫函數(shù)srand()為函數(shù)rand()設置隨機數(shù)種子來實現(xiàn)
4)隨機數(shù)種子的設置：
法1：每次通過用戶輸入來完成隨機化，srand(1),srand(2),srand(seed),輸入seed
法2：的通過函數(shù)time()讀取計算機的時鐘值，并把該值設置為隨機數(shù)種子srand(time(NULL))
5)函數(shù)time()返回以秒計算的當前時間值，即一個代表時間的字符串，使用NULL作為time()的參數(shù)時，
time(NULL)的返回值被轉換成一個無符號整數(shù)，可作為隨機數(shù)發(fā)生器的種子
6)使用time()函數(shù)時，必須在程序開頭將頭文件包含到程序中
15.例：先由計算機想一個1-100之間的數(shù)請人猜，若猜對，則計算機提示Right!結束
游戲，否則提示W(wǎng)rong!,并告訴人是大是小，直到猜對為止，記錄人猜的次數(shù)，反應猜數(shù)的水平
#include
#include
#include
void main()
{
int magic;
int guess;
int counter=0;
srand(time(NULL));
magic=rand()%100+1;
do{
printf("Please guess a magic number:");
scanf("%d",&guess);
counter++;
if(guess>magic)
{
printf("Wrong!Too big!\n");
}
else if(guess
{
printf("Wrong!Too small!\n");
}
else{
printf("Right!\n");
}
}while(guess!=magic);
printf("counter=%d\n",counter);
}
16.例：先由計算機想一個1-100之間的數(shù)請人猜，若猜對，則計算機提示Right!屏幕輸出多少次成功，
結束游戲，否則提示W(wǎng)rong!,并告訴人是大是小，最多猜10次，超過就結束,要避免非法字符的輸入
#include
#include
#include
void main()
{
int magic;
int guess;
int counter=0;
int ret;//保存scanf()函數(shù)的返回值
srand(time(NULL));
magic=rand()%100+1;
do{
printf("Please guess a magic number:");
ret=scanf("%d",&guess);
while(ret!=1)//若存在輸入錯誤，則重新輸入
{
while(getchar()!='\n');//清楚緩沖區(qū)中的內(nèi)容
printf("Please guess a magic number:");
ret=scanf("%d",&guess);
} //若存在非法字符，則重新輸入
counter++;
if(guess>magic)
{
printf("Wrong!Too big!\n");
}
else if(guess
{
printf("Wrong!Too small!\n");
}
else{
printf("Right!\n");
}
}while(guess!=magic&&counter<10);
printf("counter=%d\n",counter);
}
延伸拓展：先由計算機想一個1-100之間的數(shù)請人猜，若猜對，則計算機提示Right!屏幕輸出多少次成功，
結束游戲，否則提示W(wǎng)rong!,并告訴人是大是小，最多猜10次，超過就繼續(xù)猜下一個數(shù),每次運行程序，可
反復猜多個數(shù)，直到操作者想停時結束，要注意避免非法字符輸入的問題
#include
#include
#include
void main()
{
int magic;
int guess;
int counter;
char reply;//保存用戶輸入的答案
int ret;//保存scanf()函數(shù)的返回值
srand(time(NULL));
do{
magic=rand()%100+1;
counter=0;
do{
printf("Please guess a magic number:");
ret=scanf("%d",&guess);
while(ret!=1)//若存在輸入錯誤，則重新輸入
{
while(getchar()!='\n');//清楚緩沖區(qū)中的內(nèi)容
printf("Please guess a magic number:");
ret=scanf("%d",&guess);
} //若存在非法字符，則重新輸入
counter++;
if(guess>magic)
{
printf("Wrong!Too big!\n");
}
else if(guess
{
printf("Wrong!Too small!\n");
}
else{
printf("Right!\n");
}
}while(guess!=magic&&counter<10);
printf("counter=%d\n",counter);
printf("Do you want to continue(Y/N or y/n)?");
scanf(" %c",&reply);//%c前有一個空格，讀取緩沖區(qū)中的回車符
}while(reply=='Y'||reply=='y');
}
17.設計一個簡單計算器，允許連續(xù)做多次算術運算
#include
#include
void main()
{
float data1,data2;
char op;
char reply;
do{
printf("Please enter your expression:\n");
scanf("%f %c%f",&data1,&op,&data2);//加空格可在操作數(shù)和運算符之間加任意多個空白符
switch(op)
case '+':
printf("%f+%f=%f\n",data1,data2,data1+data2);
break;
case '-':
printf("%f-%f=%f\n",data1,data2,data1-data2);
break;
case '*':
case 'X':
case 'x':
printf("%f*%f=%f\n",data1,data2,data1*data2);
break;
case '/':
if(fabs(data2)<=1e-7)
{
printf("Division by zero!\n");
}
else{
printf("%f/%f=%f\n",data1,data2,data1/data2);
}
break;
default:
printf("Invalid operator!\n");
}
printf("Do you want to continue(Y/y or N/n)?");
scanf(" %c",&reply);//加空格清除緩沖區(qū)中的回車符
}
while(reply=='Y'||reply=='y');
}
18.嵌套循環(huán)
一個循環(huán)語句放在另一個循環(huán)語句中構成的循環(huán)稱為嵌套循環(huán)
1) 嵌套循環(huán)的總循環(huán)次數(shù)等于外層循環(huán)次數(shù)和內(nèi)層循環(huán)次數(shù)的乘積
2)為避免造成混亂，嵌套循環(huán)的內(nèi)層和外層的循環(huán)控制變量不要同名
3)例：鍵盤輸入n,編程計算1!+2!+3!+??+n!
#include
void main()
{
int term,sum=0,i,j,n;
printf("Enter n:");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
term=1;
for(j=1;j<=i;j++)
term*=j;
}
sum+=term;
}
printf("1!+2!+3!+??+%d!=%ld\n",n,sum);
}
19累加求和構成規(guī)律：
1)當累加項較為復雜或者前后項之間無關時，需要單獨計算每個累加項
2)當累加項前項與后項之間有關時，根據(jù)前項計算后項
#include
void main()
{
int i,n;
long term=1,sum=0;
printf("Enter n:");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
term=term*i;
sum=sum+term;
}
printf("1!+2!+3!+??%d=%ld\n",n,sum);
}
20.goto語句
1)功能：使程序無條件跳轉到語句標號所標識的語句去執(zhí)行,所跳過的語句不再執(zhí)行
2)一般形式：
①向前跳轉 ②向后跳轉
goto 語句標號; 語句標號:??(后)
?? ??
語句標號:?? (前) goto 語句標號;
3)應用：通常情況,goto語句與if語句聯(lián)合使用
if(表達式) goto語句標號; 語句標號:??
?? ??
語句標號:?? if(表達式) goto語句標號;
21.break語句
1)功能：①用于退出switch結構
②用于退出由while,do-while和for語句構成的循環(huán)體
2)原理：當執(zhí)行循環(huán)體遇到break語句時,循環(huán)體將立即終止,從循環(huán)語句后的第一條語句開始繼續(xù)執(zhí)行
3)應用：break語句通常與if聯(lián)合使用,表明在任何條件下跳轉到緊接循環(huán)語句后的第一條語句
22.continue語句
1)功能：跳過continue后面尚未執(zhí)行的語句,開始下一次循環(huán),只結束本次循環(huán),不終止整
個循環(huán)
2)例題：
#include
void main()
{
int i,n;
for(i=1;i<=5;i++)
{
printf("Please enter n:");
scanf("%d",&n);
if(n<0) continue;
printf("n=%d\n",n);
}
printf("Program is over!\n");
}
23.函數(shù)exit()
1) 標準庫函數(shù)exit()用于控制程序的流程,調(diào)用時,需要加頭文件
2)一般形式:exit(code);
3)功能：終止整個程序的執(zhí)行,強制返回操作系統(tǒng),并將int型參數(shù)code的值傳給調(diào)用進程 (一般為操作系統(tǒng)),當code的值為0或宏常量EXIT_FAILURE,表示程序出現(xiàn)某種錯誤后退出
24.goto,break,continue,exit()的比較
1)goto,break,continue,exit()都用于控制程序的流程,前三個是流程控制語言,exit()是C標準函數(shù)
1)功能：goto語句可以向任意方向跳轉,break語句只限定流程跳轉到循環(huán)語句之后 的第一條語句,continue語句結束本次循環(huán),exit()直接終止所有程序
2)break,goto語句和exit()函數(shù)都可用于終止整個循環(huán)的執(zhí)行,continue不能終止整個循環(huán)
3)在嵌套循環(huán)下,break語句和continue語句只對包含他們的最內(nèi)層循環(huán)語句起作用, 不能用break語句跳出多重循環(huán),只能一層一層的跳出
4)使用goto語句的兩種特定情形：
①快速跳出多重循環(huán)
②跳向共同的出口位置,進行退出前的錯誤處理工作
25.例題：韓信點兵:x%5==1&&x%6==5&&x%7==4&&x%11==10
①窮舉法(循環(huán)條件自定義,不具實際意義)
②break退出循環(huán)(循環(huán)條件省略,滿足條件結束循環(huán))
③exit(0)結束程序(循環(huán)條件省略,滿足條件結束整個程序)
④使用標志變量(循環(huán)條件為標識變量為0,最佳方法)
#include
void main()
{
int x;
int find=0;
for(x=1;!find;x++)
{
if(x%5==1&&x%6==5&&x%7==4&&x%11==10)
{
printf("x=%d\n",x);
find=1;
}
}
}
26.類型溢出
1)原因：當運算的結果超出了類型所能表示的數(shù)的上界,導致進位到達了最前面的符號 位或者更多進位的丟失,就會發(fā)生類型溢出
2)解決辦法：采用取值范圍更大的數(shù)據(jù)類型來定義變量
27.結構化程序設計的基本思想
1)采用順序、選擇和循環(huán)三種基本結構作為程序設計的基本單元,語法結構具有4個特性 ①只有一個入口
②只有一個出口
③無不可達語句,即不存在永遠執(zhí)行不到的語句
④無死循環(huán),即不存在永遠都執(zhí)行不完的循環(huán)
2)盡量避免使用goto語句,因為它破壞了結構化設計風格,并且容易帶來錯誤的隱患
3)采用自頂向下、逐步求精的模塊化程序設計方法進行結構化程序設計
c語言入門基礎知識
數(shù)據(jù)類型----C的數(shù)據(jù)類型包括：整型、字符型、實型或浮點型、枚舉類型、數(shù)組類型、結構體類型、共用體類型、指針類型和空類型。
常量與變量----常量其值不可改變，符號常量名通常用大寫。變量是以某標識符為名字，其值可以改變的量。變量在編譯時為其分配相應存儲單元。
數(shù)組----C++語言代碼如果一個變量名后面跟著一個有數(shù)字的中括號，這個聲明就是數(shù)組聲明。字符串也是一種數(shù)組。
指針----如果一個變量聲明時在前面使用 * 號，表明這是個指針型變量。換句話說，該變量存儲一個地址，指針不僅可以是變量的.地址，還可以是數(shù)組、數(shù)組元素、函數(shù)的地址。
字符串----C語言的字符串其實就是char型數(shù)組，使用字符型并不需要引用庫，但是使用字符串就就需要C標準庫里面的一些用于對字符串進行操作的函數(shù)。它們不同于字符數(shù)組。
文件輸入/輸出----在C語言中，輸入和輸出是經(jīng)由標準庫中的一組函數(shù)來實現(xiàn)的。標準輸入/輸出有三個標準輸入/輸出是標準I/O庫預先定義的：stdin標準輸入、stdout標準輸出、stderr輸入輸出錯誤。
運算----C語言的運算非常靈活，功能十分豐富，運算種類遠多于其它程序設計語言。
關鍵字----又稱為保留字，就是已被C語言本身使用，不能作其它用途使用的字。例如關鍵字不能用作變量名、函數(shù)名等標識符。由ANSI標準定義的C語言關鍵字共32個：
auto double int struct break else long switch
case enum register typedef char extern return union
const float short unsigned continue for signed void
default goto sizeof volatile do if while static inline
restrict _Bool _Complex _Imaginary _Generic
