C知識點總結歸納目錄

• 第一章 程序設計和C語言
• • 一、C的入門小概念
  • 二、程序設計的問題
  • 三、首先要搞清楚編譯器、編輯器和IDE的區別
• 第二章 算法——程序的靈魂
• • 一、程序=算法+數據結構
  • 二、算法的特性
  • 三、怎樣表示一個算法
  • 四、結構化程序的設計方法
• 第三章 C程序設計——順序程序設計
• • 一、常量和變量
  • • 1、常量
    • 2、變量
    • 3、常變量
    • 4、標識符
    • 5、數據類型
  • 二、運算符和表達式
  • 三、C語句
  • • 1、關于#include的用法
    • 2、關于#define的用法
    • 3、關于%的使用方法
  • 四、數據的輸入輸出
  • • 1、相關概念
    • 2、用printf函數輸出數據
    • 3、字符輸入輸出函數
• 第四章 選擇結構程序設計
• • 一、選擇結構和條件判斷（略）
  • 二、用if語句實現選擇結構（略）
  • 三、關系運算符和關系表達式
  • 四、邏輯運算符和邏輯表達式（略）
  • 五、條件運算符和條件表達式（略）
  • • 優先級一覽表
  • 六、選擇結構的嵌套（略）
  • 七、用switch語句實現多分支選擇結構（略）
• 第五章 循環結構設計
• • 一、關于循環結構中break、continue、return和exit的區別
  • 二、第五章課后習題答案
• 第六章 利用數組處理批量數據
• • 一、怎樣定義和引用一維數組
  • • 1、 怎樣定義一維數組
    • 2、怎樣引用一維數組元素
    • 3、一維數組的初始化
  • 二、怎樣定義和引用二維數組
  • • 1、怎樣定義二維數組
    • 2、怎樣引用二維數組的元素
    • 3、二維數組的初始化
  • 三、字符數組
  • • 1、怎樣定義字符數組
    • 2、字符數組的初始化
    • 3、怎樣引用字符數組中的元素
    • 4、字符串和字符串結束標志
    • 5、字符數組的輸入輸出
    • 6、使用字符串處理函數
  • 四、第六章課后習題答案
• 第七章 用函數實現模塊化程序設計
• • 一、為什么要用函數
  • 二、怎樣定義函數
  • • 1、為什么要定義函數
    • 2、定義函數的方法
  • 三、調用函數
  • • 1、函數的調用形式
    • 2、函數調用時的數據傳遞
    • 3、函數調用的過程
    • 4、函數的返回值
  • 四、對被調用函數的聲明和函數原型
  • 五、函數的嵌套調用（略）
  • 六、函數的遞歸調用（略）
  • 七、數組作為函數參數
  • • 1、數組元素做函數實參
    • 2、一維數組名作函數傳遞
    • 3、多維數組名作函數參數
  • 八、局部變量和全局變量
  • • 1、局部變量
    • 2、全局變量
  • 九、變量的存儲方式和生存期
  • • 1、動態存儲方式和靜態存儲方式
    • 2、局部變量的存儲類別
    • 3、全局變量的存儲類別
    • 4、存儲類別小結
  • 十、關于變量的聲明和定義
  • 十一、內部函數和外部函數
  • • 1、內部函數
    • 2、外部函數
  • 十二、第七章課后習題答案
• 第八章 善于利用指針
• • 一、指針是什么
  • 二、指針變量
  • 三、通過指針引用數組
  • 四、通過指針引用字符串
  • 五、指向函數的指針
  • 六、返回指針值的函數
  • 七、指針數組和多重指針
  • 八、動態內存分配與指向它的指針變量
  • 九、指針的小結
• 第九章 用戶自己建立數據類型
• • 一、結構體
  • • 1、定義
    • 2、定義結構體類型的變量
    • 3、結構體變量的初始化和引用
    • 4、結構體數組
    • 5、結構體指針
  • 二、共用體
  • • 1、定義
    • 2、區別
    • 3、特點
  • 三、枚舉類型
  • • 1、定義
    • 2、要點
  • 四、用typedef聲明新類型名
• 第十章 C語言文件的讀寫
• • 一、字符讀寫
  • • 1、fputc()函數；
    • 2、fgetc()函數
  • 三、字符串讀寫
  • • 1、fputs()函數
    • 2、fgets()函數
  • 二、數據塊讀寫
  • • 1、 fread()數據塊讀函數
    • 2、fwrite()數據塊寫函數
  • 三、格式化讀寫
  • • 1、fprintf()函數
    • 2、fscanf()函數
• 打完收工！

第一章 程序設計和C語言

一、C的入門小概念

1. 什么是計算機語言？

機器語言即二進制。計算機發展的初期，一般計算機的指令長度為16，即以16個二進制數組成的一條指令。
計算機能夠直接識別和接受的二進制代碼成為機器指令。這種機器指令的集合稱為機器語言。

2.符號語言（又稱為符號匯編語言或匯編語言）

使用一些英文字母和數字表示一個指令。
如：ADD A,B 表示將寄存器A中的數與寄存器B中的數相加，放到寄存器A中。
這種符號語言計算機無法直接識別，需要用匯編程序軟件把符號語言轉為機器指令。即所謂的代真或匯編。

3.高級語言

20世紀50年代世界上第一個高級語言出世——FORTRAN語言。
由于其功能更強大，任何計算機都適用，且距離具體計算機較“遠”故稱為高級語言。
但計算機無法直接識別高級語言

需要經歷以下步驟才能讓計算機識別：

Created with Rapha?l 2.2.0源程序(高級語言編譯)編譯程序目標程序(機器指令的程序)

注：高級語言經歷經歷了一下發展階段：

