《高質量嵌入式Linux C編程（第2版）》是2019年9月電子工業出版社出版的圖書，作者是梁庚、陳明、魏峰。
基本介紹
- 書名：高質量嵌入式Linux C編程（第2版）
- 作者：梁庚、陳明、魏峰
- 出版社：電子工業出版社
- 出版時間：2019年9月
- 頁數：426 頁
- 定價：78 元
- 開本：16 開
- ISBN：9787121373404
內容簡介,目錄,
內容簡介
本書從嵌入式開發角度出發，以Linux作業系統為開發平台，將隱藏在系統開發背後的關於C語言、數據結構與算法、計算機組成原理、計算機作業系統、資料庫原理等方面的機制和知識娓娓道來，不僅讓讀者知其然，更要讓讀者知其所以然，並讓這些知識再反作用於編程實踐，從而幫助讀者寫出高質量的嵌入式Linux C代碼，揭開嵌入式Linux C系統開發背後鮮為人知的秘密。
目錄
第 1 章 嵌入式Linux C 語言開發工具··········································································（1）
1.1 嵌入式Linux C 語言開發概述·················································································（1）
1.2 嵌入式Linux C 開發環境·······················································································（2）
1.3 嵌入式文本編輯器··························································································（2）
1.3.1 基本模式································································································. （3）
1.3.2 基本操作··································································································（3）
1.3.3 實訓操作··································································································（5）
1.4 嵌入式編譯器······································································································（6）
1.4.1 初識GCC 編譯器························································································（6）
1.4.2 gcc 命令常用選項和工作流程·········································································（6）
1.4.3 庫的使用·······························································································.（10）
1.5 嵌入式調試器···································································································.（12）
1.6 工程管理器······································································································.（15）
1.6.1 Makefile·································································································.（16）
1.6.2 Makefile 特性介紹····················································································.（18）
1.7 Eclipse 程式開發·······························································································.（27）
1.7.1 Eclipse 環境安裝······················································································.（27）
1.7.2 Eclipse C 程式開發···················································································.（29）
1.8 軟體版本管理···································································································.（34）
1.8.1 Git 版本管理···························································································.（34）
1.8.2 Ubuntu 軟體包管理···················································································.（45）
第 2 章 數據類型··································································································.（48）
2.1 變數與常量······································································································.（48）
2.2 變數···············································································································.（48）
2.2.1 什麼是變數····························································································.（48）
2.2.2 變數名和變數值······················································································.（49）
2.2.3 局部變數和全局變數················································································.（51）
2.3 常量···············································································································.（53）
2.4 基本內置類型···································································································.（54）
2.4.1 數據類型及其大小···················································································.（55）
2.4.2 陷阱——有符號與無符號·············································································.（55）
2.5 聲明與定義······································································································.（56）
2.5.1 定義·····································································································.（56）
2.5.2 聲明·····································································································.（57）
2.6 static 與extern····················································································.（57）
2.6.1 static ························································································.（57）
2.6.2 extern ······································································.·······.·······.（59）
2.7 const ··································································································.（60）
2.8 auto·································································································.（61）
2.9 register·····························································································.（62）
2.10 volatile ···························································································.（63）
2.11 typedef 詳解····································································································.（64）
2.11.1 typedef 與結構的問題··············································································.（64）
2.11.2 typedef 與#define 的問題··········································································.（66）
2.11.3 typedef 與#define 的另一例·······································································.（67）
2.11.4 typedef 與複雜的變數聲明········································································.（67）
2.12 枚舉（enum）·································································································.（68）
2.12.1 枚舉類型的使用方法···············································································.（68）
2.12.2 枚舉與#define 宏的區別··········································································.（69）
2.13 聯合體··········································································································.（69）
2.13.1 聯合體的定義························································································.（69）
2.13.2 從兩道經典試題談聯合體（union）的使用···················································.（70）
第 3 章 運算符和表達式·····················································································（73）
3.1 運算符簡介································································································.（73）
3.1.1 運算符優先權·························································································.（73）
3.1.2 一些容易出錯的優先權問題·······································································.（75）
3.1.3 邏輯運算符····························································································.（76）
3.2 條件運算符和條件表達式····················································································.（76）
3.3 ++、--操作符···································································································.（77）
3.4 位運算············································································································.（78）
3.4.1 按位與運算及套用···················································································.（78）
3.4.2 按位或運算及套用···················································································.（79）
3.4.3 按位異或運算及套用················································································.（79）
3.4.4 左移和右移····························································································.（79）
3.5 C 語言性能最佳化：使用位操作········································································.（79）
第 4 章 語句···································································································.（81）
4.1 空語句·······································································································.（81）
4.2 基礎語句···································································································.（82）
4.2.1 表達式語句····························································································. （82）
4.2.2 函式調用語句·························································································.（82）
4.3 if 語句······································································································.（82）
4.3.1 布爾變數與零值的比較·············································································.（83）
4.3.2 整型變數與零值比較················································································.（83）
4.3.3 浮點變數與零值的比較·············································································.（83）
4.3.4 指針變數與零值的比較·············································································.（84）
4.3.5 對if 語句的補充說明················································································.（84）
4.4 跳轉語句：goto ································································································.（85）
4.5 循環語句·········································································································.（85）
4.5.1 do-while 語句··························································································.（86）
4.5.2 for 語句·································································································.（86）
4.5.3 循環語句的效率······················································································.（88）
4.6 break 和continue ·······················································································.（89）
4.6.1 break 語句······························································································.（89）
4.6.2 continue 語句··························································································.（90）
4.7 switch 語句·································································································.（91）
第 5 章 數組與指針···························································································.（92）
5.1 數組認知·····································································································.（92）
5.2 使用數組的常見問題······················································································.（93）
5.2.1 數組的下標總是從0 開始嗎··························································. ············.（93）
5.2.2 可以使用數組後面第一個元素的地址嗎···············································. ········.（94）
5.2.3 為什麼要小心對待位於數組後面的那些元素的地址呢··········································.（95）
5.2.4 當數組作為參數傳遞給函式時，可以通過sizeof 得到數組的大小嗎························.（95）
5.2.5 指針或帶下標的數組名都可以訪問元素，哪一種更好呢···································.····（96）
5.2.6 可以把另外一個地址賦給一個數組名嗎·····························································（98）
5.2.7 array_name 和&array_name 有什麼不同·························································.（99）
5.2.8 為什麼用const 說明的常量不能用來定義一個數組的初始大小····························（100）
5.2.9 字元串和數組有什麼不同··········································································（100）
5.3 指針···············································································································（102）
5.3.1 指針是變數····························································································（103）
5.3.2 指針的類型和指針所指向的類型·································································（103）
5.3.3 指針的值·······························································································（104）
5.3.4 指針本身所占據的記憶體·············································································（105）
5.4 指針的運算······································································································（105）
5.4.1 指針的算術運算······················································································（105）
5.4.2 指針的關係運算······················································································（106）
5.4.3 間接引用·······························································································（106）
5.4.4 最多可以使用幾層指針·············································································（106）
5.5 常量指針和指針常量··························································································（108）
5.5.1 常量指針與指針常量的實例·······································································（108）
5.5.2 常量指針的套用······················································································（109）
5.6 空指針及其使用································································································（110）
5.6.1 NULL 總是被定義為0 嗎···········································································（110）
5.6.2 NULL 總是等於0 嗎·················································································（110）
5.6.3 空指針的使用·························································································（111）
5.7 void 指針：萬能指針··························································································（113）
5.8 指針數組與數組指針··························································································（114）
5.9 字元串函式詳解································································································（114）
5.10 函式指針與指針函式························································································（119）
5.11 複雜指針聲明：“int * (* (*fp1) (int) ) [10];” ···························································（120）
5.11.1 基礎····································································································（120）
5.11.2 const 修飾符··························································································（121）
5.11.3 typedef 的妙用·······················································································（122）
5.11.4 函式指針······························································································（123）
5.11.5 右左法則······························································································（123）
第 6 章 記憶體管理································································································（125）
6.1 數據放在哪裡···································································································（125）
6.1.1 未初始化的全局變數（.bss 段） ··································································（125）
6.1.2 初始化過的全局變數（.data 段） ·································································（126）
6.1.3 常量數據（.rodata 段） ·············································································（126）
6.1.4 代碼（.text 段） ······················································································（127）
6.1.5 棧（stack） ····························································································（127）
6.1.6 堆（heap）·····························································································（127）
6.2 記憶體分配方式···································································································（128）
6.3 野指針············································································································（129）
6.4 常見的記憶體錯誤及對策·······················································································（129）
6.5 段錯誤及其調試方法··························································································（130）
6.5.1 方法一：利用gdb 逐步查找段錯誤······························································（131）
6.5.2 方法二：分析core 檔案·············································································（131）
6.5.3 方法三：在發生段錯誤時啟動調試······························································（132）
6.5.4 方法四：利用backtrace 和objdump 進行分析·················································（134）
6.6 指針與數組的對比·····························································································（135）
第 7 章 預處理和結構體···························································································（138）
7.1 宏定義：#define································································································（138）
7.1.1 無參宏定義····························································································（138）
7.1.2 帶參宏定義····························································································（140）
7.2 檔案包含·········································································································（141）
7.3 條件編譯·········································································································（142）
7.4 宏定義的使用技巧·····························································································（144）
7.5 關於#和## ·······································································································（146）
7.6 結構體（struct） ·······························································································（147）
7.6.1 記憶體位元組對齊·························································································（149）
7.6.2 記憶體對齊的正式原則················································································（152）
7.7 #define 和typedef 的區別·····················································································（152）
7.8 結構體（struct）和聯合體（union）的區別·····························································（153）
7.9 淺談C 語言中的位段·························································································（153）
7.9.1 位段的使用····························································································（154）
7.9.2 位段結構在記憶體中的存儲方式····································································（154）
第 8 章 函式········································································································（155）
8.1 函式聲明與定義································································································（155）
8.1.1 定義·····································································································（155）
8.1.2 聲明與定義不同······················································································（156）
8.2 形式參數和實際參數··························································································（157）
8.3 參數傳遞·········································································································（157）
8.3.1 簡單變數或數組元素作為函式參數······························································（157）
8.3.2 指針變數或數組名作為函式參數·································································（158）
8.3.3 數組名作為函式參數················································································（159）
8.3.4 結構體數組作為函式參數··········································································（160）
8.4 如何編寫有多個返回值的C 語言函式····································································（160）
8.4.1 利用全局變數·························································································（161）
8.4.2 傳遞數組指針·························································································（162）
8.4.3 傳遞結構體指針······················································································（162）
8.5 回調函式·········································································································（163）
8.6 變參函式詳解：printf 函式的實現·········································································（165）
8.7 可變參數的相關問題··························································································（166）
第 9 章 編碼規範··································································································（170）
9.1 排版···············································································································（170）
9.2 注釋···············································································································（173）
9.3 標示符名稱······································································································（178）
第 10 章 shell 編程································································································（181）
10.1 什麼是shell ····································································································（181）
10.2 幾種流行的shell ······························································································（181）
10.3 shell 程式設計（基礎部分） ···········································································（182）
10.3.1 shell 的基本語法·····················································································（182）
10.3.2 shell 程式的變數和參數············································································（183）
10.4 shell 程式設計的流程控制··················································································（185）
10.4.1 test 命令·······························································································（185）
10.4.2 if 條件語句···························································································（186）
10.4.3 for 循環································································································（187）
10.4.4 while 和until 循環···················································································（187）
10.4.5 case 條件選擇························································································（189）
10.4.6 無條件控制語句break 和continue·······························································（189）
10.4.7 函式定義······························································································（189）
10.5 命令分組·······································································································（190）
10.6 用trap 命令捕捉信號························································································（190）
10.7 運行shell 程式的方法·······················································································（191）
10.8 bash 程式的調試······························································································（191）
10.9 bash 的內部命令······························································································（192）
第 11 章 檔案操作·································································································（194）
11.1 Linux 檔案結構·······························································································（194）
11.1.1 Linux 檔案系統······················································································（194）
11.1.2 Linux 目錄結構······················································································（195）
11.1.3 Linux 檔案分類······················································································（197）
11.1.4 常見的檔案類型·····················································································（198）
11.1.5 Linux 檔案屬性······················································································（198）
11.2 系統調用·······································································································（198）
11.3 Linux 檔案描述符····························································································（199）
11.4 不帶快取的I/O 操作·························································································（200）
11.4.1 creat 函式·····························································································（200）
11.4.2 open 函式·····························································································（201）
11.4.3 read 函式······························································································（203）
11.4.4 write 函式·····························································································（204）
11.4.5 lseek 函式·····························································································（204）
11.4.6 close 函式·····························································································（205）
11.4.7 經典範例：檔案複製···············································································（205）
11.5 帶快取的I/O 操作····························································································（207）
11.5.1 3 種類型的緩衝······················································································（207）
11.5.2 fopen 函式····························································································（209）
11.5.3 fclose 函式····························································································（209）
11.5.4 fdopen 函式···························································································（210）
11.5.5 fread 函式·····························································································（210）
11.5.6 fwrite 函式····························································································（211）
11.5.7 fseek 函式·····························································································（212）
11.5.8 fgetc 函式、getc 函式和getchar 函式···························································（213）
11.5.9 fputc 函式、putc 函式和putchar 函式···························································（214）
11.6 fgets 函式與gets 函式的比較分析········································································（215）
11.7 輸出與輸入····································································································（217）
11.7.1 printf 函式、fprintf 函式和sprintf 函式·························································（217）
11.7.2 scanf 函式、fcanf 函式和sscanf 函式···························································（220）
第12 章 進程控制編程·····························································································（222）
12.1 為何需要多進程（或者多執行緒），為何需要並發····················································（222）
12.1.1 進程····································································································（222）
12.1.2 進程分類······························································································（223）
12.1.3 進程的屬性···························································································（223）
12.1.4 父進程和子進程·····················································································（223）
12.2 Linux 進程管理·······························································································（224）
12.2.1 ps 監視進程工具·····················································································（224）
