07第四講c語言基礎知識_C語言知識總結

㈠ c語言基礎

設計》課程，大多學生覺的這門課程難學。其實，按照我們現在的教學大綱和教學要求，只要同學們掌握一些方法，克服心理上畏難、不輕言放棄，是完全可以學好的。
《C程序設計》的內容很豐富，按照我們現在的教學大綱，教學的主要內容是基礎知識、四種結構的的程序設計、函數與數組的應用和一些簡單的演算法。在學習時，同學們應該把主要精力放在這些部分，通過實踐（練習和上機調試等熟練掌握。當然，在初學C語言時，可能會遇到有些問題理解不透，或者表達方式與以往數學學習中不同（如運算符等），這就要求不氣餒，不明白的地方多問多想，鼓足勇氣進行學習，待學完後面的章節知識，前面的問題也就迎刃而解了，這一方面我感覺是我們同學最欠缺，大多學不好的就是因為一開始遇到困難就放棄，曾經和好多同學談他的問題，回答是聽不懂、不想聽、放棄這樣三個過程，我反問，這節課你聽過課嗎？回答又是沒有，根本就沒聽過課，怎麼說自己聽不懂呢？相應的根本就沒學習，又談何學的好？
學習C語言始終要記住「曙光在前頭」和「千金難買回頭看」，「千金難買回頭看」是學習知識的重要方法，就是說，學習後面的知識，不要忘了回頭弄清遺留下的問題和加深理解前面的知識，這是我們學生最不易做到的，然而卻又是最重要的。比如：在C語言中最典型的是關於結構化程序設計構思，不管是那種教材，一開始就強調這種方法，這時也許你不能充分體會，但是學到函數時，再回頭來仔細體會，溫故知新，理解它就沒有那麼難了。學習C語言就是要經過幾個反復，才能前後貫穿，積累應該掌握的C知識。
那麼，我們如何學好《C程序設計》呢？
一．學好C語言的運算符和運算順序
這是學好《C程序設計》的基礎，C語言的運算非常靈活，功能十分豐富，運算種類遠多於其它程序設計語言。在表達式方面較其它程序語言更為簡潔，如自加、自減、逗號運算和三目運算使表達式更為簡單，但初學者往往會覺的這種表達式難讀，關鍵原因就是對運算符和運算順序理解不透不全。當多種不同運算組成一個運算表達式，即一個運算式中出現多種運算符時，運算的優先順序和結合規則顯得十分重要。在學習中，只要我們對此合理進行分類，找出它們與我們在數學中所學到運算之間的不同點之後，記住這些運算也就不困難了，有些運算符在理解後更會牢記心中，將來用起來得心應手，而有些可暫時放棄不記，等用到時再記不遲。
先要明確運算符按優先順序不同分類，《C程序設計》運算符可分為15種優先順序，從高到低，優先順序為1 ~ 15，除第2、3級和第14級為從右至左結合外，其它都是從左至右結合，它決定同級運算符的運算順序。下面我們通過幾個例子來說明：
（1） 5*8/4%10 這個表達式中出現3種運算符，是同級運算符，運算順序按從左至右結合，因此先計算5 *8=40，然後被4除，結果為10，最後是%（求余數）運算，所以表達式的最終結果為10%10 = 0；
（2）a = 3;b = 5;c =++ a* b ；d =a + +* b；
對於c=++a*b來說，按表中所列順序，+ +先執行，*後執行，所以+ + a執行後，a的值為4，由於+ +為前置運算，所以a的值4參與運算，C的值計算式為4*5=20而不是3*5=15了；而對於d=a++*b來說，由於a + +為後置運算，所以a值為4參與運算，使得d的值仍為20，而a參與運算後其值加1，值為5。這個例子執行後，a的值為5，b的值為5，c的值為20，d的值也是20；
（3）（a = 3，b = 5，b+ = a，c = b* 5）
例子中的「，」是逗號結合運算，上式稱為逗號表達式，自左向右結合，最後一個表達式的結果值就是逗號表達式的結果，所以上面的逗號表達式結果為40，a的值為3，b的值為8，c的值為40。
（4）a=5;b=6;c=a>b?a:b;
例中的a>b?a:b是一個三目運算，它的功能是先做關系運算a>b部分，若結果為真，則取問號後a的值，否則取冒號後b的值，因此c的值應該為6，這個運算可以用來代替if…else…語句的簡單應用。
二．學好C語言的四種程序結構
（1）順序結構
順序結構的程序設計是最簡單的，只要按照解決問題的順序寫出相應的語句就行，它的執行順序是自上而下，依次執行。
例如；a = 3，b = 5，現交換a，b的值，這個問題就好象交換兩個杯子水，這當然要用到第三個杯子，假如第三個杯子是c，那麼正確的程序為： c = a； a = b； b = c；執行結果是a = 5，b = c = 3如果改變其順序，寫成：a = b； c = a； b = c；則執行結果就變成a = b = c = 5，不能達到預期的目的，初學者最容易犯這種錯誤。順序結構可以獨立使用構成一個簡單的完整程序，常見的輸入、計算，輸出三步曲的程序就是順序結構，例如計算圓的面積，其程序的語句順序就是輸入圓的半徑r，計算s = 3.14159*r*r,輸出圓的面積s。不過大多數情況下順序結構都是作為程序的一部分，與其它結構一起構成一個復雜的程序，例如分支結構中的復合語句、循環結構中的循環體等。
（2）分支結構
順序結構的程序雖然能解決計算、輸出等問題，但不能做判斷再選擇。對於要先做判斷再選擇的問題就要使用分支結構。分支結構的執行是依據一定的條件選擇執行路徑，而不是嚴格按照語句出現的物理順序。分支結構的程序設計方法的關鍵在於構造合適的分支條件和分析程序流程，根據不同的程序流程選擇適當的分支語句。分支結構適合於帶有邏輯或關系比較等條件判斷的計算，設計這類程序時往往都要先繪制其程序流程圖，然後根據程序流程寫出源程序，這樣做把程序設計分析與語言分開，使得問題簡單化，易於理解。程序流程圖是根據解題分析所繪制的程序執行流程圖。
學習分支結構不要被分支嵌套所迷惑，只要正確繪制出流程圖，弄清各分支所要執行的功能，嵌套結構也就不難了。嵌套只不過是分支中又包括分支語句而已，不是新知識，只要對雙分支的理解清楚，分支嵌套是不難的。下面我介紹幾種基本的分支結構。
①if(條件)
{
分支體
}
這種分支結構中的分支體可以是一條語句，此時「」可以省略，也可以是多條語句即復合語句。它有兩條分支路徑可選，一是當條件為真，執行分支體，否則跳過分支體，這時分支體就不會執行。如：要計算x的絕對值，根據絕對值定義，我們知道，當x>=0時，其絕對值不變，而x<0時其絕對值是為x的反號，因此程序段為：if(x<0) x=-x;
②if(條件)

else

這是典型的分支結構，如果條件成立，執行分支1，否則執行分支2，分支1和分支2都可以是1條或若干條語句構成。如：求ax^2+bx+c=0的根
分析：因為當b^2-4ac>=0時,方程有兩個實根，否則（b^2-4ac<0）有兩個共軛復根。其程序段如下：