Created with Rapha?l 2.2.0非結構化語言（如：BASIC/FORTRAN/ALGOL）結構化語言(如：C/QBASIC/FORTRAN 77)面向對象的語言(如：C++/C#/Visual Basic/Java)

4.C語言的主要優點

語言簡介緊湊、方便靈活；

運算符豐富；

數據類型豐富；

具有結構化的控制語句，即C語言是完全模塊化和結構化的語言；

語句限制不太嚴格，程序設計自由度大；

C允許直接訪問物理地址，進行位（BIT）操作，可直接對硬件進行操作；

可移植性好；

生成目標代碼質量高，程序執行效率高。

5.C語言程序的結構

一個程序由一個或多個源程序文件組成

源程序文件可以包括以下3個部分：①預處理指令（#include <stdio.h>）；②全局聲明；③函數定義。

函數是C語言的主要組成部分

一個C程序是由一個或者多個函數組成的，其中必須包含一個main函數（有且僅有一個）

一個函數包括兩個部分

函數的首部和函數體（函數體由聲明部分和執行部分組成）

程序總是從main函數開始執行的（可以放置到任何位置）

程序中要求計算機操作是由函數中的C語句完成的

在每個數據聲明和語句的最后必須有一個分號

C語言本身不提供輸入輸出語句

程序應當包含注釋

6.C程序的步驟與方法

流程總結如下

#mermaid-svg-S2XC6G0Fjs4NVx54 {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-S2XC6G0Fjs4NVx54 .error-icon{fill:#552222;}#mermaid-svg-S2XC6G0Fjs4NVx54 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-S2XC6G0Fjs4NVx54 .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-S2XC6G0Fjs4NVx54 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-S2XC6G0Fjs4NVx54 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-S2XC6G0Fjs4NVx54 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-S2XC6G0Fjs4NVx54 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-S2XC6G0Fjs4NVx54 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-S2XC6G0Fjs4NVx54 .marker.cross{stroke:#333333;}#mermaid-svg-S2XC6G0Fjs4NVx54 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-S2XC6G0Fjs4NVx54 .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-S2XC6G0Fjs4NVx54 .cluster-label text{fill:#333;}#mermaid-svg-S2XC6G0Fjs4NVx54 .cluster-label span{color:#333;}#mermaid-svg-S2XC6G0Fjs4NVx54 .label text,#mermaid-svg-S2XC6G0Fjs4NVx54 span{fill:#333;color:#333;}#mermaid-svg-S2XC6G0Fjs4NVx54 .node rect,#mermaid-svg-S2XC6G0Fjs4NVx54 .node circle,#mermaid-svg-S2XC6G0Fjs4NVx54 .node ellipse,#mermaid-svg-S2XC6G0Fjs4NVx54 .node polygon,#mermaid-svg-S2XC6G0Fjs4NVx54 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-S2XC6G0Fjs4NVx54 .node .label{text-align:center;}#mermaid-svg-S2XC6G0Fjs4NVx54 .node.clickable{cursor:pointer;}#mermaid-svg-S2XC6G0Fjs4NVx54 .arrowheadPath{fill:#333333;}#mermaid-svg-S2XC6G0Fjs4NVx54 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-S2XC6G0Fjs4NVx54 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-S2XC6G0Fjs4NVx54 .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-S2XC6G0Fjs4NVx54 .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-S2XC6G0Fjs4NVx54 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-S2XC6G0Fjs4NVx54 .cluster text{fill:#333;}#mermaid-svg-S2XC6G0Fjs4NVx54 .cluster span{color:#333;}#mermaid-svg-S2XC6G0Fjs4NVx54 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-S2XC6G0Fjs4NVx54 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}編譯連接處理xx.c文件xx.obj文件xx.exe文件

二、程序設計的問題

從確定問題到最后完成任務，一班經歷以下幾個工作階段：
流程總結如下

#mermaid-svg-zVgW6VYmLUtdeWPb {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-zVgW6VYmLUtdeWPb .error-icon{fill:#552222;}#mermaid-svg-zVgW6VYmLUtdeWPb .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-zVgW6VYmLUtdeWPb .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-zVgW6VYmLUtdeWPb .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-zVgW6VYmLUtdeWPb .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-zVgW6VYmLUtdeWPb .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-zVgW6VYmLUtdeWPb .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-zVgW6VYmLUtdeWPb .marker{fill:#333333;stroke:#333333;}#mermaid-svg-zVgW6VYmLUtdeWPb .marker.cross{stroke:#333333;}#mermaid-svg-zVgW6VYmLUtdeWPb svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-zVgW6VYmLUtdeWPb .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-zVgW6VYmLUtdeWPb .cluster-label text{fill:#333;}#mermaid-svg-zVgW6VYmLUtdeWPb .cluster-label span{color:#333;}#mermaid-svg-zVgW6VYmLUtdeWPb .label text,#mermaid-svg-zVgW6VYmLUtdeWPb span{fill:#333;color:#333;}#mermaid-svg-zVgW6VYmLUtdeWPb .node rect,#mermaid-svg-zVgW6VYmLUtdeWPb .node circle,#mermaid-svg-zVgW6VYmLUtdeWPb .node ellipse,#mermaid-svg-zVgW6VYmLUtdeWPb .node polygon,#mermaid-svg-zVgW6VYmLUtdeWPb .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-zVgW6VYmLUtdeWPb .node .label{text-align:center;}#mermaid-svg-zVgW6VYmLUtdeWPb .node.clickable{cursor:pointer;}#mermaid-svg-zVgW6VYmLUtdeWPb .arrowheadPath{fill:#333333;}#mermaid-svg-zVgW6VYmLUtdeWPb .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-zVgW6VYmLUtdeWPb .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-zVgW6VYmLUtdeWPb .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-zVgW6VYmLUtdeWPb .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-zVgW6VYmLUtdeWPb .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-zVgW6VYmLUtdeWPb .cluster text{fill:#333;}#mermaid-svg-zVgW6VYmLUtdeWPb .cluster span{color:#333;}#mermaid-svg-zVgW6VYmLUtdeWPb div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-zVgW6VYmLUtdeWPb :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}問題分析設計算法編寫程序對源程序進行編輯.編譯和連接運行程序且分析結果編寫程序文檔

第一章詳細記錄了各種基本知識概念，從第二章起主要記錄重點。

三、首先要搞清楚編譯器、編輯器和IDE的區別

編譯器、編輯器和IDE的區別
編譯器就是將“一種語言（通常為高級語言）”翻譯為“另一種語言（通常為低級語言）”的程序。一個現代編譯器的主要工作流程：源代碼 (source code) → 預處理器 (preprocessor) → 編譯器 (compiler) → 目標代碼 (object code) → 鏈接器 (Linker) → 可執行程序 (executables)。

第二章 算法——程序的靈魂

一、程序=算法+數據結構

數據結構：**對數據的描述。**在程序中要指定用到哪些數據，以及這些數據的類型和數據的組織形式。
算法：**對操作的描述。**要求計算機進行操作的步驟，也就是算法。

#mermaid-svg-R48NeQd8NdBgnC8a {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-R48NeQd8NdBgnC8a .error-icon{fill:#552222;}#mermaid-svg-R48NeQd8NdBgnC8a .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-R48NeQd8NdBgnC8a .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-R48NeQd8NdBgnC8a .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-R48NeQd8NdBgnC8a .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-R48NeQd8NdBgnC8a .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-R48NeQd8NdBgnC8a .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-R48NeQd8NdBgnC8a .marker{fill:#333333;stroke:#333333;}#mermaid-svg-R48NeQd8NdBgnC8a .marker.cross{stroke:#333333;}#mermaid-svg-R48NeQd8NdBgnC8a svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-R48NeQd8NdBgnC8a .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-R48NeQd8NdBgnC8a .cluster-label text{fill:#333;}#mermaid-svg-R48NeQd8NdBgnC8a .cluster-label span{color:#333;}#mermaid-svg-R48NeQd8NdBgnC8a .label text,#mermaid-svg-R48NeQd8NdBgnC8a span{fill:#333;color:#333;}#mermaid-svg-R48NeQd8NdBgnC8a .node rect,#mermaid-svg-R48NeQd8NdBgnC8a .node circle,#mermaid-svg-R48NeQd8NdBgnC8a .node ellipse,#mermaid-svg-R48NeQd8NdBgnC8a .node polygon,#mermaid-svg-R48NeQd8NdBgnC8a .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-R48NeQd8NdBgnC8a .node .label{text-align:center;}#mermaid-svg-R48NeQd8NdBgnC8a .node.clickable{cursor:pointer;}#mermaid-svg-R48NeQd8NdBgnC8a .arrowheadPath{fill:#333333;}#mermaid-svg-R48NeQd8NdBgnC8a .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-R48NeQd8NdBgnC8a .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-R48NeQd8NdBgnC8a .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-R48NeQd8NdBgnC8a .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-R48NeQd8NdBgnC8a .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-R48NeQd8NdBgnC8a .cluster text{fill:#333;}#mermaid-svg-R48NeQd8NdBgnC8a .cluster span{color:#333;}#mermaid-svg-R48NeQd8NdBgnC8a div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-R48NeQd8NdBgnC8a :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}算法數值運算算法求數值解非數值運算算法姓名排序及圖書檢索等

二、算法的特性

#mermaid-svg-y2hKyDrxCaDNJxjE {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-y2hKyDrxCaDNJxjE .error-icon{fill:#552222;}#mermaid-svg-y2hKyDrxCaDNJxjE .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-y2hKyDrxCaDNJxjE .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-y2hKyDrxCaDNJxjE .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-y2hKyDrxCaDNJxjE .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-y2hKyDrxCaDNJxjE .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-y2hKyDrxCaDNJxjE .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-y2hKyDrxCaDNJxjE .marker{fill:#333333;stroke:#333333;}#mermaid-svg-y2hKyDrxCaDNJxjE .marker.cross{stroke:#333333;}#mermaid-svg-y2hKyDrxCaDNJxjE svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-y2hKyDrxCaDNJxjE .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-y2hKyDrxCaDNJxjE .cluster-label text{fill:#333;}#mermaid-svg-y2hKyDrxCaDNJxjE .cluster-label span{color:#333;}#mermaid-svg-y2hKyDrxCaDNJxjE .label text,#mermaid-svg-y2hKyDrxCaDNJxjE span{fill:#333;color:#333;}#mermaid-svg-y2hKyDrxCaDNJxjE .node rect,#mermaid-svg-y2hKyDrxCaDNJxjE .node circle,#mermaid-svg-y2hKyDrxCaDNJxjE .node ellipse,#mermaid-svg-y2hKyDrxCaDNJxjE .node polygon,#mermaid-svg-y2hKyDrxCaDNJxjE .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-y2hKyDrxCaDNJxjE .node .label{text-align:center;}#mermaid-svg-y2hKyDrxCaDNJxjE .node.clickable{cursor:pointer;}#mermaid-svg-y2hKyDrxCaDNJxjE .arrowheadPath{fill:#333333;}#mermaid-svg-y2hKyDrxCaDNJxjE .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-y2hKyDrxCaDNJxjE .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-y2hKyDrxCaDNJxjE .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-y2hKyDrxCaDNJxjE .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-y2hKyDrxCaDNJxjE .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-y2hKyDrxCaDNJxjE .cluster text{fill:#333;}#mermaid-svg-y2hKyDrxCaDNJxjE .cluster span{color:#333;}#mermaid-svg-y2hKyDrxCaDNJxjE div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-y2hKyDrxCaDNJxjE :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}算法的特性有窮性確定性有零個或多個輸入有一個或多個輸出有效性

三、怎樣表示一個算法

用自然語言表示算法

用流程圖表示算法（傳統流程圖BS、結構化流程圖N-S）

三種基本結構：1、順尋結構，2、選擇結構，3、循環結構【當型（while）循環結構和直到型（until）循環結構】

用偽代碼表示算法

用機器語言表示算法

四、結構化程序的設計方法

#mermaid-svg-3G6XASTZ9u4o7NPW {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-3G6XASTZ9u4o7NPW .error-icon{fill:#552222;}#mermaid-svg-3G6XASTZ9u4o7NPW .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-3G6XASTZ9u4o7NPW .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-3G6XASTZ9u4o7NPW .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-3G6XASTZ9u4o7NPW .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-3G6XASTZ9u4o7NPW .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-3G6XASTZ9u4o7NPW .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-3G6XASTZ9u4o7NPW .marker{fill:#333333;stroke:#333333;}#mermaid-svg-3G6XASTZ9u4o7NPW .marker.cross{stroke:#333333;}#mermaid-svg-3G6XASTZ9u4o7NPW svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-3G6XASTZ9u4o7NPW .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-3G6XASTZ9u4o7NPW .cluster-label text{fill:#333;}#mermaid-svg-3G6XASTZ9u4o7NPW .cluster-label span{color:#333;}#mermaid-svg-3G6XASTZ9u4o7NPW .label text,#mermaid-svg-3G6XASTZ9u4o7NPW span{fill:#333;color:#333;}#mermaid-svg-3G6XASTZ9u4o7NPW .node rect,#mermaid-svg-3G6XASTZ9u4o7NPW .node circle,#mermaid-svg-3G6XASTZ9u4o7NPW .node ellipse,#mermaid-svg-3G6XASTZ9u4o7NPW .node polygon,#mermaid-svg-3G6XASTZ9u4o7NPW .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-3G6XASTZ9u4o7NPW .node .label{text-align:center;}#mermaid-svg-3G6XASTZ9u4o7NPW .node.clickable{cursor:pointer;}#mermaid-svg-3G6XASTZ9u4o7NPW .arrowheadPath{fill:#333333;}#mermaid-svg-3G6XASTZ9u4o7NPW .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-3G6XASTZ9u4o7NPW .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-3G6XASTZ9u4o7NPW .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-3G6XASTZ9u4o7NPW .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-3G6XASTZ9u4o7NPW .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-3G6XASTZ9u4o7NPW .cluster text{fill:#333;}#mermaid-svg-3G6XASTZ9u4o7NPW .cluster span{color:#333;}#mermaid-svg-3G6XASTZ9u4o7NPW div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-3G6XASTZ9u4o7NPW :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}結構化程序的設計方法自定向下逐步細化模塊化設計結構化編碼

第三章 C程序設計——順序程序設計

一、常量和變量

1、常量

常量有以下幾種組成：

#mermaid-svg-jqmZsNl3VPBgiK1B {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-jqmZsNl3VPBgiK1B .error-icon{fill:#552222;}#mermaid-svg-jqmZsNl3VPBgiK1B .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-jqmZsNl3VPBgiK1B .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-jqmZsNl3VPBgiK1B .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-jqmZsNl3VPBgiK1B .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-jqmZsNl3VPBgiK1B .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-jqmZsNl3VPBgiK1B .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-jqmZsNl3VPBgiK1B .marker{fill:#333333;stroke:#333333;}#mermaid-svg-jqmZsNl3VPBgiK1B .marker.cross{stroke:#333333;}#mermaid-svg-jqmZsNl3VPBgiK1B svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-jqmZsNl3VPBgiK1B .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-jqmZsNl3VPBgiK1B .cluster-label text{fill:#333;}#mermaid-svg-jqmZsNl3VPBgiK1B .cluster-label span{color:#333;}#mermaid-svg-jqmZsNl3VPBgiK1B .label text,#mermaid-svg-jqmZsNl3VPBgiK1B span{fill:#333;color:#333;}#mermaid-svg-jqmZsNl3VPBgiK1B .node rect,#mermaid-svg-jqmZsNl3VPBgiK1B .node circle,#mermaid-svg-jqmZsNl3VPBgiK1B .node ellipse,#mermaid-svg-jqmZsNl3VPBgiK1B .node polygon,#mermaid-svg-jqmZsNl3VPBgiK1B .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-jqmZsNl3VPBgiK1B .node .label{text-align:center;}#mermaid-svg-jqmZsNl3VPBgiK1B .node.clickable{cursor:pointer;}#mermaid-svg-jqmZsNl3VPBgiK1B .arrowheadPath{fill:#333333;}#mermaid-svg-jqmZsNl3VPBgiK1B .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-jqmZsNl3VPBgiK1B .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-jqmZsNl3VPBgiK1B .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-jqmZsNl3VPBgiK1B .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-jqmZsNl3VPBgiK1B .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-jqmZsNl3VPBgiK1B .cluster text{fill:#333;}#mermaid-svg-jqmZsNl3VPBgiK1B .cluster span{color:#333;}#mermaid-svg-jqmZsNl3VPBgiK1B div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-jqmZsNl3VPBgiK1B :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}常量整型常量實型常量十進制小數形式指數形式字符常量普通字符轉義字符字符串常量符號常量

要區分符號常量和變量！ 符號常量不占內存，只是一個臨時的符號，代表一個值。為與變量名區別，習慣將符號常量用大寫表示。
符號常量常用#define來指定某個符號代表一個常量，如下所示
#define PI 3.1415926 //表示PI代表的就是3.1415926，這個末尾是不能有分號的

2、變量

變量由以下三個部分構成：

#mermaid-svg-4zRwrFjgCixSKJMi {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-4zRwrFjgCixSKJMi .error-icon{fill:#552222;}#mermaid-svg-4zRwrFjgCixSKJMi .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-4zRwrFjgCixSKJMi .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-4zRwrFjgCixSKJMi .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-4zRwrFjgCixSKJMi .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-4zRwrFjgCixSKJMi .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-4zRwrFjgCixSKJMi .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-4zRwrFjgCixSKJMi .marker{fill:#333333;stroke:#333333;}#mermaid-svg-4zRwrFjgCixSKJMi .marker.cross{stroke:#333333;}#mermaid-svg-4zRwrFjgCixSKJMi svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-4zRwrFjgCixSKJMi .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-4zRwrFjgCixSKJMi .cluster-label text{fill:#333;}#mermaid-svg-4zRwrFjgCixSKJMi .cluster-label span{color:#333;}#mermaid-svg-4zRwrFjgCixSKJMi .label text,#mermaid-svg-4zRwrFjgCixSKJMi span{fill:#333;color:#333;}#mermaid-svg-4zRwrFjgCixSKJMi .node rect,#mermaid-svg-4zRwrFjgCixSKJMi .node circle,#mermaid-svg-4zRwrFjgCixSKJMi .node ellipse,#mermaid-svg-4zRwrFjgCixSKJMi .node polygon,#mermaid-svg-4zRwrFjgCixSKJMi .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-4zRwrFjgCixSKJMi .node .label{text-align:center;}#mermaid-svg-4zRwrFjgCixSKJMi .node.clickable{cursor:pointer;}#mermaid-svg-4zRwrFjgCixSKJMi .arrowheadPath{fill:#333333;}#mermaid-svg-4zRwrFjgCixSKJMi .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-4zRwrFjgCixSKJMi .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-4zRwrFjgCixSKJMi .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-4zRwrFjgCixSKJMi .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-4zRwrFjgCixSKJMi .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-4zRwrFjgCixSKJMi .cluster text{fill:#333;}#mermaid-svg-4zRwrFjgCixSKJMi .cluster span{color:#333;}#mermaid-svg-4zRwrFjgCixSKJMi div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-4zRwrFjgCixSKJMi :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}變量變量名變量值存儲單元

變量代表一個有名字的、具有特定屬性的一個存儲單元。變量的值如名義所釋，可以改變。

3、常變量

C 99 允許使用常變量，定義方法是在一個關鍵字前加const
如下：

const int a=3;

常變量與常量的異同點：常變量具有變量的基本屬性：有類型，占存儲單元，只是不允許改變其值。常變量是有名字的不變量，而常量是沒有名字的不變量。

4、標識符

在計算機高級語言中，用對變量、符號常量名、函數、數組、類型等命名的有效字符序列統稱為標識符。

5、數據類型

#mermaid-svg-GnTjkX7jCsNIsr06 {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-GnTjkX7jCsNIsr06 .error-icon{fill:#552222;}#mermaid-svg-GnTjkX7jCsNIsr06 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-GnTjkX7jCsNIsr06 .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-GnTjkX7jCsNIsr06 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-GnTjkX7jCsNIsr06 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-GnTjkX7jCsNIsr06 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-GnTjkX7jCsNIsr06 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-GnTjkX7jCsNIsr06 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-GnTjkX7jCsNIsr06 .marker.cross{stroke:#333333;}#mermaid-svg-GnTjkX7jCsNIsr06 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-GnTjkX7jCsNIsr06 .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-GnTjkX7jCsNIsr06 .cluster-label text{fill:#333;}#mermaid-svg-GnTjkX7jCsNIsr06 .cluster-label span{color:#333;}#mermaid-svg-GnTjkX7jCsNIsr06 .label text,#mermaid-svg-GnTjkX7jCsNIsr06 span{fill:#333;color:#333;}#mermaid-svg-GnTjkX7jCsNIsr06 .node rect,#mermaid-svg-GnTjkX7jCsNIsr06 .node circle,#mermaid-svg-GnTjkX7jCsNIsr06 .node ellipse,#mermaid-svg-GnTjkX7jCsNIsr06 .node polygon,#mermaid-svg-GnTjkX7jCsNIsr06 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-GnTjkX7jCsNIsr06 .node .label{text-align:center;}#mermaid-svg-GnTjkX7jCsNIsr06 .node.clickable{cursor:pointer;}#mermaid-svg-GnTjkX7jCsNIsr06 .arrowheadPath{fill:#333333;}#mermaid-svg-GnTjkX7jCsNIsr06 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-GnTjkX7jCsNIsr06 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-GnTjkX7jCsNIsr06 .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-GnTjkX7jCsNIsr06 .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-GnTjkX7jCsNIsr06 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-GnTjkX7jCsNIsr06 .cluster text{fill:#333;}#mermaid-svg-GnTjkX7jCsNIsr06 .cluster span{color:#333;}#mermaid-svg-GnTjkX7jCsNIsr06 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-GnTjkX7jCsNIsr06 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}數據類型基本類型派生類型整型類型浮點類型基本整形int短整型short int長整型long int雙長整型long long int字符型char布爾型bool單精度浮點型float雙精度浮點型double復數浮點型float_complex,double_complex,long long_complex枚舉類型enum/空類型void指針類型*數組類型結構體類型struct共用體類型union函數類型

二、運算符和表達式

C語言提供了一下運算符:

算術運算符

關系運算符

邏輯運算符

位運算符

賦值運算符

條件運算符

逗號運算符

指針運算符

求字節數運算符(sizeof)

強制類型轉換運算符

成員運算符(.->)

下標運算符([])

其他

三、C語句

一個函數包含聲明部分和執行部分

C語句分為以下5類：

#mermaid-svg-ZqkR8slQQPNQ2xqZ {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .error-icon{fill:#552222;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .marker{fill:#333333;stroke:#333333;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .marker.cross{stroke:#333333;}#mermaid-svg-ZqkR8slQQPNQ2xqZ svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .cluster-label text{fill:#333;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .cluster-label span{color:#333;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .label text,#mermaid-svg-ZqkR8slQQPNQ2xqZ span{fill:#333;color:#333;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .node rect,#mermaid-svg-ZqkR8slQQPNQ2xqZ .node circle,#mermaid-svg-ZqkR8slQQPNQ2xqZ .node ellipse,#mermaid-svg-ZqkR8slQQPNQ2xqZ .node polygon,#mermaid-svg-ZqkR8slQQPNQ2xqZ .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .node .label{text-align:center;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .node.clickable{cursor:pointer;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .arrowheadPath{fill:#333333;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .cluster text{fill:#333;}#mermaid-svg-ZqkR8slQQPNQ2xqZ .cluster span{color:#333;}#mermaid-svg-ZqkR8slQQPNQ2xqZ div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-ZqkR8slQQPNQ2xqZ :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}C語句控制語句函數調用語句表達式語句空語句復合語句

最基本的語句：賦值語句

1、關于#include的用法

#include用法的問題，大家可以看看我這一篇：
https://blog.csdn.net/Songbook/article/details/79630777

2、關于#define的用法

#define的用法，大家可以看看我這一篇文章
https://blog.csdn.net/Songbook/article/details/79645982

3、關于%的使用方法

%的使用方法大家可以看看我這一篇
https://blog.csdn.net/Songbook/article/details/79646427

四、數據的輸入輸出

1、相關概念

1、輸入輸出是以計算機主機為主體而言的；
2、C語言本身不提供輸入輸出語句；
3、要在程序文件的開頭用預處理指令#include把有關的頭文件放在本程序中。

2、用printf函數輸出數據

格式字符：

d格式符：用來輸出一個有符號的十進制整數；

c格式符：用來輸出一個字符；

s格式符：用來輸出一個字符串；

f格式符：用來輸出實數，以小數形式輸出
①基本型，用%f
②指定數據寬度和小數位數，用%m.nf，如：%7.2f——代表數據占7位，小數2位。
③輸出的數據向左對齊，用%-m.nf——與上相似，但當數據長度不超過m時，數據向左靠，右端補空格

e格式符：用格式聲明%e指定以指數形式輸出實數。

其他格式符：
①i格式符——與d格式符相同
②o格式符——以八進制數的形式輸出
③x格式符——以十六進制數形式輸出整數
④u格式符——用來輸出無符號數據
⑤g格式符——用來輸出浮點數系統自動選f格式或e格式輸出

使用scanf應注意格式控制后面應當是變量地址，而不是變量名。

3、字符輸入輸出函數

putchar(c);//是put character的縮寫，意為給字符，即從計算機向顯示器輸出一個字符； getchar();//是get character的縮寫，意為：取字符，即從鍵盤輸入一個字符。且只能接受一個字符

第三章練習題答案已經手編出來了，有需要的可以看看哦
鏈接在下方
https://blog.csdn.net/Songbook/article/details/123154963

第四章 選擇結構程序設計

一、選擇結構和條件判斷（略）

本章需要大家大量實操，概念什么的已經從這開始就不是那么重要了，重在練習！

二、用if語句實現選擇結構（略）

三、關系運算符和關系表達式

比較符稱為關系運算符

關系運算符及其優先次序

< （小于）

<= （小于等于）

> (大于)

>= （大于等于）
以上優先級相同（高優先級）

以下優先級相同（低優先級）
5. == （等于）
6. != (不等于)

優先級從高到低：
算術運算符，關系運算符，賦值運算符

int X=20,Y=10;

四、邏輯運算符和邏輯表達式（略）

五、條件運算符和條件表達式（略）

優先級一覽表

六、選擇結構的嵌套（略）

七、用switch語句實現多分支選擇結構（略）

關于C里面的很多小細節將在代碼中給大家呈現，我會酌情將課后大題答案放在每章結尾處，供大家取閱。歡迎大家批評指正！戶籍里面有很多細節部分，時間原因我會在后期慢慢添加相關細節，大家也可以提出建議，我會盡能力彌補漏洞的！

第四章課后習題答案在此！
https://blog.csdn.net/Songbook/article/details/123166383

第五章 循環結構設計

這一章基本上都是算法，我會單獨做完發鏈接，你們可以酌情查閱哦！

一、關于循環結構中break、continue、return和exit的區別

此處有一篇文章寫的挺全的，大家可以->戳這<-來看看！

二、第五章課后習題答案

第五章的課后習題，我已經給大家弄出來了，有什么問題歡迎留言！！！
https://blog.csdn.net/Songbook/article/details/123209850

第六章 利用數組處理批量數據

1.數組是一組有序數據的集合；
2.用一個數組名和下標來唯一確定數組中的元素；
3.數組中的每一個元素都屬于同一個數據類型。

一、怎樣定義和引用一維數組

1、 怎樣定義一維數組

int a[10]; /* 定義一維數組的一般形式為： 類型符 數組名[常量表達式]; */

2、怎樣引用一維數組元素

表示形式為：
數組名[下標]

int a[10];//這是定義數組，指定數組中包含十個元素 t=a[6];//這里的a[6]表示引用a數組中序號為6的元素

3、一維數組的初始化

1、在定義數組時對全部數組元素賦予初值：

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

2、可以只給數組中的一部分元素賦值：

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

3、如果想使一個數組中全部元素值為0：

int a[10]={0,0,0,0,0,0,0,0,0,0}; //或者這樣 int a[10]={0};

4、在對全部數組元素賦初值時，由于數據的個數已經確定，因此可以不指定數組長度：

int a[5]={0,1,2,3,4}; //或者這樣 int a[]={0,1,2,3,4};

注意：int a[10]={1,2,3,4,5}代表的含義是：只初始化前5個元素，后5個元素為0。

二、怎樣定義和引用二維數組

1、怎樣定義二維數組

float a[3][4],b[5][11];//定義為3x4（3行4列）的數組，b為5行11列的數組。 //一般形式為：類型說明符 數組名[常量表達式][常量表達式];

2、怎樣引用二維數組的元素

二維數組元素的表示形式為：
數組名[下標][下標]

注意：

int a[3][4];//定義a為3x4的二維數組 //但不存在a[3][4]這個元素

按照上面的定義：數組a中的行下標為0-2，列下標為0-3，因此a[3][4]已經超出了數組的范圍。

3、二維數組的初始化

1、分行給二維數組賦初值；

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

2、可以將所有數據寫在一個花括號內，按數組元素在內存中的排列順序對各元素賦初值；

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

3、可以對部分元素賦初值；

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

4、如果對全部元素都賦初值，則定義數組時對第1維的長度可以不指定，但第2維的長度不能省略。

int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12}; //或者 int b[][4]={{1,2,3},{},{8,6}};

三、字符數組

1、怎樣定義字符數組

char c[4]; c[0]='l'; c[1]='o'; c[2]='v'; c[3]='e';

2、字符數組的初始化

char c[10]={'i','','a','m','','h','a','p','p','y'};//字符的初始化

3、怎樣引用字符數組中的元素

可以引用字符數組中的一個元素，得到一個字符串。

#include <stdio.h> int main(){ char c[10]={'i','','a','m','','h','a','p','p','y'};//字符的初始化 int i; for(i=0;i<10;i++) printf("%c",c[i]); printf("\n"); return 0; }

4、字符串和字符串結束標志

當遇到’\0’的的時候系統自動判定字符串結束，并把它前面的字符組成一個字符串
C系統再用字符串存儲字符串常量時會自動加一個’\0’作為結束符

5、字符數組的輸入輸出

1、輸出的字符串不包括結束符’\0’；
2、用"%s"格式符輸出字符串的時候，printf函數中的輸出項是字符數組名，而不是數組元素名；
3、如果數組長度大于字符串的實際長度，也只輸出到遇’\0’結束；
4、如果一個字符數組中包含一個以上的’\0’，則遇第一個‘\0’時輸出就結束；

#include <stdio.h> #include <string.h> int main(){char a[]={"abdjad\0\0\0asd"};puts(a); printf("%d\n",strlen(a));return 0; }