d=b*b-4*a*c;
if(d>=0)
{x1=(-b+sqrt(d))/2a;
x1=(-b-sqrt(d))/2a;
printf(「x1=%8.4f,x2=%8.4f\n」,x1,x2);
}
else
{r=-b/(2*a);
i =sqrt(-d)/(2*a);
printf(「x1=%8.4f+%8.4fi\n」r, i);
printf(「x2=%8.4f-%8.4fi\n」r,i)
}
③嵌套分支語句：其語句格式為：
if(條件1) ；
else if（條件2）
else if（條件3）
……
else if（條件n）
else
嵌套分支語句雖可解決多個入口和出口的問題，但超過3重嵌套後，語句結構變得非常復雜，對於程序的閱讀和理解都極為不便，建議嵌套在3重以內，超過3重可以用下面的語句。
④switch開關語句：該語句也是多分支選擇語句，到底執行哪一塊，取決於開關設置，也就是表達式的值與常量表達式相匹配的那一路，它不同if…else 語句，它的所有分支都是並列的，程序執行時，由第一分支開始查找，如果相匹配，執行其後的塊，接著執行第2分支，第3分支……的塊，直到遇到break語句；如果不匹配，查找下一個分支是否匹配。這個語句在應用時要特別注意開關條件的合理設置以及break語句的合理應用。
（3）循環結構：
循環結構可以減少源程序重復書寫的工作量，用來描述重復執行某段演算法的問題，這是程序設計中最能發揮計算機特長的程序結構，C語言中提供四種循環，即goto循環、while循環、do –while循環和for循環。四種循環可以用來處理同一問題，一般情況下它們可以互相代替換，但一般不提倡用goto循環，因為強制改變程序的順序經常會給程序的運行帶來不可預料的錯誤，在學習中我們主要學習while、do…while、for三種循環。常用的三種循環結構學習的重點在於弄清它們相同與不同之處，以便在不同場合下使用，這就要清楚三種循環的格式和執行順序，將每種循環的流程圖理解透徹後就會明白如何替換使用，如把while循環的例題，用for語句重新編寫一個程序，這樣能更好地理解它們的作用。特別要注意在循環體內應包含趨於結束的語句（即循環變數值的改變），否則就可能成了一個死循環，這是初學者的一個常見錯誤。
在學完這三個循環後，應明確它們的異同點：用while和do…while循環時，循環變數的初始化的操作應在循環體之前，而for循環一般在語句1中進行的；while 循環和for循環都是先判斷表達式，後執行循環體，而do…while循環是先執行循環體後判斷表達式，也就是說do…while的循環體最少被執行一次，而while 循環和for就可能一次都不執行。另外還要注意的是這三種循環都可以用break語句跳出循環，用continue語句結束本次循環，而goto語句與if構成的循環，是不能用break和 continue語句進行控制的。
順序結構、分支結構和循環結構並不彼此孤立的，在循環中可以有分支、順序結構，分支中也可以有循環、順序結構，其實不管哪種結構，我們均可廣義的把它們看成一個語句。在實際編程過程中常將這三種結構相互結合以實現各種演算法，設計出相應程序，但是要編程的問題較大，編寫出的程序就往往很長、結構重復多，造成可讀性差，難以理解，解決這個問題的方法是將C程序設計成模塊化結構。
(4)模塊化程序結構
C語言的模塊化程序結構用函數來實現，即將復雜的C程序分為若干模塊，每個模塊都編寫成一個C函數，然後通過主函數調用函數及函數調用函數來實現一大型問題的C程序編寫，因此常說：C程序=主函數+子函數。因些，對函數的定義、調用、值的返回等中要尤其注重理解和應用，並通過上機調試加以鞏固。
三．掌握一些簡單的演算法
編程其實一大部分工作就是分析問題，找到解決問題的方法，再以相應的編程語言寫出代碼。這就要求掌握演算法，根據我們的《C程序設計》教學大綱中，只要求我們掌握一些簡單的演算法，在掌握這些基本演算法後，要完成對問題的分析就容易了。如兩個數的交換、三個數的比較、選擇法排序和冒泡法排序，這就要求我們要清楚這些演算法的內在含義，其中選擇法排序和冒泡法排序稍難，但只要明白排序的具體過程，對代碼的理解就不難了。如用選擇法對10個不同整數排序（從小到大），選擇法排序思路：設有10個元素a[1]~a[10],將a[1]與a[2]~a[10]比較，若a[1]比a[2]~a[10]都小，則不進行交換，即無任何操作；若a[2]~a[10] 中有一個比a[1]小，則將其中最大的一個（假設為a[i]）與a[1]交換，此時a[1]中存放了10個中最小的數。第二輪將a[2]與a[3]~a[10]比較，將剩下9個數中的最小者a[i]與a[2]交換，此時a[2] 中存放的10個數中第2小的數；依此類推，共進行9輪比較，a[1]到a[10]就已按從小到大的順序存放。即每一輪都找出剩下數中的最小一個，代碼如下：
for(i=1;i<=9;i++)
for(j=i+1;j<=10;j++)
if(a[i]>a[j]
{temp=a[i];
a[i]=a[j];
a[j]=temp;
}
結語：當我們把握好上述幾方面後，只要同學們能克服畏難、厭學、上課能專心聽講，做好練習與上機調試，其實C語言並不難學。
l8

㈡誰能給我一些C語言入門知識.詳細點..

1、 DIP40雙列直插；
2、 P0，P1，P2，P3四個8位準雙向I/O引腳；（作為I/O輸入時，要先輸出高電平）
3、電源VCC（PIN40）和地線GND（PIN20）；
4、高電平復位RESET（PIN9）；（10uF電容接VCC與RESET，即可實現上電復位）
5、內置振盪電路，外部只要接晶體至X1（PIN18）和X0（PIN19）；（頻率為主頻的12倍）
6、程序配置EA（PIN31）接高電平VCC；（運行單片機內部ROM中的程序）
7、 P3支持第二功能：RXD、TXD、INT0、INT1、T0、T1

單片機內部I/O部件：(所胃學習單片機，實際上就是編程式控制制以下I/O部件，完成指定任務)
1、四個8位通用I/O埠，對應引腳P0、P1、P2和P3；
2、兩個16位定時計數器；（TMOD，TCON，TL0，TH0，TL1，TH1）
3、一個串列通信介面；（SCON，SBUF）
4、一個中斷控制器；（IE，IP）

針對AT89S52單片機，頭文件AT89x52.h給出了SFR特殊功能寄存器所有埠的定義。

C語言編程基礎正式內容：

1、十六進製表示位元組0x5a：二進制為01011010B；0x6E為01101110。
2、如果將一個16位二進數賦給一個8位的位元組變數，則自動截斷為低8位，而丟掉高8位。
3、 ++var表示對變數var先增一；var—表示對變數後減一。
4、 x |= 0x0f;表示為 x = x | 0x0f;
5、 TMOD = ( TMOD & 0xf0 ) | 0x05;表示給變數TMOD的低四位賦值0x5，而不改變TMOD的高四位。
6、 While( 1 ); 表示無限執行該語句，即死循環。語句後的分號表示空循環體，也就是{;}

在某引腳輸出高電平的編程方法：（比如P1.3（PIN4）引腳）
#include <AT89x52.h> //該頭文檔中有單片機內部資源的符號化定義，其中包含P1.3
void main( void ) //void 表示沒有輸入參數，也沒有函數返值，這入單片機運行的復位入口
{
P1_3 = 1; //給P1_3賦值1，引腳P1.3就能輸出高電平VCC
While( 1 ); //死循環，相當 LOOP: goto LOOP;
}
注意：P0的每個引腳要輸出高電平時，必須外接上拉電阻（如4K7）至VCC電源。

在某引腳輸出低電平的編程方法：（比如P2.7引腳）
#include <AT89x52.h> //該頭文檔中有單片機內部資源的符號化定義，其中包含P2.7
void main( void ) //void 表示沒有輸入參數，也沒有函數返值，這入單片機運行的復位入口
{
P2_7 = 0; //給P2_7賦值0，引腳P2.7就能輸出低電平GND
While( 1 ); //死循環，相當 LOOP: goto LOOP;
}

在某引腳輸出方波編程方法：（比如P3.1引腳）
#include <AT89x52.h> //該頭文檔中有單片機內部資源的符號化定義，其中包含P3.1
void main( void ) //void 表示沒有輸入參數，也沒有函數返值，這入單片機運行的復位入口
{
While( 1 ) //非零表示真，如果為真則執行下面循環體的語句
{
P3_1 = 1; //給P3_1賦值1，引腳P3.1就能輸出高電平VCC
P3_1 = 0; //給P3_1賦值0，引腳P3.1就能輸出低電平GND
} //由於一直為真，所以不斷輸出高、低、高、低……，從而形成方波
}

將某引腳的輸入電平取反後，從另一個引腳輸出：（比如 P0.4 = NOT( P1.1) ）
#include <AT89x52.h> //該頭文檔中有單片機內部資源的符號化定義，其中包含P0.4和P1.1
void main( void ) //void 表示沒有輸入參數，也沒有函數返值，這入單片機運行的復位入口
{
P1_1 = 1; //初始化。P1.1作為輸入，必須輸出高電平
While( 1 ) //非零表示真，如果為真則執行下面循環體的語句
{
if( P1_1 == 1 ) //讀取P1.1，就是認為P1.1為輸入，如果P1.1輸入高電平VCC
{ P0_4 = 0; } //給P0_4賦值0，引腳P0.4就能輸出低電平GND
else //否則P1.1輸入為低電平GND
{ P0_4 = 1; } //給P0_4賦值1，引腳P0.4就能輸出高電平VCC
} //由於一直為真，所以不斷根據P1.1的輸入情況，改變P0.4的輸出電平
}

將某埠8個引腳輸入電平，低四位取反後，從另一個埠8個引腳輸出：（比如 P2 = NOT( P3 ) ）
#include <AT89x52.h> //該頭文檔中有單片機內部資源的符號化定義，其中包含P2和P3
void main( void ) //void 表示沒有輸入參數，也沒有函數返值，這入單片機運行的復位入口
{
P3 = 0xff; //初始化。P3作為輸入，必須輸出高電平，同時給P3口的8個引腳輸出高電平
While( 1 ) //非零表示真，如果為真則執行下面循環體的語句
{ //取反的方法是異或1，而不取反的方法則是異或0
P2 = P3^0x0f //讀取P3，就是認為P3為輸入，低四位異或者1，即取反，然後輸出
} //由於一直為真，所以不斷將P3取反輸出到P2
}
注意：一個位元組的8位D7、D6至D0，分別輸出到P3.7、P3.6至P3.0，比如P3=0x0f，則P3.7、P3.6、P3.5、P3.4四個引腳都輸出低電平，而P3.3、P3.2、P3.1、P3.0四個引腳都輸出高電平。同樣，輸入一個埠P2，即是將P2.7、P2.6至P2.0，讀入到一個位元組的8位D7、D6至D0。

第一節：單數碼管按鍵顯示

1、接電源：VCC（PIN40）、GND（PIN20）。加接退耦電容0.1uF
2、接晶體：X1（PIN18）、X2（PIN19）。注意標出晶體頻率（選用12MHz），還有輔助電容30pF
3、接復位：RES（PIN9）。接上電復位電路，以及手動復位電路，分析復位工作原理
4、接配置：EA（PIN31）。說明原因。

發光二極的控控制：單片機I/O輸出
將一發光二極體LED的正極（陽極）接P1.1，LED的負極（陰極）接地GND。只要P1.1輸出高電平VCC，LED就正向導通（導通時LED上的壓降大於1V），有電流流過LED，至發LED發亮。實際上由於P1.1高電平輸出電阻為10K，起到輸出限流的作用，所以流過LED的電流小於（5V-1V）/10K = 0.4mA。只要P1.1輸出低電平GND，實際小於0.3V，LED就不能導通，結果LED不亮。（注意和本電路相反）

開關雙鍵的輸入：輸入先輸出高
一個按鍵KEY_ON接在P1.6與GND之間，另一個按鍵KEY_OFF接P1.7與GND之間，按KEY_ON後LED亮，按KEY_OFF後LED滅。同時按下LED半亮，LED保持後松開鍵的狀態，即ON亮OFF滅。
#include <at89x52.h>
#define LED P1^1 //用符號LED代替P1_1
#define KEY_ON P1^6 //用符號KEY_ON代替P1_6
#define KEY_OFF P1^7 //用符號KEY_OFF代替P1_7
void main( void ) //單片機復位後的執行入口，void表示空，無輸入參數，無返回值
{
KEY_ON = 1; //作為輸入，首先輸出高，接下KEY_ON，P1.6則接地為0，否則輸入為1
KEY_OFF = 1; //作為輸入，首先輸出高，接下KEY_OFF，P1.7則接地為0，否則輸入為1
While( 1 ) //永遠為真，所以永遠循環執行如下括弧內所有語句
{
if( KEY_ON==0 ) LED=1; //是KEY_ON接下，所示P1.1輸出高，LED亮
if( KEY_OFF==0 ) LED=0; //是KEY_OFF接下，所示P1.1輸出低，LED滅
} //松開鍵後，都不給LED賦值，所以LED保持最後按鍵狀態。
//同時按下時，LED不斷亮滅，各佔一半時間，交替頻率很快，由於人眼慣性，看上去為半亮態
}

數碼管的接法和驅動原理
一支七段數碼管實際由8個發光二極體構成，其中7個組形構成數字8的七段筆畫，所以稱為七段數碼管，而餘下的1個發光二極體作為小數點。作為習慣，分別給8個發光二極體標上記號：a,b,c,d,e,f,g,h。對應8的頂上一畫，按順時針方向排，中間一畫為g，小數點為h。
我們通常又將各二極與一個位元組的8位對應，a(D0),b(D1),c(D2),d(D3),e(D4),f(D5),g(D6),h(D7)，相應8個發光二極體正好與單片機一個埠Pn的8個引腳連接，這樣單片機就可以通過引腳輸出高低電平控制8個發光二極的亮與滅，從而顯示各種數字和符號；對應位元組，引腳接法為：a(Pn.0)，b(Pn.1)，c(Pn.2)，d(Pn.3)，e(Pn.4)，f(Pn.5)，g(Pn.6)，h(Pn.7)。
如果將8個發光二極體的負極（陰極）內接在一起，作為數碼管的一個引腳，這種數碼管則被稱為共陰數碼管，共同的引腳則稱為共陰極，8個正極則為段極。否則，如果是將正極（陽極）內接在一起引出的，則稱為共陽數碼管，共同的引腳則稱為共陽極，8個負極則為段極。
以單支共陰數碼管為例，可將段極接到某埠Pn，共陰極接GND，則可編寫出對應十六進制碼的七段碼表位元組數據如右圖：

16鍵碼顯示的程序
我們在P1埠接一支共陰數碼管SLED，在P2、P3埠接16個按鍵，分別編號為KEY_0、KEY_1到KEY_F，操作時只能按一個鍵，按鍵後SLED顯示對應鍵編號。
#include <at89x52.h>
#define SLED P1
#define KEY_0 P2^0
#define KEY_1 P2^1
#define KEY_2 P2^2
#define KEY_3 P2^3
#define KEY_4 P2^4
#define KEY_5 P2^5
#define KEY_6 P2^6
#define KEY_7 P2^7
#define KEY_8 P3^0
#define KEY_9 P3^1
#define KEY_A P3^2
#define KEY_B P3^3
#define KEY_C P3^4
#define KEY_D P3^5
#define KEY_E P3^6
#define KEY_F P3^7
Code unsigned char Seg7Code[16]= //用十六進數作為數組下標，可直接取得對應的七段編碼位元組
// 0 1 2 3 4 5 6 7 8 9 A b C d E F
{0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71};
void main( void )
{
unsigned char i=0; //作為數組下標
P2 = 0xff; //P2作為輸入，初始化輸出高
P3 = 0xff; //P3作為輸入，初始化輸出高
While( 1 )
{
if( KEY_0 == 0 ) i=0; if( KEY_1 == 0 ) i=1;
if( KEY_2 == 0 ) i=2; if( KEY_3 == 0 ) i=3;
if( KEY_4 == 0 ) i=4; if( KEY_5 == 0 ) i=5;
if( KEY_6 == 0 ) i=6; if( KEY_7 == 0 ) i=7;
if( KEY_8 == 0 ) i=8; if( KEY_9 == 0 ) i=9;
if( KEY_A == 0 ) i=0xA; if( KEY_B == 0 ) i=0xB;
if( KEY_C == 0 ) i=0xC; if( KEY_D == 0 ) i=0xD;
if( KEY_E == 0 ) i=0xE; if( KEY_F == 0 ) i=0xF;
SLED = Seg7Code[ i ]; //開始時顯示0，根據i取應七段編碼
}
}

第二節：雙數碼管可調秒錶

解：只要滿足題目要求，方法越簡單越好。由於單片機I/O資源足夠，所以雙數碼管可接成靜態顯示方式，兩個共陰數碼管分別接在P1（秒十位）和P2（秒個位）口，它們的共陰極都接地，安排兩個按鍵接在P3.2（十位數調整）和P3.3（個位數調整）上，為了方便計時，選用12MHz的晶體。為了達到精確計時，選用定時器方式2，每計數250重載一次，即250us，定義一整數變數計數重載次數，這樣計數4000次即為一秒。定義兩個位元組變數S10和S1分別計算秒十位和秒個位。編得如下程序：
#include <at89x52.h>
Code unsigned char Seg7Code[16]= //用十六進數作為數組下標，可直接取得對應的七段編碼位元組
// 0 1 2 3 4 5 6 7 8 9 A b C d E F
{0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71};
void main( void )
{
unsigned int us250 = 0;
unsigned char s10 = 0;
unsigned char s1 = 0;
unsigned char key10 = 0; //記憶按鍵狀態，為1按下
unsigned char key1 = 0; //記憶按鍵狀態，為1按下
//初始化定時器 Timer0
TMOD = (TMOD & 0xF0) | 0x02;
TH1 = -250; //對於8位二進數來說，-250=6，也就是加250次1時為256，即為0
TR1 = 1;
while(1){ //----------循環1
P1 = Seg7Code[ s10 ]; //顯示秒十位
P2 = Seg7Code[ s1 ]; //顯示秒個位
while( 1 ){ //----------循環2
//計時處理
if( TF0 == 1 ){
TF0 = 0;
if( ++us250 >= 4000 ){
us250 = 0;
if( ++s1 >= 10 ){
s1 = 0;
if( ++s10 >= 6 ) s10 = 0;
}
break; //結束「循環2」，修改顯示
}
}
//按十位鍵處理
P3.2 = 1; //P3.2作為輸入，先要輸出高電平
if( key10 == 1 ){ //等松鍵
if( P3.2 == 1 ) key10=0;
}
else{ //未按鍵
if( P3.2 == 0 ){
key10 = 1;
if( ++s10 >= 6 ) s10 = 0;
break; //結束「循環2」，修改顯示
}
}
//按個位鍵處理
P3.3 = 1; //P3.3作為輸入，先要輸出高電平
if( key1 == 1 ) //等松鍵
{ if( P3.3 == 1 ) key1=0; }
else { //未按鍵
if( P3.3 == 0 ){ key1 = 1;
if( ++s1 >= 10 ) s1 = 0;
break; //結束「循環2」，修改顯示
}
}
} //循環2』end
}//循環1』end
}//main』end

第三節：十字路口交通燈

如果一個單位時間為1秒，這里設定的十字路口交通燈按如下方式四個步驟循環工作：
l 60個單位時間，南北紅，東西綠；
l 10個單位時間，南北紅，東西黃；
l 60個單位時間，南北綠，東西紅；
l 10個單位時間，南北黃，東西紅；
解：用P1埠的6個引腳控制交通燈，高電平燈亮，低電平燈滅。
#include <at89x52.h>
//sbit用來定義一個符號位地址，方便編程，提高可讀性，和可移植性
sbit SNRed =P1^0; //南北方向紅燈
sbit SNYellow =P1^1; //南北方向黃燈
sbit SNGreen =P1^2; //南北方向綠燈
sbit EWRed =P1^3; //東西方向紅燈
sbit EWYellow =P1^4; //東西方向黃燈
sbit EWGreen =P1^5; //東西方向綠燈
/* 用軟體產生延時一個單位時間 */
void Delay1Unit( void )
{
unsigned int i, j;
for( i=0; i<1000; i++ )
for( j<0; j<1000; j++ ); //通過實測，調整j循環次數,產生1ms延時
//還可以通過生成匯編程序來計算指令周期數，結合晶體頻率來調整j循環次數，接近1ms
}
/* 延時n個單位時間 */
void Delay( unsigned int n ){ for( ; n!=0; n-- ) Delay1Unit(); }
void main( void )
{
while( 1 )
{
SNRed=0; SNYellow=0; SNGreen=1; EWRed=1; EWYellow=0; EWGreen=0; Delay( 60 );
SNRed=0; SNYellow=1; SNGreen=0; EWRed=1; EWYellow=0; EWGreen=0; Delay( 10 );
SNRed=1; SNYellow=0; SNGreen=0; EWRed=0; EWYellow=0; EWGreen=1; Delay( 60 );
SNRed=1; SNYellow=0; SNGreen=0; EWRed=0; EWYellow=1; EWGreen=0; Delay( 10 );
}
}

㈢ c語言有哪些基礎知識

C語言是一門面向過程的、抽象化的通用程序設計語言，廣泛應用於底層開發。

C語言能以簡易的方式編譯、處理低級存儲器。C語言是僅產生少量的機器語言以及不需要任何運行環境支持便能運行的高效率程序設計語言。

盡管C語言提供了許多低級處理的功能，但仍然保持著跨平台的特性，以一個標准規格寫出的C語言程序可在包括類似嵌入式處理器以及超級計算機等作業平台的許多計算機平台上進行編譯。

(3)07第四講c語言基礎知識擴展閱讀：

C語言的字元串其實就是以''字元結尾的char型數組，使用字元型並不需要引用庫，但是使用字元串就需要C標准庫裡面的一些用於對字元串進行操作的函數。

它們不同於字元數組。使用這些函數需要引用頭文件<string.h>。

在C語言中，輸入和輸出是經由標准庫中的一組函數來實現的。在ANSI C中，這些函數被定義在頭文件<stdio.h>；中。

㈣ c語言入門教學

樓主，你可以去編程入門網，那裡有挺多知識點的，很多語言都有，很適合初學者，你也可以去CSDN，那裡有很多源代碼提供下載，也有論壇，呵呵，你也不要忽視網路貼吧，知道，貼吧是學習很多課本沒有東西的地方，知道，你需要看解決答案，這樣很有收獲，你也可以去中國編程網，不過，我覺得一樓也是有道理的，看看書掌握知識點，網上我覺得主要還是提高的地方哦……呵呵……關於怎麼學，我是這么過來的，每看一節書，做一節課後習題，其實初學主要還是學習語法和演算法（解決問題的方法），多上機自己寫程序，寫不出來看答案的演算法，自己再寫一邊，關鍵這個階段還是積累為主，基本知識學好了，可以學深入編程，不過你需要有熟悉的語法，可以寫一些小程序：學生成績管理系統等等，就過關了，然後可以學習鏈表，圖像編程，等等高級編程……呵呵……努力一定有回報的……加油吧…

㈤ C語言的基本知識。

C語言的基本知識；if-else 結構的應用：
編寫計算器程序，要求從鍵盤任意輸入兩個數值，然後輸入一個四則運算符，自動完成後輸出結果 2 switch 結構的應用：
從鍵盤輸入一個百分製成績，要求輸出成績等級'A''B'C''D''E'。90分以上為'A',80-89為'B',70-79為'C',60-69為'D',60分以下為'E'.
#include<stdio.h>
void main()
{float score; char grade; printf("請輸入學生成績：\n"); scanf("%f",&score); switch((int)(score/10)) {case 10: case 9: grade='A';break; case 8: grade='B';break; case 7: grade='C';break; ` case 6: grade='D';break; case 5: case 4: case 3: case 2: case 1: case 0: grade='E'; }
printf("成績是%5.1f,相應等級是%c。\n",score,grade);
}
3 do-while循環的應用:
利用下述公式求PI的近似值,要求滿足計算精度為0.0001
PI/4≈1-1/3+1/5-1/7+1/9-...
#include<stdio.h>
#include<math.h>
void main()
{int s; float n,t,pi; t=1;pi=0;n=1.0;s=1; do { pi=pi+t; n+=2; s=-s; t=s/n; }
while(fabs(1/n)>1e-4);
printf("pi=%10.6f",4*pi);
}
4 for循環的應用:
(1)求素數的累加和.從鍵盤任意輸入20個整數,將所有素數累加後輸出.
#include<stdio.h>
#include<math.h>
prime(int x[],int n)
{int i,j,k,s=0; for(i=0;i<n;i++) {k=sqrt(x[i]); for(j=2;j<=k;j++) if(x[i]%j==0) break; if(j>k) s+=x[i]; }
return s;
}
main()
{int a[20],*p,s=0,i; p=a; for(i=0;i<20;i++) scanf("%d",p++); p=a; s=prime(p,20); printf("%d",s); }
(2)無重復數字的3位數問題.用1.2.3.4 組成無重復數字的3位數,將這些3位數據全部輸出.
#include<stdio.h>
void main()
{
int i,j,k;
for(i=1;i<=2;i++)
{
for(j=i+1;j<=3;j++)
{
for(k=j+1;k<=4;k++)
{
printf("%d\n",100*i+10*j+k);
printf("%d\n",100*i+10*k+j);
printf("%d\n",100*j+10*i+k);
printf("%d\n",100*j+10*k+i);
printf("%d\n",100*k+10*i+j);
printf("%d\n",100*k+10*j+i);
}
}
}
}
5 字元型數組應用:
設計程序.輸入一篇不超過80個字元的短文(包括空格),保存到一維字元數組中,求字母a出現的次數並輸出.
#include<stdio.h>
#include<string.h>
void main()
{char s[80]; int i,n,times=0; gets(s); n=strlen(s); for(i=0;i<n;i++) if(s[i]=='a') times+=1; printf("\n The result is:%d\n",times); }
6 數值型數組應用:
設計程序將Fibonacci數列前20項中的奇數找出來存放到一維數組中.
#include<stdio.h>
void main()
{int i,s=0,j=0; int f[20]={1,1},a[20];
for(i=2;i<20;i++)
f[i]=f[i-2]+f[i-1];
for(i=0;i<20;i++)
{if(i%5==0) printf("\n"); printf("%12d",f[i]); }
printf("\n");
for(i=0;i<20;i++)
if(f[i]%2!=0)
{a[j]=f[i];j+=1;}
for(i=0;i<j;i++)
printf("%d ",a[i]);
}
7 函數調用(形參為變數的情況):
用函數調用的方式求 x!+y!+z!之值.
#include<stdio.h>
sum(int a)
{int n,t=1; for(n=1;n<=a;n++) t*=n; return t; }
main()
{int x,y,z,s=0; scanf("%d %d %d",&x,&y,&z); s=sum(x)+sum(y)+sum(z); printf("%d!+%d!+%d!=%d\n",x,y,z,s); 2008-6-19 20:22 回復 muniezuo 1位粉絲 2樓}
8 函數調用(形參為數組名的情況):
選擇法排序函數的定義及使用.編寫一個用選擇法對一維數組升序排列的函數,並在主函數中調用該排序函數,實現對任意20個整數的排序.
#include<stdio.h>
sort(int x[],int n)
{int i,j,k,t; for(i=0;i<n-1;i++) {k=i; for(j=i+1;j<n;j++) if(x[j]<x[k]) k=j; if(k!=i) {t=x[i];x[i]=x[k];x[k]=t;}
}
}
main()
{int *p,i,a[20]; p=a; for(i=0;i<20;i++) scanf("%d",p++); p=a; sort(p,20); for(p=a,i=0;i<20;i++) {printf("%d ",*p);p++;}
}
9 指針
(1)程序填空
下面程序中,函數fun的功能是:將s所指字元串中下標為偶數的字元刪除,s中剩餘的字元形成的新串放在t所指的數組中.例如,當s所指字元串中的內容為"ABCDEFGHIJK",在t 所指數組中的內容應是"BDFHJ"
#include<conio.h>
#include<stdio.h>
#include<string.h>
void fun(char *s,char t[])
{int i,j,n; n=strlen(s); for(i=0,j=0;i<n;i++) if(i!=2*j) {t[j]=s[i];j++;}
t[j]='\0';
}
void main()
{char s[80],t[80]; printf("\n Please enter string s: "); scanf("%s",s); fun(s,t); printf("\n The result is:%s\n",t); }
(2)程序改錯
下面程序中的sub函數的功能是:將s所指字元串的反序和正序進行連接形成一個新串放在t所指的數組中.
#include"stdio.h"
#include"conio.h"
#include"string.h"
void sub(char *s,char *t)
{int i,d; d=strlen(s); for(i=0;i<d;i++) t[i]=s[d-1-i]; for(i=0;i<d;i++) t[d+i]=s[i]; t[2*d]='\0'; }
main()
{char s[100],t[100]; printf("\n Please enter string s:"); scanf("%s",s); sub(s,t); printf("\n The result is : %s \n",t); }
10 結構體:有10個學生,4門課成績,設計程序,計算每個學生的總分和平均分,
並列印學生的成績排名表.
要求:定義結構體類型,成員有學號,姓名,4科成績
#include<stdio.h>
#define N 10 struct student
{
long num;
int score[4];
int add;
double aver;
}stu[N]; void main()
{
int i,j,sum;
char c[4][10]={"math","English","computer","physics"};
void paixu(struct student stu[]);
printf("請輸入學生的成績:\n");
for(i=0;i<N;i++)
{sum=0; printf("輸入第%d個學生的學號:",i+1); scanf("%ld",&stu[i].num); for(j=0;j<4;j++) {printf("輸入%s成績:",c[j]); scanf("%d",&stu[i].score[j]); sum+=stu[i].score[j];}
stu[i].add=sum;
stu[i].aver=stu[i].add/4.0;
}
for(i=0;i<N;i++)
a[i]=stu[i].add;
paixu(stu);
for(i=0;i<N;i++)
printf("%d\t%ld\t%d\t%d\t%d\t%d\t%d\t%6.2f\n",i+1,stu[i].num,stu[i].score[0],stu[i].score[1],stu[i].score[2],stu[i].score[3],stu[i].add,stu[i].aver);
}
void paixu(struct student stu[])
{
int i,j;
struct student t;
for(i=0;i<N-1;i++)
for(j=i+1;j<N;j++)
if(stu[j].add>stu[i].add)
{t=stu[j];stu[j]=stu[i];stu[i]=t;}
}
11 文件:建立一個數據文件,將10題中的成績排名表寫入數據文件中,完成後,關閉該數據文件;打開數據文件並將內容顯示在屏幕上,以便驗證
#include<stdio.h>
#define N 10 struct student
{
long num;
int score[4];
int add;
double aver;
}stu[N]; void save()
{FILE *fp; int i; if((fp=fopen("stu_list","wb"))==NULL) {printf("cannot open file\n"); return; }
for(i=0;i<N;i++)
if(fwrite(&stu[i],sizeof(struct student),1,fp)!=1)
printf("file write error\n");
fclose(fp);
} void main()
{FILE *fp; int i,j,sum; char c[4][10]={"math","English","computer","physics"};
void paixu(struct student stu[]);
printf("請輸入學生的成績:\n");
for(i=0;i<N;i++)
{sum=0; printf("輸入第%d個學生的學號:",i+1); scanf("%ld",&stu[i].num); for(j=0;j<4;j++) {printf("輸入%s成績:",c[j]); scanf("%d",&stu[i].score[j]); sum+=stu[i].score[j];}
stu[i].add=sum;
stu[i].aver=stu[i].add/4.0;
}
paixu(stu);
save();
fp=fopen("stu_list","rb");
for(i=0;i<N;i++)
{fread(&stu[i],sizeof(struct student),1,fp); printf("%d\t%ld\t%d\t%d\t%d\t%d\t%d\t%6.2f\n",i+1,stu[i].num,stu[i].score[0],stu[i].score[1],stu[i].score[2],stu[i].score[3],stu[i].add,stu[i].aver); }
fclose(fp);
} void paixu(struct student stu[])
{
int i,j;
struct student t;
for(i=0;i<N-1;i++)
for(j=i+1;j<N;j++)
if(stu[j].add>stu[i].add)
{t=stu[j];stu[j]=stu[i];stu[i]=t;}
}

㈥關於學習c語言的問題

他說的沒錯這本說的確很好我也在學習這半書
我這里有點筆記是高手們學習c語言留下的我想也許對你會有用
C程序入門
第一講語言的分類
一。低級語言：計算機語言,採用二進制進行編程，用戶難度大，機器易識別。
二。匯編語言：（低級語言）採用簡單的英文字母進行編程，用戶稍意識別，計算機不能使被識別，需翻譯。
匯編程序：將匯編語言譯成機器語言。
反匯編語言：將機器語言譯成匯編語言。
三。高級語言∶採用近於自然語言進行編程，用戶易編程，計算機不能識別，需翻譯，速度慢。
解釋程序：整句翻譯；
編譯程序：整個程序翻譯；
二，C語言的特點
1，C語言是一門中級語言
低級語言：直接訪問硬體
高級語言：自然語言移植性較好
2，C是一門結構化程序設計語言
有屬性，循環性，選擇性
3，C有豐富的數據類型和運算符
數據類型：數據在計算機內的表現形式
基本數據類型：整型實型字元型
int float char
控制符：
%d 整型
%f 實型
%c 字元型
4，C語言的結束符為分號大括弧為一個語句或函數范圍
5，C語言的構成
#include<文件名。h>
#define 宏名字元
main 主函數
①預處理（以#開頭) (不屬於C語言)
②書寫主函數（。C）
一個C語言程序是與主函數構成，主函數有且只有一個，main。
可以有或沒有子函數
執行程序
從子函數開始從左到右，從上倒下。
補充：
數制
一。含義
由一組數組成且按照一定的規則對數據進行管理的制度
二。分類
二進制八進十十六
組成：
二：0 1
八：0--7
十：0--9
十六：0--9和a--f
權：根據位置不同，所表示的數值不同。表示：基數的n次冪（n從0開始）
基數：組成該數制的數字個數。
123
1*100+2*10+3*1
三。轉換
1。十制數-->其它進制
規則：
整數：除以相應數制的基數然後除余倒排列。
小數：乘以相應數制的基數然後除整數正排列。
**當乘不盡時,保留前兩位.
(13.5）10=(1101.1)2
2.其它進制-->十制數
規則:按權展開,相加求和.
(1101.167)8=(13.)10
3.其它進制
二<--->八
採用421演算法
(001 011 011 010 101 110.001 101 011 100)2=(133256.1534)8
規則:從小數點開始向兩側每三個二進制位為一組,不足3位的,整數部分在前面補齊,小數部分在後面補齊,然後,對每一組按權展開相加求和.
八-->二
採用421反演算法
將一個八進制位拆分3個二進制位.
(75462.5041)8=(111101100110010.101000100001)2
二-->十六
採用8421演算法
規則:從小數點開始向兩側每四個二進制位為一組,不足4位的,整數部分在前面補齊,小數部分在後面補齊,然後,對每一組按權展開相加求和.
(1001 1110 1110 1100 1010.1101 1001 0100)2=(9eca)16
十六-->二
採用8421反演算法
將一個十六進制位拆分4個二進制位.
(10afd)16=(10000101011111101)2
八<--->十六
藉助二,十進制
第二講數據類型常量變數

一.數據類型:
數據在計算機內的表現形式
整型
基本數據單精度
實型(浮點型)
雙精度
字元型

結構體
構造類型共用體
數組

指針型,空類型.
二.常量
<一>.含義,在程序招待過程中,其值不變的量.
<二>.使用形式
1.字面量.
s=2*P*r;
2.宏符號
#define X 3.141592627
int x;
<三>分類
整型常量實型常量字元型常量字元串常量
A:整型常量
1.表示形式
八進制十進制十六進制(二進制不能表示整型常量)
2.書寫格式
十進制:由0--9組成,不能以0開頭.5 6
八進制:由0--7組成,必須以0開頭.eg:05 07
十六進制:由0--9和a--f組成,必須以0x開頭. 0x5 0xa 0xa01
3.分類,范圍,空間,控制符
十進制:
-5 1111111111111111
5 0000000000000101

123
0 1 999
有符號 (signed) int x; %d -32768----32767
短整型(2B)
無符號 unsigned int x; %u 0----65535
有符號 (signed) long (int) x; %ld -2147483648----2147483647
長整型(4B)
無符號 unsigned long (int) x; %lu 0-----429......

八進制(無符號)
符合整數的定義規則 .
短無(2B): %o 0---0177777
長無(4B):%lo 0---037777777777
十進制(無符號)
符合整數的定義規則 .
短無(2B): %x 0---0xffff
長無(4B):%lx 0---0xffffffff
B:實型常量
1。表示形式
十進制指數形式
2.十進制
由0--9組成,必須有小數點,小數點前面或後面有數據.
單精度:float %f 10(-38)----10(38) 4B
雙精度:double %lf 10(-308)---10(308) 8B
3.指數形式
階碼標志:E(e)代表10
double x=1.23457e+3;
必須有階碼標志E(e),階碼標志前和後必須有數據,且前面是整數或實數,指數部分:必須是整數.
%e 與%f一致小數點後保留6位,且E也算一位
C:字元型常量
1.書寫格式
由一對單引號括起的任意一個字元.
2.分類
ASCII碼字元(共256個)
'a'---'z'[97--122] 'A'--'Z'[65--90] '0'---'9' [48--57]
ASCII碼值:每個字元對應的十進制整數.(無符號) 0---255
main(){ char c; scanf("%c",&c); printf("%c",c-32);}
if(c>=97&&c<=122)
printf("%c is xiaoxie",c);
else if(c>='A'&&c<='Z')
printf("%c is da xie",c);
else if(c>='0'&&c<=57)
printf("%c is shuzi",c);
else
printf("%c is qita",c);
轉義字元
書寫格式:以\開頭,用一對單引號括起一個或多個字元,但是表示是一個字元.
分類:
'\+字母':作用:主要控制游標.
'\n':游標回車換行.
'\t':游標跳到下一個製表位
'\r':游標回到行首
'\b':游標左退一列
printf("******\n*******");
'\+標點':作用:控制輸出一個標點符號
'\'':輸出一個單引號
'\"':輸出一個雙引號
'\\':輸出一個反斜杠
'\+數字': 作用:表示一個ASCII碼字元.
'\0ddd':八進制轉義字元:最多三位八進制數*****0可以省略.
'\xdd':十六進制轉義字元:最多二位十六進制數
'\0123' '\123'
'\xa1'
printf("%c",'\61');
3.范圍(1B)
有符號:-128----127
無符號:0--255
char c=-5;
printf("%c",c);

D：字元串常量
書寫格式：由一對雙引號括起任意零個1個或多個字元。
字元串的長度：組成該字元串的字元個數。
字元串結束標志：'\0'
空間:串長度+1個空間.
控制:%s
char x[100];
scanf("%s",x);
printf("%s",x);
printf("%s","kdfjlkdsjfsdls");
printf("%s","zheng");
"":空串.
三.變數
1.其值在執行程序中可以改變的量.
2.定義格式
存儲類型數據類型變數名1,變數名2,......變數名n;
int x,y,z;
存儲類型:變數開辟空間的類型.
auto:(默認)自動型該變數的默認值為隨機值.
static:靜態型該變數的默認值為0值.
regiester:寄存器型該變數的默認值為隨機值.
extern:外部參照型該變數的默認值為0值. (我們使用省略extern型)
static int x;
printf("%d",x);
aaa.prg
a1.c int x;
a2.c extern int x;
a3.c
int x;
main()
{
int x;
}
變數名:
a:多個變數之間用,隔開;
b:相同類型的變數可以寫在同一個語句中;
int a,b,c;
c:變數命名
必須符合合法的用戶標識符
標識符:用來表明或表示變數或函數的名字或類型的符號.
關鍵字:用來標識類型的標識符.(32個關鍵)
存儲類型,數據類型,流程類 ,運算符類(sizeof)
標識符:由字母,數字,下劃線組成,不能以數字開頭,不能與關鍵字重名.
int if;
_a1;
1a
a 1;
main()
{
int x,X;
float x;
****不能與同一范圍內的變數名重名.*****
3.給變數賦值.
通過兩種:
賦值表達式: =
輸入函數:scanf()
x=3;
scanf("%d",&x);
a:賦值表達式
格式: 變數名=表達式;
左邊必須是變數名,右邊賦值給左邊,並將左邊變數的值覆蓋.當一個變數進行多次賦值時,該變數只能保留最一次所賦的值.
main()
{
int x;
x=2;
x=5;
scanf("%d",&x);
printf("%d",x);
getch();
}
int x,y,z;
x=2;
y=3;

z=x;
x=y;
y=z;

x=3;
y=2;
b:scanf()
格式:scanf("控制符",地址項)
scanf("%d%f%c",&x,&y,&z);
3. 數據類型之間轉換(兩個自動,一個強制)
a:在賦值時,右邊數據的類型自動轉換成左邊變數的類型.
int x;
x=1.23;
float x;
x=10;
char c=65;
int x='a';
int x=32768;
printf("%d,%u",x,x);
b:運算時,數據類型低的轉換成數據類型高的(占空間的位元組數)
int x;
float y;
printf("%f ",x+y);
c:強制轉換
格式:(數據類型)表達式
數據類型:將要轉換成的類型
表達式:要轉換的對象.
(float)x+y
(float)(x+y)
x+(float)y
float x=12.345,y;
y=x-(int)x;
printf("%f",x);
(int)x%2==0
第三講運算符及表達式
目:根據運算對象對運算符分為:單目,雙目,三目.
表達式:簡單和復雜表達式
簡單:無運算連接的式子. 3 x (1)
復雜:有運算連接的式子. x+y x=3 x<y
一.算術運算符 +(正)-(負)+ - / * %
規則:
/ :當運算對象都為整數時,結果取整的.若其中一個為實型,結果為實型. 1/2.
%(取余/模):要求:運算對象必須為整型.
int x,y;
x%y
x=123
x%10;
x/10%10
x/100
表達式
式子的類型:與運算對象中占空間最大的一致.
優先順序:正,負-->*/%-->+,-
結合性:單目:從右向左;雙目:從左向右.
- - -5
x%2/y*z
二.賦值運算符 = += -= /= *= %=(自反賦值)
規則: s=5
自反賦值:左邊和右邊先按指定的運算符進行運算,然後再賦值給自己.*****左邊必須先有值.
x=2;
x+=5
x=x+5;
表達式:
表達式的值與左邊變數的值一致.
printf("%d",x=5);
結合性:從右向左
int x=3;
x+=x-=1;
三.關系運算符 < > <= >= == !=
規則:.
表達式的值:邏輯值,當判斷成立時,得到邏輯值真值(用1表示),不成立時,得到邏輯值假值(用0表示)****因為C語言中沒有邏輯型數據****
類型:整型.
int x,y;
x=3;
y=4;
printf("%d ",x<y);
c<='z'&&c>='a' 'z'>=x>='a'
優先順序:< > <= >= -->== !=
結合性:從左向右
x>y>z x>y && x>z
四.邏輯運算符 &&(邏輯與) 雙目 ||(邏輯或) 雙目 !(邏輯非）單目
規則:
格式:表達式1&&/||表達式2
&&:表達式1和表達式2必須都為真值(非零值),整個邏輯與表達式才成立.產生邏輯值真值(用1表示)
如果表達式1或表達式2其中一個是假值(0值),整個邏輯與表達式不成立.產生邏輯值假值(用0表示)
x= x=5&&6<9;
||:表達式1或表達式2成立,則整個式子成立,產生真值(用1表示).若兩個式子都為假值,整個邏輯或表達式為假(用0表示)
x>='a'||x<='z'
!:格式: !表達式
當表達式為真(非零值)值,邏輯非表達式為假(用0表示)
當表達式為假(零值)值,邏輯非表達式為真(用1表示)
x=!(4>5)
優先順序:!-->&&-->||
x>='a'&&x<='z' || x>='A'&&x<='Z'
*********
&&:如果表達式1為假了,系統不對表達式2進行計算了
||:如果表達式1為真了,系統不對表達式2進行計算了
int x,y;
x=3;
y=4;
x= x<y&&!5;
x,y?
x=x>y||x=9
x,y?
對&&和||而言:不是按優先順序計算,而是先計算表達式1,再計算表達式2.
結合性:單目:從右向左
雙目:從左向右
! ! ! ! !5
表達式的值:邏輯值
類型:整型.
int x,y;
scanf("%
if(x>y)
五。自增/減運算符 ++ -- 單目
規則：
表達式++ 表達式-- 後綴表達式
++表達式 --表達式前綴表達式
main()
{
int x;
x=2;
printf("%d",x++);
x=2;
printf("%d",++x);
}
變數的值：會自動的增/減1；
表達式的值：
後綴表達式：與變數改變之前值一致。
前綴表達式：會與變數的值一致增/減1；
表達式：
x++ x=x+1 x+=1
六。條件運算符( ? : )三目
規則：
表達式1？表達式2：表達式3
x>y?printf("%d",x):pritnf("%d",y);
int x,y;
w=x>y?x:y;
printf("%d",w);
int x,y;
if(x>y)
printf("%d",x);
else
printf("%d",y);
先計算表達式1，若產生非零值，則執行表達式2，並將表達式2的值作為整個條件表達式的值，若產生
零值，則執行表達式3，並將表達式3的值作為整個條件表達式的值(若執行表達式2，不執行表達式3）
int x,y,w;
x=5;
y=4;
w=x>y?x++:y++;
printf("%d,%d,%d",w,x,y);
if(x>y)
x++;
else
y++;
x,y?
優先順序:
單目(++,--,-+!)-->算術雙目-->關系-->邏輯運算-->條件-->賦值->逗號.
結合性:從右向左分出正確的表達式,從左向右計算.

?: ? ?: : ? :
w=x>y? x>z?x: z : y>z?y: z
3個
w,x,y,z
if(x>y)
if(x>z)
w=x;
else
w=z;
else
if(y>z)
w=y;
else
w=z;
七.逗號 , 雙目
作用:分隔,運算符
格式:表達式1,表達式2
規則:從左向右算,取最後一個表達式的值為整個逗號表達式的值.
int x=5,y;
y=x++,--x,x,x+1,x;
x,x+1,x,(y=x++,++x);
y=(x++,--x,x,x+1,x);
printf("%d",(x,y));
第四講流程式控制制語句
順序循環選擇
一.選擇語句
if..else 和 switch
作用:根據條件執行程序的某一部分.
A:if...else
1.格式
if(條件表達式)
{
語句組1;
}
else
{
語句組2;
}
注意:
a:if,else為關鍵字必須為小寫.
b:條件表達式:一般寫關系或邏輯表達式.
c:else可選項,{}當執行語句只有一句時,可以省略.
2.執行過程
首先計算條件表達式的值,若為非零值,則執行if分支,否則,若有else分支,則執行else,沒有時,執行下面的其它語句.
3.嵌套
在if或else分支中又出現if..else語句.
a:在else中出現if..else
if( )
.....
else if( )
.....
else if( )
.....
else
......
b:在if分支中出現if...else
if1( )
if2( )
if3( )
if4( )
.....
else4
.....
else3
.....
else2
......
else1
........
c:在if和else中出現if...else
if( )
if( )
....
else
....
else
if( )
....
else
....
if(x%4==0&&x%100!=0||x%400==0)
if(x%4==0)
if(x%100==0)
if(x%400==0)
printf("run");
else
printf("ping");
else
run;
else
ping

if(x>y)
if(x>z)
w=x;
else
w=z;
else
if(y>z)
w=y;
else
w=z;
B:多開關語句switch
格式
switch(表達式)
{
case 常量表達式1:語句組1;[break;]
case 常量表達式2:語句組2;[break;]
case 常量表達式3:語句組3;[break;]
................n:.....n;[break;]
default :語句組n+1;
}
注意:
a:表達式的類型必須與常量表達式的類型一致.整型或字元型.
b: break;是可選項, 當遇到break表示該語句執行完畢.
c:default是可選項.{}不可省略.
d:同一個switch語句中,常量表達式的值不能重復.
int x,y;
char w;
scanf("%d%d%c",&x,&y,&w);
switch(w)
{
case '+':printf("%d",x+y);break;
case '*':printf("%d",x*y);break;
case '/':printf("%d",x/y);break;
case '-':printf("%d",x-y);break;
default:printf("wu ci yun suan fu");
}
2.執行過程
......
3.嵌套.
char c;
scanf("%c",&c);
switch(c>='a'&&c<='z')
{
case 0:switch(c>='A'&&c<='Z')
{
case 0:switch(c>='0'&&c<='9')
{
case 0:printf("qita");break;
case 1:pritnf("shuzi");break;
}break;
case 1:printf("daxie");break;
}break;
case 1:printf("xiaoxie");break;
}
二.循環語句
for while do...while
作用:根據條件重復執行程序的某一部分.
A:for語句
1.格式
for(表達式1;表達式2;表達式3)
{
循環體語句;
}
for(x=1;x<=10000;x++)
{
printf("%d",x);
}
注意:
a:表達式1:給循環變數賦初值
b:表達式2:決定是否應該進入循環的條件,一般為關系或邏輯表達式.
c:表達式3:給變數重新賦值.
d:{}可以省略.3個表達式均可省略.同時省略 for(;;)無限循環.
2.執行過程
首先執行表達式1給變數賦初值,然後再判斷表達式2是否成立.若成立則進入循環體,當執行到}表示一次循環體執行完畢.再執行表達式3給變數賦新值,然後再判斷表達式2是否成立.若成
立,再進入循環體,否則,表示該語句執行完畢.
1.求1---100和
2.接收10個實數,對小數部分求和.

B:while語句
a.格式
while(表達式)
{
循環體;
}
注意:{}當循環體只有一句時,可以省略.表達式與表達式2一樣,但不能省略.while(1)===for(;;)無限循環.
for(i=1;i<=100;i++)
printf("%d",i);

int i;
i=1;
while(i<=100)
{
printf("%d",i++);
}
補充:
輸入/出單個字元的函數.**必須預處理<stdio.h>
getchar()和putchar()
格式
變數名=getchar();
putchar(變數名/常量);
main()
{
char x;
scanf("%c",&x);
printf("%c",x);
x=getchar();
putchar(x);
}
C.do ...while
a:格式
do
{
循環體;
}while(表達式);
注意:
;{}均不可省略.先執行一次循環體,再判斷表達式是否成立.
至少執行一次.

main()
{
int i;
i=1;
do
{
printf("%d",i);
}while(++i<=100);
D:嵌套
for(i=1;i<=3;i++)
for(j=1;j<=3;j++)
for(k=0;k<=59;k++)
{
printf("%d:%d:%d",i,j,k);
delay(1);
}
****
***
**
*
for(i=1;i<=4;i++)
{
for(j=1;j<=5-i;j++)
printf("*");
putchar('/n');
}

1!+2!+3!+4!+....n!
階乘。
三.轉移
break;
作用：只能用在循環體或switch語句中。
用在循環體中，為了終止其所在的循環體。
while(c!='*')
c=getchar();
if(c=='*')
break;
continue;
只能用在循環體中，提前結束本次循環體語句，而進入下一次循環體。

for(i=1;i<=100;i++)
{
if(i%2)
continue;
printf("%d",i);
}
***********************************************
數組前的筆記
+qq619740933，能幫你講得盡量幫你講明白

㈦ C語言入門知識

char a[20],b[20],c[20];上面的a,b,c都是數組變數,在定義時已經為其分配棧內存,而char (*str1)[20],(*str2)[20],(*str3)[20]; 只是分配了4個位元組的內存來保存指針變數(即變數本身),而指針的值(即指向)還沒有,所以這些指針還不能保存數據!--------------char (*str1)[20],(*str2)[20],(*str3)[20]; str1 str2 str3均為指針,都指向長度為20的char數組.你只定義了指針,但是沒有對其進

㈧ C語言考試教程◆全國計算機等級考試二級C語言視頻教程（完整版) 下載

計算機等級考試二級C語言

首先我們先看下軟體展示圖，最後是軟體！

圖：

3、未來教育2017二級msoffice模擬軟體

以其模式的高專業度，題庫權威度而聞名業界，它聚合歷年真題加以分析從而提出權威預測，效果非常不錯。

2、捷成全國計算機等級考試練習系統。

上機考試系統提供了歷屆考試題100套，並附有試題分析和參考答案，可以幫助考生熟悉考試模式，提高應試能力，測試實際操作和應變能力，自己評定成績，對正式考試時能否通過進行初步的估計。

1、全國計算機等級考試超級模擬軟體。

匯聚了多年開發全國計算機等級考試模擬軟體的豐富經驗，並綜合有經驗的命題專家、教授和全國各地考點一線教師的建議基礎上研製而成。本套軟體採用模擬考試形式，以大量的習題練習，強化考生的應考能力。

㈨ c語言的基本課程是什麼

全書共12章，第1章計算機程序設計的含義，第2章C語言程序的基本結構，第3章C語言的基本數據類型與簡單I/0，第4章C語言的語句特徵，第5章函數，第6章變數的存儲屬性，第7章編譯預處理與工程，第8章C語言的數組及其應用，第9章指針變數及其屬性，第10章結構體、共用體數據及其應用，第11章C語言的文件I，0及其應用，第12章C語言的位運算與低級操作。
替你了，懶。

㈩ C語言知識總結

c語言概要
第一章、概述
1、 c語言的基本知識
1.1、 c語言的執行步驟
編輯-程序代碼的錄入，生成源程序*.c
編譯-語法分析查錯，翻譯生成目標程序*.obj
（語法或邏輯錯誤，從第一個開始改，變數定義，語句格式，表達式格式等）
鏈接-與其他目標程序或庫鏈接裝配，生成可執行程序*.exe
執行
1.2、 main函數的基本知識
main（）函數的位置
c程序總是從main( )函數開始執行
一個c程序可以包含一個主函數，即main（）函數；也可以包含一個main()函數和若干其它函數
1.3、 c程序的結構
函數與主函數
程序由一個或多個函數組成
必須有一個且只能有一個主函數main()
程序執行從main開始，在main中結束，其他函數通過嵌套調用得以執行
程序語句
C程序由語句組成
用「；」作為語句終止符
注釋
//
或
/* */ 為注釋，不能嵌套
不產生編譯代碼
1.4、c 程序書寫的規則
習慣用小寫字母，大小寫敏感
不使用行號，無程序行概念：通常一個語句佔一行
可使用空行和空格
常用鋸齒形的書寫格式；同一層次結構的語句上下對齊。
第二章、基本數據類型與運算
2.1、c程序的數據類型
注意類型和變數含義的不同（類型是固定好的名字，變數是自己起的名字）
變數佔用的存儲空間
數據類型
基本類型：整型、字元型、浮點型（單精度型，雙精度型）
構造類型：數組類型、結構體類型
指針類型
空類型
注意基本類型賦初值的方式
基本數據類型的表示形式
整形數據
十進制：以非0數字開頭，如：123，-9，0
八進制;以0數字開頭，如：0123，067
十六進制：以0x開頭，如：0x123,0xff
實型數據
十進制：必須帶小數點，如：123.0，-9.0
指數形式;如：1.23E3，0.9e-2,5e2
字元型數據
普通字元：如：』a』,』2』,』H』,』#』
轉義字元：如：』\n』,』\167』,』\xlf,』\\』
（實現幾列的對齊：指定寬度。如%100\ 『\t』製表位）
（字元串長度。「abc\n\t\\」 strlen 6; sizeof 7）
基本數據類型的存儲長度
整型
Int 位元組數 2 位數 16 數的表示範圍 -32768—32767
Short 2 16 -32768—32767
Long 4 32 -2147483648—2147483647
實型
Float 4 32 3.4e-38---3.4e38
Double 8 64 1.7e-308---1.7e308
字元型
Char 1 8 -128----127
2.2、標識符命名規則
C語言標志符命名規則
標識符有數字，字母，下劃線組成
標識符的首字元必須為字母和下劃線
標識符不能為c語言的保留字（關鍵字）
如：auto extern sizeof float static case for struct char goto switch continue in typedef const if union default long unsigned do register void double return else short while enum signed
算術運算符 + - * / %
關系運算符 > < == >= <= !=
邏輯運算符！ && ||
位運算符 << >> ~ | ^ &
賦值運算符 = 及其擴展賦值運算符
條件運算符 ? :
逗號運算符，
指針運算符 * &
求位元組數運算符 sizeof
強制類型轉換運算符（類型）
分量運算符 . ->
下標運算符 [ ]
其他如函數調用運算符()
運算符的優先順序
由高到低：單目運算符，算數運算符，關系運算符，賦值運算符
說明：單目運算符：自增運算符，自減運算符，類型裝換運算符。結合方向：自右至左
如：++--I 先—i.。
算術運算結合方向自左至右
2.3基本運算和表達式
關系表達式和邏輯表達式
(a>b)&&(x>y) (a==b)||(x==y) !=a||(a>b)
A&&b.a為0.不執行b
A||b a為1.不執行b
在 c 中邏輯運算結果：1代表「真」，0代表「假」；
判斷一個表達式是否真：0代表「假」，非0代表「真」
條件表達式逗號表達式
如：k=5,k++
逗號值為5；k為6.
表達式1？表達式2 ：表達式3
K=5>6 ? 1 : 0
2.4、混合運算的數據類型轉換
2/3+0.5 雙精度浮點型
第三章、順序結構程序設計
3.1、c語句的分類
簡單語句
表達式語句表達式+分號
空語句只有分號的語句
復合語句用花括弧將若干語句括起來
流程式控制制語句
選擇語句 if ,switch
循環語句 while, do while , for
轉移語句 break ,continue ,return goto
3.2、格式輸入函數scanf
一般形式：scanf(「格式控制字元串「，地址列表)；
使用scanf函數時，需要注意：
格式字元的個數必須與輸入項的個數相同，數據類型必須一一對應，非格式字元串（說明性的）要原封不動的輸入。
輸入實行數據時，可以不帶小數點，即按整型數據輸入
數值型數據與字元或字元串混合輸入時，需要注意輸入方式。
3.3、格式輸出函數printf
Printf（「格式控制字元串「，輸出列表）；
指定輸出格式，由格式字元串和非格式字元串兩種組成，非格式字元串照原樣輸出。
%[標志][輸出最小寬度][.精度][長度]類型
標志：- 左對齊；+ 右對齊；
%f, %d, %c, %s
3.4、其他輸入輸出函數
Putchar getchar puts gets
第四章、選擇結構程序設計
If選擇結構
單分支
If(表達式)
語句
雙分支
If(表達式)
語句1
Else
語句2
多分支
If （表達式1）
語句1
Else if（表達式2）
語句2
。。。
Else if(表達式m)
語句m
Else
語句n
Switch（表達式）
{
Case 常量表達式1：語句1；break；
Case 常量表達式2：語句2；break；
。。。
Case 常量表達式m：語句m；break;
Default:語句n；break;
}
注意break的使用
第五章、循環結構程序設計
循環三要素
初始條件；終止條件；在初始條件和終止條件間反復做某件事情（循環體）
While(表達式)
語句

Do
語句
While(表達式);

For(循環體變數賦初值；循環條件；循環變數增量)
( for( ) ; // ; 進行時間延遲。在信息交換等時用。如for(i=0,i<100) ; 互相通訊的時間延遲。 Delay )
Break語句：不能用於循環語句和switch語句之外的任何其他語句；跳出循環。
Continue語句：跳過循環體中剩餘的語句而強行執行下一次循環；跳出本次循環。
第六章、函數與編譯預處理
6.1、函數的定義和調用
類型標識符函數名（形式參數列表）
{ 聲明部分
語句
}
例：
Int max (int x,int y)
{int z; Z=x>y?x:y; Return(z);}
6.2、局部變數和全局變數
注意函數中靜態變數的定義和使用
6.3、變數的存儲類型
局部變數的存儲類型
自動變數(auto) 動態存儲
局部靜態變數（static）靜態存儲
寄存器變數(register) 靜態存儲
全局變數的存儲類型
自動變數（auto）動態存儲
外部變數（extern）靜態存儲
全局靜態變數（static ）靜態存儲
Extern 外部引用
Static 不能用extern 引用。
第七章、數組
7.1、一維數組的定義和使用
特別需要注意循環體的初值，終止條件
例：
Main()
{
Int I,a[10];
For(i=0;i<=9;i++)
A=I;
For(i=9;i>=0;i--)
Printf(「%d」,a);
}
注意下標問題
7.2、二維數組的定義和使用
二維數組的初始化
例如：
Int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
Int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
Int a[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12};
Int a[ ][4]={{1,2,3,4},{5},{9,10,11,12}};
例如：int a[3][3]={{1},{2},{3}};
是對每一行的第一列元素賦值，未賦值的元素取0
7.3、字元數組和字元串
字元串用字元數組來處理，結束標志符『\0』
如：char c[ ]={「I am happy」};
用字元串常量使字元數組初值化
Char c[ ]={『I』,』『,』a』,』m』,』『,』h』,』a』,』p』,』p』,』y』,』\0』};
第八章、指針
8.1、地址和指針的概念
Int I;
Int *i_point;
8.2、指針變數和變數的地址
操作符：* &
8.3、指針和一維數組
若有定義
Int a[10];
Int *p=a;
分析下面表達式的含義：
A, &a,
*(a+i), a+I,
*(p+i), p+i
A=*(a+i)=*(P+i)
&a=a+i=p+i
8.4、指針與字元串
Main()
{
Char string[ ]=」I love china!」;
Printf(「%s\n」,string);
}
Main()
{ char *string=」I love china!」;
Printf(「%s\n」,string);
}
8.5、指針變數作為函數參數
形參的定義方式；實參的形式；參數的傳遞方式。
第九章、結構體
9.1、結構體類型和變數的定義
Struct 結構體名
{成員列表}；
Struct student
{char stuNO[8]; Char name[20]; Char sex; Int age; Float score; Char addr[30]; };

Stuct student
{char stuNO[8]; Char name[20]; Char sex; Int age; Float score; Char addr[30]; };
Struct student stu1, stu2;
9.2、結構體變數的引用
一般形式為：
結構體變數名.成員名
9.3、結構體數組
結構體數組結構體數組元素.成員名
指向結構體的指針變數
（*p）.成員名
p->成員名
其他
Strcpy(字元數組1，字元串2)
Strcat(字元數組1，字元數組2)
Strcmp(字元串1，字元串2)
Strlen（字元數組）

07第四講c語言基礎知識

(3)07第四講c語言基礎知識擴展閱讀：

與07第四講c語言基礎知識相關的內容