說明當程序遇到’\0’便自動停止錄入！

5、可以用scanf函數輸入一個字符串：

scanf("%s",c);

6、使用字符串處理函數

以下字符串處理函數需要加上#include <string.h>頭文件

#include <stdio.h> #include <string.h> int main(){char str[]={'C','h','i','n','a'};char str1[20],str2[20];//puts函數——輸出字符串的函數//puts(字符數組)//puts輸出時將字符串結束標志'\0'轉換成'\n'，即輸出完字符串后換行！puts(str);//gets函數 ——輸入字符串的函數 gets(str);//其函數值是字符數組的起始地址puts(str);//puts函數和gets函數一次只能輸出或輸入一個字符串 //strcat函數——字符串連接函數//strcat(字符數組1，字符數組2)作用是將兩個字符串連接起來gets(str1);gets(str2); puts(strcat(str1,str2));//將str1和str2連接起來，并將連接的值賦給str1！ puts(str1);puts(str2);//strcpy和strncpy函數——字符串復制函數//一般形式為：strcpy(字符數組1，字符數組2)puts(strcpy(str1,str2));//將str2的值復制給str1 /*注意：1、在復制前str1定義得足夠大，以便容納str2的值 ；2、數組一的str1必須攜程數組名形式， 數組二str2可以使字符數組名，也可以是一個字符串常量：strcpy(sttr1,'china!');3、在復制之前若未對str1進行初始化，則str1的各字節中的內容是無法預知的；4、不能用賦值語句將一個字符串常量或字符數組直接給一個字符數組，只能用strcpy函數講話一個字符串復制到另一個字符數組中去； 5、 可以用strncpy函數將字符串2中前面n個字符復制到字符數組1中去。 */ //strcmp函數——字符串比較函數printf("%d\n",strcmp(str1,str2));//比較字符串str1和str2//比較規則：若果全部字符相同，則認為兩個字符串相等；若出現不相同的字符，則以第一對不相同的字符的比較結果為準（在英文字典中位置在后面的為大）//strlen函數——測字符串長度的函數 printf("%d\n",strlen(str1)); //測量字符串的長度并返回相應的值//strlwr函數——轉換為小寫函數puts(strlwr(str2));//將里面的所有大寫字母轉換成小寫字母//strupr函數——轉換為大寫的函數puts(strupr(str2));//將里面的所有小寫字母轉換為大寫字母return 0; }

四、第六章課后習題答案

https://blog.csdn.net/Songbook/article/details/123276276

第七章 用函數實現模塊化程序設計

一、為什么要用函數

函數就是功能，函數是為了是程序更加精簡、更有結構感和層次感而設計的！用來完成一些特定的功能，通過調用函數庫從而使用它們，這也是模塊化程序設計的思路。

二、怎樣定義函數

1、為什么要定義函數

定義函數包括以下幾個內容：

指定函數的名字，以便以后按名調用；

指定函數的類型，即函數返回值的類型；

指定函數的參數的名字和類型，以便在調用函數時向他們傳遞數據。對無參函數不需要這項；

**指定函數應當完成什么操作，也就是函數是做什么的，即函數的功能。**是在函數體中解決的。

注：在文件開頭寫#include <stdio.h>

2、定義函數的方法

定義無參函數；如：void

定義有參函數；如：int max(int x,int y){ int z; z=x+y; return(z);}

定義空函數；如：void sum{}

三、調用函數

1、函數的調用形式

一般調用形式：函數名(實參表列)

函數調用語句；

函數表達式；

函數參數；函數參數分為形參和實參

2、函數調用時的數據傳遞

形式參數和實際參數

在調用有參函數式，主調函數和被調函數之間有數據傳遞關系。
在定義函數式函數名后面括號中的變量名稱為 “形式參數” 或“虛擬參數”
在主調函數中調用一個函數時，函數名后面括號中的參數稱為 “實際參數”

實參和形參間的數據傳遞

在調用函數的過程中，系統會將實參的值傳給形參，其中的數據傳遞稱為 “虛實結合”

3、函數調用的過程

1、形參在為調用之前不占內存存儲單元，只有調用的時候系統才會給它分配內存單元；
2、當系統調用的時候，會將實參的值換遞給形參；
3、函數調用期間，形參已經分配了臨時的存儲空間，即已經有值故而直接使用形參進行相關運算；
4、被調用的函數會通過return將值傳遞回調用函數里面；
5、當調用結束，給形參的存儲空間自動釋放。

當函數不進行申明自動默認為int類型！

4、函數的返回值

函數的返回值是從return中獲取；

函數值的類型與函數定義有關；

當函數值定義為void即不返回值的函數不用進行return，當沒有void就需要進行return返回相應的結果。即：函數類型決定返回值的類型。

對于不返回值的番薯，應當是定義函數為void類型。

四、對被調用函數的聲明和函數原型

被調用的函數必須是已經定義的函數；

如果使用的是庫函數，必須在開頭調用#include指令，將有關的庫函數所需的信息包含的文件夾中來；

如果使用的是自己定義的函數，且函數的位置在調用它的函數后面，則需要在主函數中對被調用的函數進行聲明。即：簡概而論就是將定義的函數頭放到主函數中。

五、函數的嵌套調用（略）

六、函數的遞歸調用（略）

七、數組作為函數參數

1、數組元素做函數實參

在用數組元素做函數實參時，把實參的值傳遞給形參，是“值傳遞”方式。數據傳遞的方向是從實參傳到形參，單向傳遞。

2、一維數組名作函數傳遞

用數組名做函數的參數，應該在調用函數和被調用函數都分別定義數組；

實參和形參的類型應該一致；

定義形參數組的大小是無任何意義的；

形參數組可以不指定大小，在定義后面跟一個空的括號即可。

3、多維數組名作函數參數

可以用多維數組名作為函數的實參和形參，在被調用函數中對形參數組定義時可以指定每一維的大小，也可以省略第一維的大小說明。

//以下是合法的 int a[4][8]; int b[][9]; //以下是不合法的 int c[][]; int d[6][];

八、局部變量和全局變量

定義變量可能有以下三種：

在函數的開頭定義；

在函數內的復合語句內定義；

在函數的外部定義。

1、局部變量

在函數內部定義變量，該變量的生命周期只有在該函數結束的時候自動“死亡”。因此這類函數是不能在函數的外部使用的，以上被稱為“局部變量”；

注意以下幾點：

在主函數定義的變量，也只能在主函數內部使用，不能在其他函數中使用；

不同函數中可以定義相同名字的變量，互不影響；

形式參數也屬于局部變量；

在復合語句中（即程序塊）定義的變量，生命周期在該復合語句結束的時候自動釋放，因此也只能在復合語句中使用。

2、全局變量

在函數外部定義的變量稱為外部變量，外部變量是全局變量。它的生命周期為整個文件，當整個文件運行結束的時候，系統才會釋放它的存儲空間。

全局變量有利有弊，它即可以增加函數之間的數據聯系，也為數據值得改變埋下了隱患。

因此建議在不必要的情況盡量減少使用全局變量：

全局變量的生命周期是整個文件，因此若無必要則浪費系統存儲單元空間；

它會使函數的通用性降低，在劃分模塊要求將模塊的“內聚性”強、與其他模塊的“耦合性”弱，即盡量封閉；

使用全局變量會降低程序的清晰性。

九、變量的存儲方式和生存期

1、動態存儲方式和靜態存儲方式

變量可以分為全局變量和局部變量，即變量的生存周期長短不一。
變量的存儲有兩種方式：靜態存儲方式和動態存儲方式。

靜態存儲方式：在程序運行期間有系統分配固定的存儲空間的方式；
動態存儲方式：程序運行期間根據需要進行動態分配存儲空間的方式。

內存中供用戶使用的存儲空間的情況：

程序區；

靜態存儲區；

動態存儲區。

全局變量存儲在靜態存儲區。

在動態存儲區存放以下數據：

函數形式參數；

函數中定義的沒有用關鍵字static聲明的變量，即自動變量（auto）；

函數調用時的現場保護和返回地址等。

在C語言中，每一個變量和函數都有兩個屬性：數據類型（整形、浮點型等）和數據的存儲類別（靜態存儲和動態存儲）
C語言的存儲類別有四種：自動的auto、靜態的static、寄存器的register、外部的extern。

2、局部變量的存儲類別

1.自動變量

在調用函數的時候，系統會自動分配這些變量的存儲空間，并在函數調用結束的時候自動釋放這些空間，這類變量稱為自動變量。
自動變量一般用auto作為存儲類別的聲明，實際上，關鍵字auto可以省略，不寫auto則隱含指定為“自動存儲類別”。
存儲在動態存儲區
2.靜態局部變量
即生命周期為整個文件的開始而開始結束而結束。
一般用static進行聲明。
1、對靜態局部變量，只賦初值一次，在編譯時賦初值；自動變量則是在函數調用時賦初值
2、對于靜態局部變量來說，如果在編譯之初不賦初值，系統自動賦初值0或空字符’\0’；對于自動變量則為系統隨機的內存地址；
3、靜態局部變量雖然生存周期長，但仍然是局部變量，其他函數不能引用它。
存儲在靜態存儲區。

3.寄存器變量

一般對于使用非常頻繁地變量定義為寄存器變量，因為寄存器的存儲速度遠遠高于內存的存取速度，這樣可以提高執行效率。
一般用register進行聲明。
存儲在CPU中的寄存器中。

3、全局變量的存儲類別

1)在一個文件內擴展外部變量的作用域

外部變量的生存周期在它定義點到文件結束。它之前的部分不能引用它。可以使用extern進行外部變量聲明，就可以從聲明處之后引用該變量了。

2)將外部變量的作用域擴展到其他文件

在要調用外部變量的文件中用extern將外部變量的作用域擴展到本文件中來即可。

3)將外部變量的作用域限制在本文件中

當靜態外部變量定義聲明前加上static，則為限制只能用于本文件的外部變量。
>用static聲明一個變量的作用是;
1.對局部變量用static聲明，把它分配在靜態存儲區，該變量在整個程序執行期間不釋放，其所分配的空間始終存在；
2.對全局變量用static聲明，則該變量的作用域只限于本文件模塊。

4、存儲類別小結

對一個數據的定義，需要指定兩種屬性：數據類型和存儲類別。

十、關于變量的聲明和定義

1、聲明和定義的區別：

我們已經知道一個函數是由兩個部分組成：聲明部分和執行部分。
聲明部分的作用是對有關的標識符（如：變量、結構體和共用體等）的屬性進行聲明。
聲明和定義明顯，函數的聲明是函數的原型，二函數的定義是對函數功能的定義。
對被調用函數的聲明是放在主調函數的聲明部分中的，而函數的定義顯然不在聲明部分的范圍內，他是一個獨立的模塊。

在聲明部分出現的變量通常有兩種情況：一種是需要建立存儲空間的；(如:int a;)另一種是不需要建立存儲空間的。（如:extern a;）第一種稱為：定義性聲明。簡稱：定義第二種稱為：引用性聲明。

把建立存儲空間的聲明稱定義，把不需要建立存儲空間的聲明稱為聲明。

十一、內部函數和外部函數

根據函數能否被其他源文件調用，將函數區分為內部函數和外部函數。

1、內部函數

如果一個函數只能夠被本文件中的其他函數所調用，稱為內部函數。又稱為靜態函數。

2、外部函數

在定義函數時，在函數首部的最左端加extern，則此函數是外部函數，可供其他文件調用。
函數首部可以為：extern int fun (int a,int b);
因此當在定義的時候省略了extern，則默認為外部函數。前面所有使用的程序都是外部函數。
因此在調用此函數的其他文件中，需要對此函數做說明，即使在本文件中調用一個函數，也要用函數原型進行聲明，因此每次將main函數放在文件最下面，可以省略聲明，但為了嚴謹也應該進行聲明。

十二、第七章課后習題答案

大家可以看看這一篇！

第八章 善于利用指針

一、指針是什么

簡而言之，指針就是存儲的某個地址的一個空間，而地址指向的是某個變量的變量單元。因此將地址形象化地稱為“指針”。意思是能通過這個指針找到以它為地址的內存單元。
對變量的訪問可以分為直接訪問和間接訪問。
如果有一個變量專門用來存放另一變量的地址（即指針），則它稱為“指針變量”。

二、指針變量

定義指針變量：
類型名 *指針變量名;
int *p1,*p2;
左端的int是在定義指針變量時必須指定的“基類型”。

在定義指針變量時要注意：

指針變量前面的*表示該變量為指針型變量；

在定義指針變量時必須指定基類型。一個變量的指針的含義包含兩個方面：一是一存儲單元編號表示的純地址，一是它指向的存儲單元的數據類型；

整數型指針用int *,讀作指向int類型的指針或int指針；

指針變量中只能存放地址。

p=&a;//給指針變量賦值 printf("%d",*p);//輸出a的值，即以整數形式輸出指針變量p所指向的變量的值 printf("%o",p);//以八進制的形式輸出指針p的值，也就是a的地址

注意：C語言中實參變量和形參變量之間的數據傳遞是單向的“值傳遞”方式。

三、通過指針引用數組

所謂數組元素的指針就是數組元素的地址。
引用數組元素可以用下標法，也可以用指針法，即通過指向數組元素的指針找到所需的元素。

int *p=&a[0]; //等價于 int *p; p=&a[0]; //等價于 int *p=a; //即：將a[0]的首地址給指針變量p;

注意：
在指針已指向一個數組元素時，可以對指針進行自加或自減運算。
1、如果指針p已經指向數組中的一個元素，則p+1指向同一個數組中的下一個元素，p-1指向同一數組中的上一個元素；
2、如果p的初值為&a[0],則p+i和a+i就是數組元素a[i]的地址；
3、其實在編譯時候a[i]就是按照a[i+1]處理的，即按照數組首元素的地址加上相對位移量得到要找的元素的地址，然后找出該單元中的內容，即：(p+5)=*(a+5)=a[5]。[]實際上就是變址運算符，即將a[i]按a+i計算地址，然后找出此地址單元中的值；
4、如果指針變量P1和P2都指向同一數組中的元素，如執行p2-p1,結果是p2-p1的值除以數組元素的長度，即：兩個指針所指元素之間的距離。
兩指針不能相加，相加毫無意義。
不用變化指針p的方式，換做變換數組a的方式即 ：a++是不行的，因為a是常量，a++無法實現

*(p--)相當于a[i--]; *(++p)相當于a[++i]; *(--p)相當于a[--i];

指針在函數中的運用

C編譯都是將形參數組名作為指針變量來處理的。

指針在多維數組元素中的運用

一個二維數組：a[n][n],其中a+1為a[1][0]。
在二維數組中：a+i,a[i],*(a+i),&a[i],&a[i][0]的值相同，即它們都代表同一地址，但基類型不同。

#include <stdio.h> int main(){int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};printf("%d,%d\n",a,*a);printf("%d,%d\n",a[0],*(a+0));printf("%d,%d\n",&a[0],&a[0][0]);printf("%d,%d\n",a[1],a+1);printf("%d,%d\n",&a[1][0],*(a+1)+0);printf("%d,%d\n",a[2],*(a+2));printf("%d,%d\n",&a[2],a+2);printf("%d,%d\n",a[1][0],*(*(a+1)+0));printf("%d,%d\n",*a[2],*(*(a+2)+0));return 0; }

由于分配內存情況不同，所顯示的地址可能是不同的，但是上面顯示的地址是有共同規律的。
int (*p)[4];//表示定義p為一個指針變量，它指向包含4個整形元素的一維數組；
int *p[4];表示的是指針數組。（因為[]的運算優先級別高所以會從左至右運行。）

四、通過指針引用字符串

1、字符數組由若干個元素組成，每個元素中放一個字符，而字符指針變量中存放的是地址（字符串第1個字符的地址），絕不是將字符串放到字符指針變量中；
2、可以對字符指針變量賦值，但不能對數組名賦值；
3、可以在定義時對各元素賦初值，但不能用賦值語句對字符數組中全部元素整體賦值；
4、編譯時為字符數組分配若干存儲單元，以存放各元素的值，而對字符指針變量，只分配一個存儲單元；
5、指針變量的值是可以改變的，而字符數組名代表一個固定的值，不能改變；
6、字符數組中各元素的值是可以改變的（可以對它們再賦值），但字符指針變量指向的字符串常量中的內容是不可以被取代的；
7、如果定義了字符指針變量，并使它指向了數組a的首元素，則可以用指針變量帶下標的形式引用數組元素，同樣，可以用地址發引用數組元素；但若未指向數組，則無法用此類形式引用數組中的元素；
8、用指針指向格式字符串，可用它代替printf函數中的格式字符串。

char *ff; ff="a=%d,b=%c\n"; printf(ff,a,b); //相當于 printf("a=%d,b=%c\n",a,b);//這種printf函數稱為可變格式輸出函數。

五、指向函數的指針

函數名代表的是函數的起始地址

#include <stdio.h> #include <math.h> int main(){int max(int x,int y);int (*p)(int x,int y);//若*p的括號去掉則由于優先級的關系成為了申明一個p函數 而我們是在定義一個指向函數的指針變量 int a,b,c;p=max;//使p指向max函數printf("input a and b:\n");scanf("%d%d",&a,&b);c=(*p)(a,b);printf("最大的值為：%d\n",c); return 0; } int max(int x,int y){int z;x>y?z=x:z=y;return(z); }

1、定義指向函數的指針變量，只能指向在定義時指定的類型的函數，且一個指針變量可以先后指向同類型的不同函數；
2、如果要用指針調用函數，必須先使指針變量指向該函數；
3、再給函數指針變量賦值是，只給出函數名而不給參數；
4、用函數指針變量調用函數時，將(*p)代替函數名即可；
5、函數指針是不能夠進行算術運算的；
6、函數名只能調用所定義的一個函數，而通過指針變量則比較靈活。

#include <stdio.h> #include <math.h> int main(){int max(int x,int y);int min(int x,int y);int (*p)(int x,int y);int a,b,c;printf("input a and b:\n");scanf("%d%d",&a,&b);printf("請輸入 1 or 2 ：\n");int n;scanf("%d",&n);if(n==1)p=max;else if(n==2)p=min;c=(*p)(a,b);if(n==1)printf("最大的值為：%d\n",c); if(n==2)printf("最小的值為：%d\n",c); return 0; } int max(int x,int y){int z;x>y?z=x:z=y;return(z); } int min(int x,int y){int z;x<y?z=x:z=y;return(z); }

這是一個調用函數的雛形，大家要學會哦！

指向函數的指針變量的一個重要用途是把函數的入口地址作為參數傳遞到其他函數。

六、返回指針值的函數

定義返回指針值的函數原型的一般形式為:
類型名 *函數名(參數列表);
對于初學者來說一般不太習慣，所以使用的時候要小心。
比如：
int *a(int x,int y);
a是函數名，調用他以后能得到一個int *型（指向整形數據）的指針，即整型數據的地址。x和y勢函數的形參，為整形。此函數是指針型函數（函數值是指針），最前面的int表示返回的指針指向整形變量。

七、指針數組和多重指針

一個數組，若其元素均為指針類型數據，稱為指針數組。也就是說指針數組中的每一個元素都存放一個地址，相當于一個指針變量。

int (*p)[4];//這是指向一維數組的指針變量

格式：
類型名 * 數組名[數組長度]；

指向指針數據的指針變量，簡稱指向指針的指針

char **p;

這里可以把char **p分為兩部分來看，char * 和 (*p),后面的(*p)表示p是指針變量，前面的char *表示p指向的是char *型的數據。
數組元素只能存放地址，不能存放整數

main函數的形參

int main(int argc,char argv[])
其中的argc和argv就是main函數的形參，它們是程序的“命令行參數”。
argc：argument count（參數個數）的縮寫。
argv：argument vector（參數向量）的縮寫。它是char指針數組，數組中每一個元素（其值為指針）指向命令行的一個字符串的首字符。
main的函數的形參不一定命名為argc和argv，可以使任意的名字，只是人們習慣使用argc和argv罷了

八、動態內存分配與指向它的指針變量

全局變量是分配在內存中的靜態存儲區的，非靜態的局部變量是分配在內存中的動態存儲區的，這個存儲區是一個稱為棧的區域。
存儲動態分配區域臨時存儲的數據存放在一個特別的自由存儲空間稱為堆區。

對內存動態分配是通過系統提供的庫函數來實現的主要有malloc、calloc、free、realloc這四個函數。

其中
用malloc函數開辟動態存儲空間；
作用：在內存的動態存儲區中分配一個長度為size的連續存儲空間。size的類型定位無符號整型

void *malloc(unsigned int size); malloc(100);//開辟100字節的臨時分配域，函數值為其第一個字節的地址

用calloc函數開辟動態存儲區；
作用：在內存的動態存儲區中分配n個長度為size的連續空間，這個空間一般比較大，足以保存一個數組。

p=calloc(50,4);//開辟50x4個字節的臨時分配域，把首地址賦給指針變量p //用calloc函數可以為一維數組開辟動態存儲空間，n為數組元素個數，每個元素長度為size。

malloc和calloc的區別:函數malloc()和函數calloc()的主要區別是前者不能初始化所分配的內存空間,而后者能。如果由malloc()函數分配的內存空間原來沒有被使用過，則其中的每一位可能都是0;反之,如果這部分內存曾經被分配過,則其中可能遺留有各種各樣的數據。也就是說，使用malloc()函數的程序開始時(內存空間還沒有被重新分配)能正常進行,但經過一段時間(內存空間還已經被重新分配)可能會出現問題。
函數calloc()會將所分配的內存空間中的每一位都初始化為零,也就是說,如果你是為字符類型或整數類型的元素分配內存,那麼這些元素將保證會被初始化為0;如果你是為指針類型的元素分配內存,那麼這些元素通常會被初始化為空指針;如果你為實型數據分配內存,則這些元素會被初始化為浮點型的零。

用realloc函數重新分配動態存儲區；
當通過malloc和calloc函數獲得動態空間，想改變其大小，可以用recalloc函數重新分配。
用realloc函數將p所指的動態空間大小改變為size。

用free函數釋放動態存儲區。
作用：釋放指針變量p所指向的動態空間，使這部分空間能重新被其他變量使用。

p應該是最近一次調用calloc或malloc函數得到的函數返回值。

void指針類型。
C99使用基類型為void的指針類型，可以定義一個基類型為void的指針變量（void*型變量）它不指向任何類型的數據。
void p;//指向空類型或不指向確定的類型的數據。
將它值賦給另一指針變量時由系統對它進行類型轉換，使之適合于被賦值的變量的類型。
void稱為空類型指針它不指向任意一種具體的類型數據，只提供一個純地址。
這種空類型指針在形式上和其他指針一樣，遵循C語言對指針的有關規定，它也有基類型，只是它的基類型是void。
void*型紙質恩代表“無指向的地址”，這種指針不指向任何類型的數據。不能企圖通過它存取數據，在程序中它只是過渡性的，只有轉換為有指向的地址，才能存取數據。

九、指針的小結

指針的含義：

1、&a是變量a的地址,也可稱為變量a的指針；
2、指針變量是存放地址的變量，也可說，指針變量是存放指針的變量；
3、指針變量也可稱為地址變量，它的值是地址；
4、&是取地址運算符，也可說是去指針運算符，&a是a的地址，也是變量a的指針；
5、數組名是一個地址，是數組首元素的地址，也可說是一個指針，是首元素的指針；
6、函數名是一個指針（即函數代碼區的首字節），也可以說函數名是一個地址；
7、函數的實參如果是數組名，傳遞給形參的是一個地址，也可說傳遞給形參的是一個指針；

在c語言中，所有的數據都是有類型的，此外不同類型的數據有不同的運算規則，即c語言中的數據都是有類型的數據，或稱“帶類型的數據”；對地址而言，也同樣有類型，地址不是一個數值型數據，它是按指針型數據存儲的方式存儲的，指針型存儲單元是專門用來存放地址的，指針型數據的存儲形式就是地址的存儲形式；

地址型的數據包含三個信息：
1、表示內存編號的純地址；
2、它本身的類型，即指針類型；
3、以它為標識的存儲單元中存放的是什么類型的數據，即基類型。

區別指針和指針變量：

指針就是地址，而指針變量就是用來存放地址的變量。指針是沒有值的，只有指針變量才有值，即指針變量的值是一個地址；

什么是“指向”？

地址就意味著指向。對于指針變量來說，把誰的地址存放在指針變量中，就說此指針變量指向誰，但并不是任何類型的數據的地址都可以存放在同一個指針變量中的，只有與指針變量的基類型相同的數據的地址才能存放在相應的指針變量中；
==void * 指針是一種特殊的指針，不指向任何類型的數據。==若要用此地址指向某種類型，應當先對地址進行類型轉換；

在對數組的操作中正確使用指針，p=a；a是數組，p是指向數組中的元素而并非指向整個數組，準確說p指向a數組的首元素；

有關指針變量的歸納比較：

變量定義類型表示含義

int i;	int	定義整形變量i
int*p	int *	定義p為指向整型數據的指針變量
int a[5]	int [5]	定義整形數組a，它有5個元素
int *p[4];	int *[4]	定義指針數組p，它由4個指向整型數據的指針元素組成
int (*p)[4];	int (*)[4]	p指向包含4個元素的一維數組的指針變量
int f();	int ()	f為返回整形數值的函數
int *p();	int*()	p為返回一個指針的函數，該指針指向整型數據
int(*p)();	int(*)()	p為指向函數的指針，該函數返回一個整形值
int **p;	int **	p是一個指針變量，它指向一個指向整型數據的指針變量
void *p;	void *	p是一個指針變量，基類型為void（空類型），不指向具體的對象

指針運算

1、指針變量加或者減一個整數；
2、指針變量賦值；
3、兩個指針變量可以相減；（相加則無意義）
4、兩個指針變量比較；（兩個指針指向同一個數組的元素）
5、指針變量可以有空值；（該指針變量不指向任何變量，在引用指針變量之前應對它賦值）。

指針的優點
①提高程序效率；
②在調用函數時當指針指向的變量的值改變時，這些值能夠為主調函數使用，即可以從函數調用得到多個可以改變的值；
③可以實現動態存儲分配。

第九章 用戶自己建立數據類型

一、結構體

1、定義

為了體現出某些數據的內在聯系，將數據組成一個組合數據，可稱為結構體。（C語言允許用戶自己建立有不同類型的數據組成的組合型的數據結構）。
用戶可在程序中自己建立一個結構體類型，類似struct student。
結構體一般形式為：

struct 結構體名 {成員表列}；

結構體類型的名字是由一個關鍵字struct和結構體名組合而成的。
結構體名是由用戶指定的，又稱**“結構體標記”**。

2、定義結構體類型的變量

1、先聲明結構體類型，再定義該類型的變量；

struct Student s1,s2;

2、在聲明類型的同時定義變量；

struct 結構體名 {成員表列 }變量名表列;

3、不指定類型名二直接定義結構體類型變量

struct {成員表列 }變量名表列;

①結構體類型與結構體變量是不同的的概念，只能對變量進行賦值、存取或運算，不能對一個類型賦值、存取或運算。在編譯的時候，對類型是不分配存儲空間的，只對變量分配空間；
②結構體類型中的成員名可以與程序中的變量名相同，但二者不代表同一對象；
③對結構體變量中的成員 （即“域”），可以單獨使用，它的作用與地位相當于普通變量。

3、結構體變量的初始化和引用

在定義結構體變量的時候，可以對它進行初始化，即賦初值，然后可以引用這個變量。
①在定義結構體便來哪個是可以對它的成員進行初始化

struct Student b={.name="zhang fang"};//“.”是成員運算符意為:b.name

②可以引用結構體變量中成員的值，方法為：結構體變量名.成員名。“.”是成員運算符，其優先級最高；
③如果成員本身又屬于一個結構體類型，則要用若干個成員運算符，一級一級的找到最低一級的成員，且只能對最低一級的成員進行賦值或存取以及運算；
④對結構體變量的成員可以像普通變量一樣進行各種運算；
⑤同類的結構體變量可以互相賦值；
⑥可以引用結構體變量成員的地址，也可以引用結構體變量的地址

4、結構體數組

結構體數組與數值型數組的不同之處在于，結構體數組的每個元素都是一個結構體類型的數據，它們都包含著結構體每一項的成員；
定義結構體數組的一般形式為：
①struct 結構體名
{成員表列}數組名[數組長度];
②結構體類型 數組名[數組長度]；

#include <stdio.h> #include <string.h>struct student{int num;char name[20];float score;}; int main(){void sq(student a[5]); student p[5]={{10101,"zhang",78.0},{10103,"wang",98.5},{10106,"li",86.0},{10108,"ling",73.5},{10110,"sun",100.0}};sq(p);return 0; }void sq(student a[5]){a[0].num=10101;strcpy(a[0].name,"ling");a[0].score=23;student temp;//臨時變量也需要定義為結構體類型const int n=5;int i,j,k;printf("The order is:\n");for(i=0;i<n-1;i++){k=i;for(j=i+1;j<n;j++)if(a[j].score>a[k].score)k=j;temp=a[k];a[k]=a[i];a[j]=temp; }for(i=0;i<n;i++)printf("%6d %8s %6.2f\n",a[i].num,a[i].name,a[i].score);printf("\n"); } //簡單編寫的一個結構體的運用！

5、結構體指針

所謂結構體指針就是指向結構體變量的指針，一個結構體變量的起始地址就是這個結構體變量的指針；
即：如果將一個結構體變量的起始地址存放在一個指針變量中，那么這個指針變量就指向該結構體變量；
指向結構體對象的指針變量即可指向結構體變量，也可指向結構體數組中的元素。指針變量的基類型必須與結構體變量的類型相同。
如：(*p).num; 或者 p->num;
(*p)表示p指向的結構體變量，(*p).num是p所指向的結構體變量中的成員num。*p兩側的括號不能省略，因為"."的優先級最高，若省略則為*p.num就等價于*(p.num)了。

將一個結構體變量的值傳遞給另一個函數，有三個辦法：
①用結構體變量的成員做參數；
②用結構體變量作實參；
③用指向結構體變量（或數組元素）的指針作實參。
->大家若還有疑惑可以看看我這一篇詳細寫的<-

二、共用體

1、定義

一般形式為： union 共用體名 {成員列表 }變量表列；

2、區別

共用體和結構體的區別：
結構體變量所占內存長度是各成員占的內存長度之和，每個成員分別占有其自己的內存單元；
而共用體變量所占的內存長度等于最長的成員的長度。

3、特點

①同一個內存段可用來存放幾種不同類型的成員，但在每一瞬間只能存放其中一個成員，而不是同時存放幾個。

#include <stdio.h> union Date{ int i; char ch; float f; }a;int main(){a.i=97;printf("a.i=%d\n",a.i);printf("a.ch=%c\n",a.ch);printf("a.f=%f\n",a.f);return 0; }

②可以對共用體變量初始化，但初始化表中只能有一個常量。

union Date{ int i; char ch; float f; }a={1,'d',2.3};//錯誤，不能初始化三個成員 union Data a={16};//正確，對第一個成員進行初始化 union Data a={.ch='j'};//C99可以對指定的成員進行初始化，但我使用的是C-free該運行出現錯誤

正確如下所示

#include <stdio.h> union Date{ int i; char ch; float f; };union Date a={99};int main(){printf("a.i=%d\n",a.i);printf("a.ch=%c\n",a.ch);printf("a.f=%f\n",a.f);return 0; }

③共用體變量中起作用的成員是最后一次被賦值的成員，在對共用體變量中的一個成員賦值后，原有變量存儲單元中的值就取代；
④共用體變量的地址和它的各成員的地址都是同一地址；
⑤不能對共用體變量名賦值，也不能企圖引用變量名來得到一個值；
⑥以前的C規定不能把共用體變量作為函數參數，但可以使用指向共用體變量的指針作函數參數，C99允許用共用體變量作為函數參數；
⑦共用體類型可以出現在結構體類型的定義中，也可以定義共用體數組。

三、枚舉類型

1、定義

如果一個變量只有幾種可能的值，則可以定義為枚舉類型，所謂“枚舉”就是把可能的值一一列舉出來，變量的值只限于列舉出來的值的范圍內，聲明枚舉類型用enum開頭。

enum Week{sun,mon,tue,wed.thu,fri,sat}; Wk=mon;//指定枚舉常量之一賦值給Wk；

week被定義為枚舉變量，sun,mon…,sat被稱為枚舉元素或枚舉常量。

2、要點

①C編譯對枚舉類型的枚舉元素按常量處理，故稱枚舉常量。
②每一個枚舉元素都代表一個整數，C編譯按定義時的順序默認它們的值為0,1,2,3,4,5,6,…
③枚舉元素可以用來做判斷表示，即if(wk>=mon)…

四、用typedef聲明新類型名

1、簡單地用一個新的類型名代替原有的類型名；

typedef int Integer;

2、命名一個簡單的類型名代替復雜的類型表示方法：
①可命名一個新的類型名代表結構體類型：

typedef struct { int m; int d; int y; }date;

②可命名一個新的類型名代表數組類型；

typedef int N[100]; N a;

③可命名一個新的類型名代表指針類型；

typedef char * S; S p,s[10];

④可命名一個新的類型名代表指向函數的指針類型；

typedef int (*p)(); p p1,p2;

總結：按定義變量的方式，把變量名換上新類型名，并且在最前面加typedef，就聲明了新類型名代表原來的類型；

typedef和#define的區別

#define是在預編譯時處理的，它只能做簡單的字符串替換
而typedef是在編譯階段處理的，它并非是簡單的字符串替換，例如

typedef int Num[10];//采用的是融通定義變量的方法那樣先生成一個類型名，然后去定義變量。 Num a;

第十章 C語言文件的讀寫

關于細節幾部分，我就不仔細介紹了，首先，我只想說說關于C語言中的文件讀寫時一般常用的文件的讀寫函數的記載：

fgetc()函數和fputc()函數：字符的讀寫函數；
fgets()函數和fputs()函數：字符串的讀寫函數；
fread()函數和fwrite()函數：數據塊的讀寫函數，主要針對二進制文件；
fscanf()函數和fprintf()函數：格式化的讀寫函數，主要針對文本文件。
文件隨機讀寫函數：fseek()函數、rewind()函數和ftell()函數

下面，我來講講這些函數的格式，即使用說明：

一、字符讀寫

1、fputc()函數；

格式：fputc(c,fp);

功能：用來將一個字符寫入到文件中。

在格式中fp是已經定義的文件指針變量；c為要寫入的字符，可以是字符常量或字符型變量，該函數是有返回值的。
返回值：如果執行成功，返回寫入的字符；否則，返回EOF，（EOF是C語言編譯系統定義的文本文件結束標志，其值為-1，十六進制表示為0xff，在stdio.h中定義），表示寫操作失敗。

這里也可以用putc()函數來實現字符寫功能，與fputc()完全等價，調用格式：putc(c,fp);

//例如： #include <stdio.h> #include <stdlib.h> void main(){FILE *fp;char c[80],*pt=c;if((fp=fopen("c:\\1\\wenjiu1.txt","w"))==NULL){printf("Cannot open the file,strike any key to exit!\n");getchar();exit(0);}printf("Input a string:\n");for(int i=1;i<=6;i++){gets(pt);while(*pt!='\0'){fputc(*pt,fp);pt++;}fputc('\n',fp);}fclose(fp); }

2、fgetc()函數

格式： c=fgetc(fp);

功能：用來從指定的文本文件中讀取一個字符。

其中，fp為文件指針，c為要寫入的字符。該函數的功能是從指定的文件中讀取一個字符，并賦值給字符型變量c。
返回值：讀取成功返回讀取字符，讀取錯誤或遇到結束標志EOF，返回EOF。

*同上也可以用**getc()**函數來實現，與fgetc()完全等價，格式：getc(ch,fp); *

//fgetc();輸入的第一行第一個字符會出現亂碼問題，應該是我用的VC6.0版本問題 #include <stdio.h> #include <stdlib.h> void main(){FILE *fp;char c;if((fp=fopen("c:\\1\\wenjiu2.txt","r"))==NULL){printf("Cannot open the file,strike any key to exit!\n");getchar();exit(0);}while(c!=EOF){putchar(c);c=fgetc(fp);}fclose(fp); }

三、字符串讀寫

1、fputs()函數

格式：fputs(s,fp);

功能：用來將一個字符串寫入指定的文本文件。

其中，fp為文件指針，s可以是字符數組名，字符型指針變量或字符串常量。該函數的功能是將字符串s寫入由fp指向的文件中，字符串末尾的‘\0’字符不允寫入。

返回值：執行成功，返回所寫的最后一個字符；否則，返回EOF。

//fputs#include <stdio.h> #include <stdlib.h> void main(){FILE *fp;char s[][15]={"BeiJing","ShangHai","GuangZhou","NanJing","HangZhou"};if((fp=fopen("c:\\1\\wenjiu3.txt","w"))==NULL)/*只能相應文件，創建不了文件夾，fopen()函數會尋找相應位置文件夾然后在其中創建所需文件。當沒有所需文件夾的時候，系統會自動跳轉到NULL!*/{printf("Cannot open the file,strike any key to exit!\n");getchar();exit(0);}for(int i=0;i<6;i++){fputs(s[i],fp);fputs("\n",fp);}fclose(fp); }//輸出在文件中的第六行，會出現“'jb”這個字符串

2、fgets()函數

格式：fgets(s,n,fp);

功能：用于從指定的文件中讀一個字符串到字符數組中。

其中，s可以是字符型數組名或字符串指針,n是指定讀入的字符個數；fp為文件指針。n是一個正整數，表示從文件中最多讀取n-1個字符，并將字符串指針s定位在讀入的字符串首地址。fgets()函數從文件中讀取字符直到遇到回車符或EOF為止，函數會在最后一個字符后加上字符串結束標志’\0’；若有EOF，則不予保留。

返回值：該函數如果執行成功，返回讀取字符串；如果失敗，則返回空指針NULL，這時，s中的內容不確定。

//fgets()函數#include <stdio.h> #include <stdlib.h> void main(){FILE *fp;char s[6][15];if((fp=fopen("c:\\1\\wenjiu3.txt","r"))==NULL){printf("Cannot open the file,strike any key to exit!\n");getchar();exit(0);}for(int i=0;i<6;i++){fgets(s[i],15,fp);if(i%2==0)printf("%s",s[i]);}fclose(fp); }

二、數據塊讀寫

1、 fread()數據塊讀函數

格式：fread(char *ps,int len,int n,FILE *fp);

功能：用來指定文件中一次讀取由若干個數據項組成的一個數據塊，存放到指定的內存緩存區中，數據塊的大小取決于數據塊中數據項大小（字節數）和數據項的個數。

其中ps是用來指向存放數據塊內存緩沖區的首地址，len是用來指出數據塊中數據項的大小的整型數，fp是一個指向被操作 文件的指針。fread()函數一次讀取數據塊的大小等于len與n的乘積。
舉例：要從fp指針所指向的文件中一次讀取500個整數，存放到內存的buf緩存中，可以用下列語句實現這一功能：
fread(buf,sizeof(int),500,fp);

返回值：該函數正常返回值實際讀取的數據項數，出錯時返回NULL。

2、fwrite()數據塊寫函數

格式：fwrite(char *ps,int len,int n,FILE *fp);

功能：fwrite()函數用來將指定的內存緩沖區的數據塊內的數據項寫入指定的文件中。所寫入的數據塊的大小是由數據項的大小和數據項個數決定的。

其中的參數同fread()函數類似。

返回值：該函數參數與fread()函數返回參數相同，函數正常返回值是實際寫入文件中的數據項個數。

//fread() AND fwrite()#include <stdio.h> #include <stdlib.h> struct student{char name[10];int ID;int score; };void main(){struct student a[4],b[4],*pa,*pb;FILE *fp;pa=a;pb=b;if((fp=fopen("c:\\1\\wenjiu4.txt","wb+"))==NULL){printf("Cannot open the file,strike any key to exit!\n");getchar();exit(0);}printf("\nInput date\n");for(int i=0;i<3;i++,pa++)scanf("%s%d%d",&pa->name,&pa->ID,&pa->score);pa=a;fwrite(pa,sizeof(struct student),3,fp);rewind(fp);//內部位置指針移動到文件首位!fread(pb,sizeof(struct student),3,fp);printf("\n\nname ID score \n");for(i=0;i<3;i++,pb++)printf("%-10s %-6s %-5d\n",pb->name,pb->ID,pb->score);fclose(fp); }

三、格式化讀寫

1、fprintf()函數

格式：fprintf(fp, format, arg1, arg2,…,argn);

功能：fprintf()用來將輸出項按指定的格式寫入指定的文本文件中，其中格式化規定與printf()函數功能相似，所不同的只是fprintf()函數是將輸出的內容寫入文件中，而printf()函數則是在屏幕輸出。

其中，fp為文件指針，format為指定的格式控制字符串；arg1~argn為輸出項，可以是字符、 字符串或各種類型的數值。該函數的功能是按格式控制字符串format給定的格式，將輸出項arg1,arg2,…,argn的值寫入fp所指向的文件中。

返回值：如果函數執行成功，返回實際寫入文件的字符個數；若出現錯誤，返回負數。

fprintf()中格式控制的使用與printf()相同。
例如：fprintf(fp,“r=%f,area=%f\n”,r,area);

//fprintf()函數#include <stdio.h> #include <stdlib.h> void main(){FILE *fp;int data[1000];for(int i=0;i<1000;i++)data[i]=(rand()%1000);//產生0~999的隨機整數if((fp=fopen("c:\\1\\wenjiu5.txt","w"))==NULL){printf("Cannot open the file,strike any key to exit!\n");getchar();exit(0);}for(i=0;i<1000;i++){if(i%20==0)fprintf(fp,"\n%5d",data[i]);elsefprintf(fp,",%5d",data[i]);if((i+1)%20==0)fprintf(fp,"\n");}fclose(fp);}

2、fscanf()函數

格式：fscanf(fp,format,arg1,arg2,…,argn);

功能：fscanf()用來按規定的格式從指定的文本文件中讀取數據。它與scanf()函數的功能相似，都是按規定的格式讀數據的函數，只是fscanf()函數讀的對象不是鍵盤區，而是文件。

其中，fp為文件指針，format為指定的格式控制字符串；arg1~argn為輸入項的地址。該函數的功能是從文件指針fp所指的文本文件中讀取數據，按格式控制字符串format給定的格式賦予輸入項arg1,arg2,…,argn中。

返回值：如果該函數執行成功，返回讀取項目個數；如果遇到文件末尾，返回EOF;如果賦值失敗，返回0.

fscanf()中格式控制的使用與scanf()相同。
例如：fprintf(fp,"%d,%d\n",&a,&b);

//fscanf()函數#include <stdio.h> #include <stdlib.h> void main(){FILE *fp;int data[1000];if((fp=fopen("c:\\1\\wenjiu5.txt","r+"))==NULL){printf("Cannot open the file,strike any key to exit!\n");getchar();exit(0);}for(int i=0;i<1000;i++){if(i%20==0)fscanf(fp,"\n%5d",&data[i]);elsefscanf(fp,",%5d",&data[i]);}fseek(fp,0,SEEK_END);fprintf(fp,"\n\n");int j=0;for(i=0;i<1000;i++){{if(data[i]%7==0){if(j%20==0)fprintf(fp,"%5d",data[i]);if((j+1)%20==0) fprintf(fp,"\n");j++;}}fclose(fp);} }

打完收工！

歷時一個多月，一個字一個字給敲上去的，里面融入了我自己的思考，當然很多權威性的解釋還是沿用了書本上的，畢竟咱還是很知道天高地厚的。大家可以把這篇文章當個梳理思路的文章過一過，這里面也有很多漏洞存在，我會在后期一一完善和補充的，也希望大家發現什么不足留個言，感謝大家支持！！！
整本書知識點很多，有很多概念前后都重復介紹過好幾遍，很適合新手閱讀，當然也存在一定的深度！

總結

以上是生活随笔為你收集整理的C语言程序设计知识点总结归纳（全书）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。