嵌入式LInux之C語言提升篇---Skr Skr Up Up
阿新 • • 發佈：2018-10-15
任務 開發者 三目運算 關鍵字const 此外 mat 庫函數 linu 限制
預處理的使用
#include 包含頭文件 使編譯程序將另一源文件嵌入到帶#include 的源文件中
#define 宏定義 （替換）
#define 宏名 宏體 （不進行語法檢查）
#define ABC 3+5
printf("the %d\n",ABC*5); ----?
#define ABC (3+5) ---?
#define ABC(x) (5+(x))
#undef 撤銷已定義過的宏名
條件編譯 003.c
#if #if的一般含義是如果#if後面的表達式為TRUE（真)
則編譯它與#endif之間的代碼，否則跳過這些代碼。
#elif 命令#elif 類似於 else if 形成一個if else-if 階梯狀語句
可進行多種編譯選擇
#endif 命令#endif 標識 一個#if塊的結束
#ifdef 如果有定義執行編譯代碼
#ifndef 如果沒有定義執行編譯代碼
可以使用GCC 編譯選項添加預處理宏定義
gcc -D[宏名] 不需要空格
其他
#line 改變當前的行號和文件名，他們是在編譯中預處理定義的標識符
#line number["filename"]
#error 編譯程序時，只要遇到 #error 就會產生一個編譯錯誤提示信息 ，並停止編譯
#error 錯誤信息
#pragma 為實現時定義的命令，它允許向編譯程序傳送各種指令
編譯程序可能有一種選擇，它支持對程序執行的追蹤。
預定義宏
__FUNCTION__: 函數名
__LINE__ ：行號
__FILE__ : 文件名
__DATA__ : 表示編譯時刻的日期字符串，“25 Dec 2018”
__TIME__ : 表示編譯時刻的時間字符串, "12:30:44"
宏展開下的 # ## 004.c
# 字符串化
## 連接符號
C 語言關鍵字 32 個
關鍵字：編譯器 預先定義好的有一定意義的 字符串
雜項：
sizeof：計算對象所占內存大小 sizeof(xxx) --不是函數--
編譯器給我們查看內存容量的一個工具
return：子程序返回語句（可以帶參數，也可不帶參數）
用於終止一個函數並返回其後面跟著的值
用法： return （Val）
-規則-
：return語句不能返回指向“棧內存”的“指針”，因為該內存在函數體結束時被自動銷毀
例子：
char *func(void){
char str[30];
.
...
return str;
}
數據類型：
C語言操作的對象---> 資源/內存
資源的屬性【大小】---> 數據類型--->”尺子“
char
硬件芯片操作的最小單位： bit 1 / 0 位
軟件操作的最小單位： 8bit == 1 Byte 4M --> 4Mbit Kbit/s KB/s
char = 1Byte = 8bit == 2^8 = 256
==================================================================
int
編譯器最優處理大小：
系統一個周期，所能接受的最大處理單元，int 32位
int = 4Byte = 4*8bit = 32bit == 2^32 (與編譯器有關)
short = 2Byte = 16bit
long = 4Byte = 32bit
unsigned 聲明無符號類型變量
signed 聲明有符號類型變量
int a ---展開--- signed int
區別：內存空間的最高是符號位還是數據
有符號： 數字
無符號： 數據 （采集數據）
區別 ：
char a = -1; 0xff;
a>>1
unsigned char b = 0xff;
b>>1;
==================================================================
浮點數
float：聲明浮點型數據 4Byte = 32bit
double：聲明雙精度變量 8Byte = 64bit
浮點型常量
1.0f
=================================================================
void 空類型 用於占位 到時候強制轉換
===================================================================
自定義數據類型
struct :聲明結構體變量
元素之間的集合
struct myabc{
unsigned int a;
unsigned int b;
unsigned int c;
unsigned int d;
}; -------->這裏只是告訴編譯器，有定義該結構體的能力（聲明）；
struct myabc mybuf;劃分內存 (定義)；
順序有要求
-----------------
| | |——|———————————————|
|---------------| ----》|--|---------------|
|---------------|
|---------------|
(結構體內存模型) (共用體內存模型)
union 聲明聯合數據類型
共用起始地址的一段內存（占用的內存為最大數據類型，但是指定好後就是指定數據類型）
技巧型代碼
union myabc{
char a;
int b;
}; (聲明)
union myabc abcbuf;
enum:聲明枚舉類型 【人和人交流限制】
enumerate 一一列舉
用法
enum [枚舉名稱]{常量列表};
typedef:用以給數據類型取別名
int a ; a是一個int 類型的變量
typedef int a ; a是一個int 類型的外號（聲明 沒有申請內存）
------------------------------------------------------------------------------------------------
邏輯結構：改變程序執行的方式 （提高邏輯思維）
CPU 順序執行程序
分支 ---> 選擇
循環 ---> 重復
條件：
if（條件表達式）
xxxx
else
xxxx
if 使用規制：
先處理正常情況，在處理異常情況；
理解：
if(NULL != p);
func();
和：if（NULL ！= p）
func();
多分支 switch case default
switch(整形數字)
case :
break
default
使用規則：
1.每一個case語句的結尾絕對不要忘記加break，否則將導致多個分支重疊（除非有意為止）
2.最後必須使用default分支，即使程序真的不需要default處理，也要保留。
3.case後面只能是整型或者字符型的常量或者常量表達式。
================================================================================================
do while for
for 次數
while 條件 先判斷while後面括號的值，如果是真則執行其後面的代碼，否則不執行；
while(0)
{
printf("0\n");
break;
}
while(-1){
printf("-1");
break;
}
while(1)
{
printf("1\n")
break;
}
do (先執行在判斷)
while
continue break goto
continue :終止本次循環（本輪循環）
break :終止本層循環（消除一次循環體）
===============================================================================================
類型修飾符
對內存資源存放位置的限定
資源屬性【位置的限定】
資源位置：
auto: 聲明自動變量 默認情況 --- > 分配的內存是可讀可寫的區域 （區域如果在{ }裏面，就是棧空間內）
register: 限制變量定義在寄存器上的修飾 內存（存儲器） 寄存器 定義一些快速訪問的變量
（編譯器會盡量安排CPU的寄存器去存放這個值，&對register不起作用）
使用規則：register變量必須是能被CPU寄存器所接受的類型。
static:
靜態
應用場景：
1.函數內部的變量
int fun()
{
int a ===> static int a
}
2.函數外部的變量
int a ===> static int a
int fun()
{
}
3.修飾函數
int fun() === > static int fun();
const: 常量的定義 修飾只讀變量
extern: 外部申明
volatile:告知編譯器編譯方法的關鍵字，不優化編譯 給硬件打交道
修飾的變量的值的修改，不僅僅可以通過軟件，也可以通過其他方式（硬件外部的用戶）
----------------------------------------------------------------------------------------------
運算符
算術操作運算符
+ 加
- 減
* 乘
/ 除
% 求余數 n%m = res [0 ~ m-1]
應用場景：
1.取一個範圍的數
2.得到M進制的個位數
3.得到循環數據結構的下標
==============================================================================================
邏輯運算
真 假
返回結果 1（真） 0 （假）
|| 邏輯或 有一真即可
&& 邏輯與 都真才為真
> 大於
< 小於
>= 大於等於
<= 小於等於
! 不等於
? : 三目運算
=============================================================================================
位運算符
1. 移位操作 (註意：數據 與數字 操作是不同的)
<< 左移位 乘法 *2 （2進制下的移位） m<<n == m*2^n
>> 右移位
& 按位與
應用場景：
1.屏蔽 int a = 0x1234; a & 0xff00 = 0x1200
2.取出 int a = 0x12; a & 0xff = 0x12
3.硬件清零器 clr
| 按位或
應用場景：
1.設置高點頻的方法 設置器 set
^ 按位異或 相當與減
~ 取反
=============================================================================================
賦值運算符
=
+=
-=
&=
|=
============================================================================================
內存訪問符
() :限制符 （a+b）*c 函數訪問 fun()
[] :數組 內存訪問的ID符號
{} :函數體限制符
--------------------------------------------------------------------------------------------
->
.
--------------------------------------------------------------------------------------------
& ：取地址
* ：指針
=============================================================================================
2-3：C語言內存空間的使用（指針 數組 結構體,共用體 內存分布圖 段錯誤分析）
指針:一種保存變量地址的變量： 首先--變量 作用：保存變量的地址 pointer = 指向
指針： 內存類型資源地址，門牌號的代名詞
指針變量：存放指針這個概念的盒子。
int a ; ----> | | | | a 相當與 盒子
*P
C語言編譯器對指針這個特殊概念，有2個疑問？
1.分配一個盒子，盒子多大？
在32bit系統中，指針就是4個Byte
2.盒子裏要存放的地址，所指向 內存的讀取方法是什麽？
看前面的數據類型，看在內存讀取方式。如果char *p_ch 取讀 1Byte
int *p_int 4Byte
& 取地址符
指針與修飾符
const：常量（只讀性質）
內存屬性：
1.內存操作的大小
2.內存的變化性，可讀可寫
理解如下：
char const *p/const char *p[T]
解析： const char *p :所指向的位置可以改變，但是位置裏面的內容不可變。 字符串 “hello world”
char *const p[T]/char *p const
解析：char *const p：所指向的位置不能改變，所指向位置裏面的內容可變。 硬件資源 LCD
解析： const char *const p
const char*const P:指針所指向的位置不能改變，同時位置裏面的內容也不能改變。 ROM 空間
voliatile：防止編譯器優化指向內存的優化，（硬件修改的內容，編譯器可能將其去掉了）
char *p
voliatile char *p
typedef:取別名
什麽類型 變量名稱；
xxxxx neam
int (*p[10](int ,void(*p)(int)));
typedef char* name_t; 聲明一個name_t類型，其類型是指的是char * 類型
name_t my_name; == char * my_name;
====================================================================================================
指針+運算符
加減運算 ++，--，+，-：
int a =12;
a+1 = 13
int *p = 0x12;
p+1 = [0x12+1*(sizeof(*p))] = 0x16;
指針的加/減法運算，實際上加/減的是一個單位，單位的大小可以使用sizeof(p[0]);
[]:
變量名[n]
n:ID標簽
地址裏面的內容的標簽訪問方式
*(p+n) = p[n]
================================================================================================
邏輯操作符 （> >= < <= == !=）
對地址操作一般只要的就是與特殊位置的比較
1.跟一個特殊值進行比較 0x0 地址的無效值，結束標誌 NULL
int *p
if(p == 0x0)/ if(p==NULL)
2.指針必須是同類型的比較才有意義（編譯器操作時使用）
================================================================================================
多級指針（關系）地址表
int **p;
存放地址的地址空間
char **p;
p[0] ,p[1].....p[n]
p[m] = NULL 結束了
int main(int argc, char **argv)
================================================================================================
數組 = 地址常量的標簽
內存分配的一種形式 越界問題
數組名是一個常量符號，一定不能放在=的左邊 相當於標簽
char buff[100] ;
buff = "hello world!\n"; XXXXXXX錯誤使用
buff = {"hello world!\n"};
定義一個空間：
1.大小
2.讀取方式
數據類型 數組名[m]
解析： [] == 告訴編譯器申請一個連續內存空間 大小 m個區域（小方格） 數據類型取內存的方式 一個小方格的大小Byte
int a[100]: 100個int類型的連續空間
數組空間的初始化
1.空間的賦值:按照標簽逐一賦值（程序員工作量太大，能不能用編譯器進行一些自動處理，幫組賦值）
---》空間定義時，就告知編譯器初始化情況，空間的第一次賦值，初始化操作
int a[10] = 空間； 第一次賦值
C語言本身，CPU內部本身一般不支持空間與空間的拷貝；
{} == 空間限制塊
int a[10] = {10,20,30,40,50,60,70,80,90,100};
#include <stdio.h>
void main()
{
char buf[100];
#ifdef A
buf = "hello wolrd!\n";
printf("buf:%s",buf);
#endif
#ifdef B
char buf1[100] = {"helo wolrd\n"};
printf("buf1:%s",buf1);
#endif
#ifdef C
buf = {"=====\n"};
printf("buf:%s"，buf);
#endif
}
演示代碼：
[root@localhost lesson1]# gcc 005.c -o 005-1 -D A
005.c: 在函數‘main’中:
005.c:7: 錯誤：將‘char *’賦值給‘char[100]’時類型不兼容
[root@localhost lesson1]# gcc 005.c -o 005-1 -D B
[root@localhost lesson1]# ./005-1
buf1:helo wolrd
[root@localhost lesson1]# gcc 005.c -o 005-1 -D C
005.c: 在函數‘main’中:
005.c:15: 錯誤：expected expression before ‘{’ token
數組空間的初始化和變量的初始化本質不同，尤其是嵌入式的裸機開發中，空間的初始化往往需要庫函數的輔助
軟件的最小空間char
char buf[10] = {‘a‘,‘b‘,‘c‘};
buf當成普通內存來看，沒有問題
buf當成一個字符串來看,最後加上一個‘\0‘或者0
字符串的重要屬性，結尾一定有一個‘\0‘
char buf[10] = {"abc"};
區別：char buf[10] = "abc" char *buf = "abc";
解析： “abc” === 地址
第二次內存初始化，賦值只能逐一處理；
strcpy ,strncpy
一塊空間，當成字符空間，提供了一套字符拷貝函數
字符拷貝函數的原理：
內存空間和內存空間的逐一賦值的功能的一個封裝體
一旦空間出現了0給個特殊值，函數即將結束。
#include <string>
char *strcpy(char *dest,const char * stc); == 非常嚴重的內存泄露函數
char *strncpy(char *dest,const char *stc,size_t n); （推薦使用）
字符空間
可以使用ASCII碼來解碼的空間，===人能看懂的數值 ‘\0‘作為結束標誌
===============================================================================================
非字符空間（不能使用strcpy /strncpy）
數據采集 0x00 ~ 0xff 8bit
開辟一個存儲這些數據的盒子
unsigned char buf[10]; ----> 數據
拷貝三要素（非字符串空間）：使用memcpy()
1.源資源
2.目標
3.拷貝的個數
#include <string>
void *memcpy(void *dest,const void*str,size_t n); n單位是字節 Byte
int buf[10];
int sensor_buf[100];
memcpy(buf,sensor_buf,(10*sizeof(int)));
========================================================================================
指針與數組
int a[100];
char * a_p[100]; sizeof(a_p) = 100*4
1.指針數值（二維指針）：數組裏面保存的地址，地址在內存的取地址方式就是前面的數據類型。
數組名的保存
定義一個指針，指向int a[10]的首地址;
定義一個指針，指向int b[5][6]的首地址；
*p p這個變量被*修飾了，只能是一個地址的變量了。
int *p[5]與int (*p)[5]區別？
解析：
int *p[5] : 5元素的數組，修飾數組* 說明是數組裏面裝的是用來存放地址，這些地址在內存
中取地址的方式 int類型（一次取走4Byte）；
int (*p)[5]:裏面有一個（）修飾 先翻譯()裏面的內容，*修飾的是地址 p表示一個存放的是地址變量
但是在內存中取地址的方式 int[5] 5*sizeof(int) = 5*4 =20 Byte;
int b[2][3][4] == int (*p)[3][4];
========================================================================================
結構體（打包數據類型）
1.字節對齊
struct abc{
char ch; //1Byte
int i; //4Byte
};
printf("sizeof:%lu\n",sizeof(abc)); == ???
效率，希望空間換時間的效率。最終打包的大小一定是4的倍數；
結構體裏面的變量的位置不一致，打包的大小可能不一樣。
============================================================================================
內存分配圖
內存屬性：
1.大小
2.在哪兒(位置)
int a ---》在哪兒？
編譯----》匯編-----》連接
int main()
{
int a;
a =0x10;
printf("a&:%p\n",&a);
printf("main:%p",main);
}
全局的數據空間（初始的，未初始化的 全局變量）static RW
只讀數據段 "hello world\n" 字符串常量 R 靜態空間，整個程序結束時釋放內存 生存周期最長
常見錯誤： char *p = "helao world"
代碼段： code R
常用的查看函數內存的命令
size ：查看函數內存大小
strings ：查看"" 只讀數據段
nm ：查看全局數據空間
=======================================================================================
棧空間：
‘{}‘裏面的除了有特殊修飾的變量 或者函數
運行時，函數內部使用的變量，函數一旦結束，就釋放空間。
=======================================================================================
堆空間：
運行時，可以自由，自我管理的分配和釋放的空間。生存周期是由程序員決定。
分配：
malloc()，一旦成功，返回分配好的地址給我們，只需要接受。對於新地址讀法，
由程序員制定。輸入參數制定分配大小，單位Byte
char *p;
p = (char *)malloc(100)；
int *p ;
p=(int *)malloc(5*sizeof(int));
釋放：
free(p);
========================================================================================
3-4:C語言函數的使用
1.函數的概述：
一堆代碼的集合，用一個標簽去描述它 （優點：復用化）
訪問：標簽--- 函數名
函數與數組的區別：
函數具備3要素
char *p:
int a[100]:
函數3要素：1.函數名（地址） 2.輸入參數 3.返回值
1.函數名：
在定義函數標簽 是，必須將3要素告知編譯器
int fun(int strm,char ch){};
如何用指針保存函數？
char *p;
char (*p)[10];
int (*p)(int char) 保存函數地址
定義函數，調用函數。
int func(int a,int b)
{
xxxx
}
int main()
{
func(10,2);
}
舉例：lesson2/002.c
void main()
{
void *p;
p = (void *)printf;
int(*myshow)(const char *,...);
printf("printf() addr:%p\n",p);
myshow = (int (*)(const char *,...))p;
myshow("myshow\n");
myshow("P:%p,M:%p\n",printf,myshow);
}
2.輸入參數（值得傳遞，地址的傳遞）
承上啟下的功能
調用者：
函數名（要傳遞的數據） //實參
背調者：
函數的具體實現
函數的返回值 函數名（接受的數據）//形參 只開辟空間 用於放數據
{
具體的實現
}
數據流向 ： 實參 -----》 形參
傳遞的形式：拷貝；
舉例：lesson2/003.c
void myswap(int buf)
{
char str[20];
strncpy(str,(char *)(buf),20);
printf("The buf is:%x\n",buf);
printf("str:%s",str);
}
void main()
{
int a = 0x20;
char *p = "hello world!\n";
myswap(p);
void (*func)(int);
func = myswap;
char *T = "My is func !\n";
func(T);
}
--------值傳遞------------------------------
#include <stdio.h>
void swap(int a ,int b)
{
int temp;
temp = a;
a = b;
b = temp;
}
void main()
{
int a =30, b =10;
int c ;
printf("This a :%d,b:%d\n",a,b);
#ifdef A
c =a;
a =b;
b =c;
printf("This a :%d,b:%d\n",a,b);
#endif
#ifdef B
swap(a,b);
printf("This a :%d,b:%d\n",a,b);
#endif
}
結果：004-1 / -D A a:30,b:10 a:10 b:30
004-2 / -D B a:30,b:10 a:30 b:10
上層調用者保護自己的空間不被修改的能力
---------地址傳遞----------------------------
#include <stdio.h>
void swap(int *a ,int*b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
void main()
{
int a =30, b =10;
int c ;
printf("This a :%d,b:%d\n",a,b);
#ifdef A
c =a;
a =b;
b =c;
printf("This a :%d,b:%d\n",a,b);
#endif
#ifdef B
swap(&a,&b);
printf("This a :%d,b:%d\n",a,b);
#endif
}
結果：005-1 / -D A a:30,b:10 a:10 b:30
005-2 / -D B a:30,b:10 a:10 b:30
上層，調用者讓下層子函數 修改自己的空間值得方式
連續空間的傳遞的方式使用地址傳遞
註意修飾符 const 只讀空間
int a
scanf("%d",&a);
-------------連續空間的傳遞------------------------
1.數組
數組名 --- 標簽(地址)
實參：
int abc[10];
fun(abc);
形參：
void fun(int *p)(推薦) <====> void fun (int p[10])
2.結構體
結構體變量
struct abc{
int a,b,c;
};
struct abc buf;
實參：
fun(buf); fun(&buf)
形參：
void fun(struct abc buf_t)---->浪費空間 void fun(struct abc *buf_p)---->節約空間
連續空間的傳遞的方式使用地址傳遞
sprintf(char *str ,const char*format,...)
空間傳遞：
1.子函數只看空間裏面的內容情況 —--+ const void func(const char *string);
2.子函數修改上層空間裏面的內容
空間與空間操作註意要素：1.首地址 2.結束標誌
結束標誌：內存裏面存放了0x00（1B），針對於字符空間的結束標誌 。
非字符空間0x00不是結束標誌，只是表示當前狀態。
字符空間操作模板：
void fun(char *p)
{
int i;
while(p[i]){
p[i] 操作 p[i] = x a = p[i] + -
i++
}
}
非字符空間(不已0x00作為結束標誌 )
int *p unsigned char *p short *p struct abc *p void *p(任何類型)
結束標誌：數量（Byte）
void fun(unsigned char *p ,int size) ===升級====> void fun(void *p,int size)
{
int i;
for(i=0;i<size;i++){
p[i] = ;
a =p[i]
++ -- + -
}
}
//內存拷貝
void *memcpy(void *dest，const void *str,size_t size);
ssize_t recv(int sockfd,void *buf,size_t len,int flags);
ssize_t send(int sockfd ,const void *buf,size_t len,int flags);
======================================================================
函數三要素之返回值（出口參數---啟下作用（返回值 地址傳遞））
基本語法：
返回類型 函數名稱（輸入列表）
{
return （返回信息）
}
調用者：
返回值接受 = fun();
被調者：
int fun ()
{
int ret;
xxxxx
return ret ;
}
拷貝
返回數據類型：
基本類型
指針類型（空間）
指針作為空間返回的唯一數據類型
int *fun（）
地址：指向的合法性
作為函數的設計者，必須保證函數返回的地址所指向的空間是合法。（不是局部變量）
使用者：
int *fun()
int *p = fun();
函數內部實現
基本數據類型返回：
基本數據類型 fun()
{
基本數據類型 ret
ret = xxx;
return ret;
}
返回數據類型為地址空間：
char *fun() =====> 錯誤 函數返回局部變量地址 ====》改變將局部變量轉化成靜態區
{
char buf[] = "hello wolrd\n";
return buf;
}
升級 （局部變量地址轉化到）=== 靜態區 只讀區 堆區
char * fun(void)
{
char *str = (char *)malloc(sizeof(char)*100);
strcpy(str,"hello wolrd\n");
return str;
}
======================================================================================
常見面試題解析：
預處理器（Preprocessor）
1 . 用預處理指令#define 聲明一個常數，用以表明1年中有多少秒（忽略閏年問題）
#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在這想看到幾件事情：
1) #define 語法的基本知識（例如：不能以分號結束，括號的使用，等等）
2)懂得預處理器將為你計算常數表達式的值，因此，直接寫出你是如何計算一年中有多少秒而不是計算出實際的值，是更清晰而沒有代價的。
3) 意識到這個表達式將使一個16位機的整型數溢出-因此要用到長整型符號L,告訴編譯器這個常數是的長整型數。
4) 如果你在你的表達式中用到UL（表示無符號長整型），那麽你有了一個好的起點。記住，第一印象很重要。
2 . 寫一個"標準"宏MIN ，這個宏輸入兩個參數並返回較小的一個。
#define MIN(A,B) （（A） <= (B) ? (A) : (B)) 這個測試是為下面的目的而設的：
1) 標識#define在宏中應用的基本知識。這是很重要的。因為在 嵌入(inline)操作符 變為標準C的一部分之前，宏是方便產生嵌入代碼的唯一方法，對於嵌入式系統來說，為了能達到要求的性能，嵌入代碼經常是必須的方法。
2)三重條件操作符的知識。這個操作符存在C語言中的原因是它使得編譯器能產生比if-then-else更優化的代碼，了解這個用法是很重要的。
3) 懂得在宏中小心地把參數用括號括起來
4) 我也用這個問題開始討論宏的副作用，例如：當你寫下面的代碼時會發生什麽事？
least = MIN(*p++, b);
3. 預處理器標識#error的目的是什麽？
如果你不知道答案，請看參考文獻1。這問題對區分一個正常的夥計和一個書呆子是很有用的。只有書呆子才會讀C語言課本的附錄去找出象這種問題的答案。當然如果你不是在找一個書呆子，那麽應試者最好希望自己不要知道答案。
死循環（Infinite loops）
4. 嵌入式系統中經常要用到無限循環，你怎麽樣用C編寫死循環呢？ 這個問題用幾個解決方案。
我首選的方案是：
while(1)
{
}
一些程序員更喜歡如下方案：
for(;;)
{
}
這個實現方式讓我為難，因為這個語法沒有確切表達到底怎麽回事。如果一個應試者給出這個作為方案，我將用這個作為一個機會去探究他們這樣做的基本原理。如果他們的基本答案是："我被教著這樣做，但從沒有想到過為什麽。"這會給我留下一個壞印象。
第三個方案是用 goto
Loop:
...
goto Loop;
應試者如給出上面的方案，這說明或者他是一個匯編語言程序員（這也許是好事）或者他是一個想進入新領域的BASIC/FORTRAN程序員。
數據聲明（Data declarations）
5. 用變量a給出下面的定義
a) 一個整型數（An integer）
b)一個指向整型數的指針（ A pointer to an integer）
c)一個指向指針的的指針，它指向的指針是指向一個整型數（ A pointer to a pointer to an intege）r
d)一個有10個整型數的數組（ An array of 10 integers）
e) 一個有10個指針的數組，該指針是指向一個整型數的。（An array of 10 pointers to
integers）
f) 一個指向有10個整型數數組的指針（ A pointer to an array of 10 integers）
g) 一個指向函數的指針，該函數有一個整型參數並返回一個整型數（A pointer to a function
that takes an integer as an argument and returns an integer）
h) 一個有10個指針的數組，該指針指向一個函數，該函數有一個整型參數並返回一個整型數（ An array of ten pointers to functions that take an integer argument and return an integer ）
答案是：
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that
takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to
functions that take an integer argument and return an
integer
人們經常聲稱這裏有幾個問題是那種要翻一下書才能回答的問題，我同意這種說法。當我寫這篇文章時，為了確定語法的正確性，我的確查了一下書。但是當我被面試的時候，我期望被問到這個問題（或者相近的問題）。因為在被面試的這段時間裏，我確定我知道這個問題的答案。應試者如果不知道所有的答案（或至少大部分答案），那麽也就沒有為這次面試做準備，如果該面試者沒有為這次面試做準備，那麽他又能為什麽出準備呢？
Static
6. 關鍵字static的作用是什麽？
這個簡單的問題很少有人能回答完全。在C語言中，關鍵字static有三個明顯的作用：
1)在函數體，一個被聲明為靜態的變量在這一函數被調用過程中維持其值不變。
2) 在模塊內（但在函數體外），一個被聲明為靜態的變量可以被模塊內所用函數訪問，但不能被模塊外其它函數訪問。它是一個本地的全局變量。
3) 在模塊內，一個被聲明為靜態的函數只可被這一模塊內的其它函數調用。那就是，這個函數被限制在聲明它的模塊的本地範圍內使用。
大多數應試者能正確回答第一部分，一部分能正確回答第二部分，同是很少的人能懂得第三部分。這是一個應試者的嚴重的缺點，因為他顯然不懂得本地化數據和代碼範圍的好處和重要性。
Const
7．關鍵字const有什麽含意？
我只要一聽到被面試者說："const意味著常數"，我就知道我正在和一個業余者打交道。去年Dan
Saks已經在他的文章裏完全概括了const的所有用法，因此ESP(譯者：Embedded Systems
Programming)的每一位讀者應該非常熟悉const能做什麽和不能做什麽.如果你從沒有讀到那篇文章，只要能說出const意味著"只讀"就可以了。盡管這個答案不是完全的答案，但我接受它作為一個正確的答案。（如果你想知道更詳細的答案，仔細讀一下Saks的文章吧。）
如果應試者能正確回答這個問題，我將問他一個附加的問題：下面的聲明都是什麽意思？
const int a;
int const a;
const int *a;
int * const a;
int const * a const;
/******/
前兩個的作用是一樣，a是一個常整型數。第三個意味著a是一個指向常整型數的指針（也就是，整型數是不可修改的，但指針可以）。第四個意思a是一個指向整型數的常指針（也就是說，指針指向的整型數是可以修改的，但指針是不可修改的）。最後一個意味著a是一個指向常整型數的常指針（也就是說，指針指向的整型數是不可修改的，同時指針也是不可修改的）。如果應試者能正確回答這些問題，那麽他就給我留下了一個好印象。順帶提一句，也許你可能會問，即使不用關鍵字 ，也還是能很容易寫出功能正確的程序，那麽我為什麽還要如此看重關鍵字const呢？我也如下的幾下理由：
1) 關鍵字const的作用是為給讀你代碼的人傳達非常有用的信息，實際上，聲明一個參數為常量是為了告訴了用戶這個參數的應用目的。如果你曾花很多時間清理其它人留下的垃圾，你就會很快學會感謝這點多余的信息。（當然，懂得用const的程序員很少會留下的垃圾讓別人來清理的。）
2) 通過給優化器一些附加的信息，使用關鍵字const也許能產生更緊湊的代碼。
3) 合理地使用關鍵字const可以使編譯器很自然地保護那些不希望被改變的參數，防止其被無意的代碼修改。簡而言之，這樣可以減少bug的出現。
Volatile
8. 關鍵字volatile有什麽含意?並給出三個不同的例子。
一個定義為volatile的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到這個變量時必須每次都小心地重新讀取這個變量的值，而不是使用保存在寄存器裏的備份。下面是volatile變量的幾個例子：
1) 並行設備的硬件寄存器（如：狀態寄存器）
2) 一個中斷服務子程序中會訪問到的非自動變量(Non-automatic variables)
3) 多線程應用中被幾個任務共享的變量
回答不出這個問題的人是不會被雇傭的。我認為這是區分C程序員和嵌入式系統程序員的最基本的問題。搞嵌入式的家夥們經常同硬件、中斷、RTOS等等打交道，所有這些都要求用到volatile變量。不懂得volatile的內容將會帶來災難。 假設被面試者正確地回答了這是問題（嗯，懷疑是否會是這樣），我將稍微深究一下，看一下這家夥是不是直正懂得volatile完全的重要性。
1)一個參數既可以是const還可以是volatile嗎？解釋為什麽。
2); 一個指針可以是volatile 嗎？解釋為什麽。
3); 下面的函數有什麽錯誤：
int square(volatile int *ptr)
{
return *ptr * *ptr;
}
下面是答案：
1)是的。一個例子是只讀的狀態寄存器。它是volatile因為它可能被意想不到地改變。它是const因為程序不應該試圖去修改它。
2); 是的。盡管這並不很常見。一個例子是當一個中服務子程序修該一個指向一個buffer的指針時。
3) 這段代碼有點變態。這段代碼的目的是用來返指針*ptr指向值的平方，但是，由於*ptr指向一個volatile型參數，編譯器將產生類似下面的代碼：
int square(volatile int *ptr)
{
int a,b;
a = *ptr;
b = *ptr;
return a * b;
}
由於*ptr的值可能被意想不到地該變，因此a和b可能是不同的。結果，這段代碼可能返不是你所期望的平方值！正確的代碼如下：
long square(volatile int *ptr)
{
int a;
a = *ptr;
return a * a;
}
位操作（Bit manipulation）
9. 嵌入式系統總是要用戶對變量或寄存器進行位操作。給定一個整型變量a，寫兩段代碼，第一個設置a的bit 3，第二個清除a 的bit 3。在以上兩個操作中，要保持其它位不變。 對這個問題有三種基本的反應
1)不知道如何下手。該被面者從沒做過任何嵌入式系統的工作。
2) 用bit fields。Bit fields是被扔到C語言死角的東西，它保證你的代碼在不同編譯器之間是不可移植的，同時也保證了的你的代碼是不可重用的。我最近不幸看到 Infineon為其較復雜的通信芯片寫的驅動程序，它用到了bit fields因此完全對我無用，因為我的編譯器用其它的方式來實現bit fields的。從道德講：永遠不要讓一個非嵌入式的家夥粘實際硬件的邊。
3) 用 #defines 和 bit masks 操作。這是一個有極高可移植性的方法，是應該被用到的方法。最佳的解決方案如下：
#define BIT3 (0x1 << 3)
static int a;
void set_bit3(void)
{
a |= BIT3;
}
void clear_bit3(void)
{
a &= ~BIT3;
}
一些人喜歡為設置和清除值而定義一個掩碼同時定義一些說明常數，這也是可以接受的。我希望看到幾個要點：說明常數、|=和&=~操作。
訪問固定的內存位置（Accessing fixed memory locations）
10. 嵌入式系統經常具有要求程序員去訪問某特定的內存位置的特點。
在某工程中，要求設置一絕對地址為0x67a9的整型變量的值為0xaa66。編譯器是一個純粹的ANSI編譯器。寫代碼去完成這一任務。這一問題測試你是否知道為了訪問一絕對地址把一個整型數強制轉換（typecast）為一指針是合法的。這一問題的實現方式隨著個人風格不同而不同。典型的類似代碼如下：
int *ptr;
ptr = (int *)0x67a9;
*ptr = 0xaa55;
A more obscure approach is: ( 一個較晦澀的方法是)：
*(int * const)(0x67a9) = 0xaa55;
即使你的品味更接近第二種方案，但我建議你在面試時使用第一種方案。
中斷（Interrupts）
11.
中斷是嵌入式系統中重要的組成部分，這導致了很多編譯開發商提供一種擴展—讓標準C支持中斷。具代表事實是，產生了一個新的關鍵字 __interrupt。下面的代碼就使用了__interrupt關鍵字去定義了一個中斷服務子程序(ISR)，請評論一下這段代碼的。
__interrupt double compute_area (double radius)
{
double area = PI * radius * radius;
printf("\nArea = %f", area);
return area;
}
這個函數有太多的錯誤了，以至讓人不知從何說起了：
1)ISR 不能返回一個值。如果你不懂這個，那麽你不會被雇用的。
2) ISR 不能傳遞參數。如果你沒有看到這一點，你被雇用的機會等同第一項。
3) 在許多的處理器/編譯器中，浮點一般都是不可重入的。有些處理器/編譯器需要讓額處的寄存器入棧，有些處理器/編譯器就是不允許在ISR中做浮點運算。此外，ISR應該是短而有效率的，在ISR中做浮點運算是不明智的。
4) 與第三點一脈相承，printf()經常有重入和性能上的問題。如果你丟掉了第三和第四點，我不會太為難你的。不用說，如果你能得到後兩點，那麽你的被雇用前景越來越光明了。
代碼例子（Code examples）
12 . 下面的代碼輸出是什麽，為什麽？
void foo(void)
{
unsigned int a = 6;
int b = -20;
(a+b > 6) ? puts("> 6") : puts("<= 6");
}
這個問題測試你是否懂得C語言中的整數自動轉換原則，我發現有些開發者懂得極少這些東西。不管如何，這無符號整型問題的答案是輸出是 ">6"。原因是當表達式中存在有符號類型和無符號類型時所有的操作數都自動轉換為無符號類型。因此-20變成了一個非常大的正整數，所以該表達式計算出的結果大於6。這一點對於應當頻繁用到無符號數據類型的嵌入式系統來說是豐常重要的。如果你答錯了這個問題，你也就到了得不到這份工作的邊緣。
13. 評價下面的代碼片斷：
unsigned int zero = 0;
unsigned int compzero = 0xFFFF;
/*1‘s complement of zero */
對於一個int型不是16位的處理器為說，上面的代碼是不正確的。應編寫如下：
unsigned int compzero = ~0;
這一問題真正能揭露出應試者是否懂得處理器字長的重要性。在我的經驗裏，好的嵌入式程序員非常準確地明白硬件的細節和它的局限，然而PC機程序往往把硬件作為一個無法避免的煩惱。
到了這個階段，應試者或者完全垂頭喪氣了或者信心滿滿誌在必得。如果顯然應試者不是很好，那麽這個測試就在這裏結束了。但如果顯然應試者做得不錯，那麽我就扔出下面的追加問題，這些問題是比較難的，我想僅僅非常優秀的應試者能做得不錯。提出這些問題，我希望更多看到應試者應付問題的方法，而不是答案。不管如何，你就當是這個娛樂吧...
動態內存分配（Dynamic memory allocation）
14.
盡管不像非嵌入式計算機那麽常見，嵌入式系統還是有從堆（heap）中動態分配內存的過程的。那麽嵌入式系統中，動態分配內存可能發生的問題是什麽？這裏，我期望應試者能提到內存碎片，碎片收集的問題，變量的持行時間等等。這個主題已經在ESP雜誌中被廣泛地討論過了（主要是 P.J. Plauger, 他的解釋遠遠超過我這裏能提到的任何解釋），所有回過頭看一下這些雜誌吧！讓應試者進入一種虛假的安全感覺後，我拿出這麽一個小節目：下面的代碼片段的輸出是什麽，為什麽？
char *ptr;
if ((ptr = (char *)malloc(0)) == NULL)
puts("Got a null pointer");
else
puts("Got a valid pointer");
這是一個有趣的問題。最近在我的一個同事不經意把0值傳給了函數malloc，得到了一個合法的指針之後，我才想到這個問題。這就是上面的代碼，該代碼的輸出是"Got a valid pointer"。我用這個來開始討論這樣的一問題，看看被面試者是否想到庫例程這樣做是正確。得到正確的答案固然重要，但解決問題的方法和你做決定的基本原理更重要些。
Typedef
15 Typedef
在C語言中頻繁用以聲明一個已經存在的數據類型的同義字。也可以用預處理器做類似的事。例如，思考一下下面的例子：
#define dPS struct s *
typedef struct s * tPS;
以上兩種情況的意圖都是要定義dPS 和 tPS 作為一個指向結構s指針。哪種方法更好呢？（如果有的話）為什麽？
這是一個非常微妙的問題，任何人答對這個問題（正當的原因）是應當被恭喜的。答案是：typedef更好。思考下面的例子：
dPS p1,p2;
tPS p3,p4;
第一個擴展為
struct s * p1, p2;
上面的代碼定義p1為一個指向結構的指，p2為一個實際的結構，這也許不是你想要的。第二個例子正確地定義了p3 和p4 兩個指針。
晦澀的語法
16 . C語言同意一些令人震驚的結構,下面的結構是合法的嗎，如果是它做些什麽？
int a = 5, b = 7, c;
c = a+++b;
這個問題將做為這個測驗的一個愉快的結尾。不管你相不相信，上面的例子是完全合乎語法的。問題是編譯器如何處理它？水平不高的編譯作者實際上會爭論這個問題，根據最處理原則，編譯器應當能處理盡可能所有合法的用法。因此，上面的代碼被處理成：c = a++ + b;
因此, 這段代碼持行後a = 6, b = 7, c = 12。
如果你知道答案，或猜出正確答案，做得好。如果你不知道答案，我也不把這個當作問題。我發現這個問題的最大好處是這是一個關於代碼編寫風格，代碼的可讀性，代碼的可修改性的好的話題。
嵌入式C語言提升
致敬：每一個奮鬥的人！ Up Up Up
C語言常見編譯錯誤
1.預處理錯誤 -E
1-1 找不到源文件錯誤
自己定義頭文件 使用 “xxx.h” 搜索的目錄 ./
系統頭文件 使用 <xxx.h> 搜索的目錄 系統環境變量
解決辦法
gcc -I跟查找頭文件的目錄
舉例
gcc -o build -I./include xxx.c
2.編譯錯誤 -c （語法錯誤）
3.鏈接錯誤 -o 原材料不夠，或者多了
collect2 -undefined （原材料缺少）
預處理的使用
#include 包含頭文件 使編譯程序將另一源文件嵌入到帶#include 的源文件中
#define 宏定義 （替換）
#define 宏名 宏體 （不進行語法檢查）
#define ABC 3+5
printf("the %d\n",ABC*5); ----?
#define ABC (3+5) ---?
#define ABC(x) (5+(x))
#undef 撤銷已定義過的宏名
條件編譯 003.c
#if #if的一般含義是如果#if後面的表達式為TRUE（真)
則編譯它與#endif之間的代碼，否則跳過這些代碼。
#elif 命令#elif 類似於 else if 形成一個if else-if 階梯狀語句
可進行多種編譯選擇
#endif 命令#endif 標識 一個#if塊的結束
#ifdef 如果有定義執行編譯代碼
#ifndef 如果沒有定義執行編譯代碼
可以使用GCC 編譯選項添加預處理宏定義
gcc -D[宏名] 不需要空格
其他
#line 改變當前的行號和文件名，他們是在編譯中預處理定義的標識符
#line number["filename"]
#error 編譯程序時，只要遇到 #error 就會產生一個編譯錯誤提示信息 ，並停止編譯
#error 錯誤信息
#pragma 為實現時定義的命令，它允許向編譯程序傳送各種指令
編譯程序可能有一種選擇，它支持對程序執行的追蹤。
預定義宏
__FUNCTION__: 函數名
__LINE__ ：行號
__FILE__ : 文件名
__DATA__ : 表示編譯時刻的日期字符串，“25 Dec 2018”
__TIME__ : 表示編譯時刻的時間字符串, "12:30:44"
宏展開下的 # ## 004.c
# 字符串化
## 連接符號
C 語言關鍵字 32 個
關鍵字：編譯器 預先定義好的有一定意義的 字符串
雜項：
sizeof：計算對象所占內存大小 sizeof(xxx) --不是函數--
編譯器給我們查看內存容量的一個工具
return：子程序返回語句（可以帶參數，也可不帶參數）
用於終止一個函數並返回其後面跟著的值
用法： return （Val）
-規則-
：return語句不能返回指向“棧內存”的“指針”，因為該內存在函數體結束時被自動銷毀
例子：
char *func(void){
char str[30];
.
...
return str;
}
數據類型：
C語言操作的對象---> 資源/內存
資源的屬性【大小】---> 數據類型--->”尺子“
char
硬件芯片操作的最小單位： bit 1 / 0 位
軟件操作的最小單位： 8bit == 1 Byte 4M --> 4Mbit Kbit/s KB/s
char = 1Byte = 8bit == 2^8 = 256
==================================================================
int
編譯器最優處理大小：
系統一個周期，所能接受的最大處理單元，int 32位
int = 4Byte = 4*8bit = 32bit == 2^32 (與編譯器有關)
short = 2Byte = 16bit
long = 4Byte = 32bit
unsigned 聲明無符號類型變量
signed 聲明有符號類型變量
int a ---展開--- signed int
區別：內存空間的最高是符號位還是數據
有符號： 數字
無符號： 數據 （采集數據）
區別 ：
char a = -1; 0xff;
a>>1
unsigned char b = 0xff;
b>>1;
==================================================================
浮點數
float：聲明浮點型數據 4Byte = 32bit
double：聲明雙精度變量 8Byte = 64bit
浮點型常量
1.0f
=================================================================
void 空類型 用於占位 到時候強制轉換
===================================================================
自定義數據類型
struct :聲明結構體變量
元素之間的集合
struct myabc{
unsigned int a;
unsigned int b;
unsigned int c;
unsigned int d;
}; -------->這裏只是告訴編譯器，有定義該結構體的能力（聲明）；
struct myabc mybuf;劃分內存 (定義)；
順序有要求
-----------------
| | |——|———————————————|
|---------------| ----》|--|---------------|
|---------------|
|---------------|
(結構體內存模型) (共用體內存模型)
union 聲明聯合數據類型
共用起始地址的一段內存（占用的內存為最大數據類型，但是指定好後就是指定數據類型）
技巧型代碼
union myabc{
char a;
int b;
}; (聲明)
union myabc abcbuf;
enum:聲明枚舉類型 【人和人交流限制】
enumerate 一一列舉
用法
enum [枚舉名稱]{常量列表};
typedef:用以給數據類型取別名
int a ; a是一個int 類型的變量
typedef int a ; a是一個int 類型的外號（聲明 沒有申請內存）
------------------------------------------------------------------------------------------------
邏輯結構：改變程序執行的方式 （提高邏輯思維）
CPU 順序執行程序
分支 ---> 選擇
循環 ---> 重復
條件：
if（條件表達式）
xxxx
else
xxxx
if 使用規制：
先處理正常情況，在處理異常情況；
理解：
if(NULL != p);
func();
和：if（NULL ！= p）
func();
多分支 switch case default
switch(整形數字)
case :
break
default
使用規則：
1.每一個case語句的結尾絕對不要忘記加break，否則將導致多個分支重疊（除非有意為止）
2.最後必須使用default分支，即使程序真的不需要default處理，也要保留。
3.case後面只能是整型或者字符型的常量或者常量表達式。
================================================================================================
do while for
for 次數
while 條件 先判斷while後面括號的值，如果是真則執行其後面的代碼，否則不執行；
while(0)
{
printf("0\n");
break;
}
while(-1){
printf("-1");
break;
}
while(1)
{
printf("1\n")
break;
}
do (先執行在判斷)
while
continue break goto
continue :終止本次循環（本輪循環）
break :終止本層循環（消除一次循環體）
===============================================================================================
類型修飾符
對內存資源存放位置的限定
資源屬性【位置的限定】
資源位置：
auto: 聲明自動變量 默認情況 --- > 分配的內存是可讀可寫的區域 （區域如果在{ }裏面，就是棧空間內）
register: 限制變量定義在寄存器上的修飾 內存（存儲器） 寄存器 定義一些快速訪問的變量
（編譯器會盡量安排CPU的寄存器去存放這個值，&對register不起作用）
使用規則：register變量必須是能被CPU寄存器所接受的類型。
static:
靜態
應用場景：
1.函數內部的變量
int fun()
{
int a ===> static int a
}
2.函數外部的變量
int a ===> static int a
int fun()
{
}
3.修飾函數
int fun() === > static int fun();
const: 常量的定義 修飾只讀變量
extern: 外部申明
volatile:告知編譯器編譯方法的關鍵字，不優化編譯 給硬件打交道
修飾的變量的值的修改，不僅僅可以通過軟件，也可以通過其他方式（硬件外部的用戶）
----------------------------------------------------------------------------------------------
運算符
算術操作運算符
+ 加
- 減
* 乘
/ 除
% 求余數 n%m = res [0 ~ m-1]
應用場景：
1.取一個範圍的數
2.得到M進制的個位數
3.得到循環數據結構的下標
==============================================================================================
邏輯運算
真 假
返回結果 1（真） 0 （假）
|| 邏輯或 有一真即可
&& 邏輯與 都真才為真
> 大於
< 小於
>= 大於等於
<= 小於等於
! 不等於
? : 三目運算
=============================================================================================
位運算符
1. 移位操作 (註意：數據 與數字 操作是不同的)
<< 左移位 乘法 *2 （2進制下的移位） m<<n == m*2^n
>> 右移位
& 按位與
應用場景：
1.屏蔽 int a = 0x1234; a & 0xff00 = 0x1200
2.取出 int a = 0x12; a & 0xff = 0x12
3.硬件清零器 clr
| 按位或
應用場景：
1.設置高點頻的方法 設置器 set
^ 按位異或 相當與減
~ 取反
=============================================================================================
賦值運算符
=
+=
-=
&=
|=
============================================================================================
內存訪問符
() :限制符 （a+b）*c 函數訪問 fun()
[] :數組 內存訪問的ID符號
{} :函數體限制符
--------------------------------------------------------------------------------------------
->
.
--------------------------------------------------------------------------------------------
& ：取地址
* ：指針
=============================================================================================
2-3：C語言內存空間的使用（指針 數組 結構體,共用體 內存分布圖 段錯誤分析）
指針:一種保存變量地址的變量： 首先--變量 作用：保存變量的地址 pointer = 指向
指針： 內存類型資源地址，門牌號的代名詞
指針變量：存放指針這個概念的盒子。
int a ; ----> | | | | a 相當與 盒子
*P
C語言編譯器對指針這個特殊概念，有2個疑問？
1.分配一個盒子，盒子多大？
在32bit系統中，指針就是4個Byte
2.盒子裏要存放的地址，所指向 內存的讀取方法是什麽？
看前面的數據類型，看在內存讀取方式。如果char *p_ch 取讀 1Byte
int *p_int 4Byte
& 取地址符
指針與修飾符
const：常量（只讀性質）
內存屬性：
1.內存操作的大小
2.內存的變化性，可讀可寫
理解如下：
char const *p/const char *p[T]
解析： const char *p :所指向的位置可以改變，但是位置裏面的內容不可變。 字符串 “hello world”
char *const p[T]/char *p const
解析：char *const p：所指向的位置不能改變，所指向位置裏面的內容可變。 硬件資源 LCD
解析： const char *const p
const char*const P:指針所指向的位置不能改變，同時位置裏面的內容也不能改變。 ROM 空間
voliatile：防止編譯器優化指向內存的優化，（硬件修改的內容，編譯器可能將其去掉了）
char *p
voliatile char *p
typedef:取別名
什麽類型 變量名稱；
xxxxx neam
int (*p[10](int ,void(*p)(int)));
typedef char* name_t; 聲明一個name_t類型，其類型是指的是char * 類型
name_t my_name; == char * my_name;
====================================================================================================
指針+運算符
加減運算 ++，--，+，-：
int a =12;
a+1 = 13
int *p = 0x12;
p+1 = [0x12+1*(sizeof(*p))] = 0x16;
指針的加/減法運算，實際上加/減的是一個單位，單位的大小可以使用sizeof(p[0]);
[]:
變量名[n]
n:ID標簽
地址裏面的內容的標簽訪問方式
*(p+n) = p[n]
================================================================================================
邏輯操作符 （> >= < <= == !=）
對地址操作一般只要的就是與特殊位置的比較
1.跟一個特殊值進行比較 0x0 地址的無效值，結束標誌 NULL
int *p
if(p == 0x0)/ if(p==NULL)
2.指針必須是同類型的比較才有意義（編譯器操作時使用）
================================================================================================
多級指針（關系）地址表
int **p;
存放地址的地址空間
char **p;
p[0] ,p[1].....p[n]
p[m] = NULL 結束了
int main(int argc, char **argv)
================================================================================================
數組 = 地址常量的標簽
內存分配的一種形式 越界問題
數組名是一個常量符號，一定不能放在=的左邊 相當於標簽
char buff[100] ;
buff = "hello world!\n"; XXXXXXX錯誤使用
buff = {"hello world!\n"};
定義一個空間：
1.大小
2.讀取方式
數據類型 數組名[m]
解析： [] == 告訴編譯器申請一個連續內存空間 大小 m個區域（小方格） 數據類型取內存的方式 一個小方格的大小Byte
int a[100]: 100個int類型的連續空間
數組空間的初始化
1.空間的賦值:按照標簽逐一賦值（程序員工作量太大，能不能用編譯器進行一些自動處理，幫組賦值）
---》空間定義時，就告知編譯器初始化情況，空間的第一次賦值，初始化操作
int a[10] = 空間； 第一次賦值
C語言本身，CPU內部本身一般不支持空間與空間的拷貝；
{} == 空間限制塊
int a[10] = {10,20,30,40,50,60,70,80,90,100};
#include <stdio.h>
void main()
{
char buf[100];
#ifdef A
buf = "hello wolrd!\n";
printf("buf:%s",buf);
#endif
#ifdef B
char buf1[100] = {"helo wolrd\n"};
printf("buf1:%s",buf1);
#endif
#ifdef C
buf = {"=====\n"};
printf("buf:%s"，buf);
#endif
}
演示代碼：
[root@localhost lesson1]# gcc 005.c -o 005-1 -D A
005.c: 在函數‘main’中:
005.c:7: 錯誤：將‘char *’賦值給‘char[100]’時類型不兼容
[root@localhost lesson1]# gcc 005.c -o 005-1 -D B
[root@localhost lesson1]# ./005-1
buf1:helo wolrd
[root@localhost lesson1]# gcc 005.c -o 005-1 -D C
005.c: 在函數‘main’中:
005.c:15: 錯誤：expected expression before ‘{’ token
數組空間的初始化和變量的初始化本質不同，尤其是嵌入式的裸機開發中，空間的初始化往往需要庫函數的輔助
軟件的最小空間char
char buf[10] = {‘a‘,‘b‘,‘c‘};
buf當成普通內存來看，沒有問題
buf當成一個字符串來看,最後加上一個‘\0‘或者0
字符串的重要屬性，結尾一定有一個‘\0‘
char buf[10] = {"abc"};
區別：char buf[10] = "abc" char *buf = "abc";
解析： “abc” === 地址
第二次內存初始化，賦值只能逐一處理；
strcpy ,strncpy
一塊空間，當成字符空間，提供了一套字符拷貝函數
字符拷貝函數的原理：
內存空間和內存空間的逐一賦值的功能的一個封裝體
一旦空間出現了0給個特殊值，函數即將結束。
#include <string>
char *strcpy(char *dest,const char * stc); == 非常嚴重的內存泄露函數
char *strncpy(char *dest,const char *stc,size_t n); （推薦使用）
字符空間
可以使用ASCII碼來解碼的空間，===人能看懂的數值 ‘\0‘作為結束標誌
===============================================================================================
非字符空間（不能使用strcpy /strncpy）
數據采集 0x00 ~ 0xff 8bit
開辟一個存儲這些數據的盒子
unsigned char buf[10]; ----> 數據
拷貝三要素（非字符串空間）：使用memcpy()
1.源資源
2.目標
3.拷貝的個數
#include <string>
void *memcpy(void *dest,const void*str,size_t n); n單位是字節 Byte
int buf[10];
int sensor_buf[100];
memcpy(buf,sensor_buf,(10*sizeof(int)));
========================================================================================
指針與數組
int a[100];
char * a_p[100]; sizeof(a_p) = 100*4
1.指針數值（二維指針）：數組裏面保存的地址，地址在內存的取地址方式就是前面的數據類型。
數組名的保存
定義一個指針，指向int a[10]的首地址;
定義一個指針，指向int b[5][6]的首地址；
*p p這個變量被*修飾了，只能是一個地址的變量了。
int *p[5]與int (*p)[5]區別？
解析：
int *p[5] : 5元素的數組，修飾數組* 說明是數組裏面裝的是用來存放地址，這些地址在內存
中取地址的方式 int類型（一次取走4Byte）；
int (*p)[5]:裏面有一個（）修飾 先翻譯()裏面的內容，*修飾的是地址 p表示一個存放的是地址變量
但是在內存中取地址的方式 int[5] 5*sizeof(int) = 5*4 =20 Byte;
int b[2][3][4] == int (*p)[3][4];
========================================================================================
結構體（打包數據類型）
1.字節對齊
struct abc{
char ch; //1Byte
int i; //4Byte
};
printf("sizeof:%lu\n",sizeof(abc)); == ???
效率，希望空間換時間的效率。最終打包的大小一定是4的倍數；
結構體裏面的變量的位置不一致，打包的大小可能不一樣。
============================================================================================
內存分配圖
內存屬性：
1.大小
2.在哪兒(位置)
int a ---》在哪兒？
編譯----》匯編-----》連接
int main()
{
int a;
a =0x10;
printf("a&:%p\n",&a);
printf("main:%p",main);
}
全局的數據空間（初始的，未初始化的 全局變量）static RW
只讀數據段 "hello world\n" 字符串常量 R 靜態空間，整個程序結束時釋放內存 生存周期最長
常見錯誤： char *p = "helao world"
代碼段： code R
常用的查看函數內存的命令
size ：查看函數內存大小
strings ：查看"" 只讀數據段
nm ：查看全局數據空間
=======================================================================================
棧空間：
‘{}‘裏面的除了有特殊修飾的變量 或者函數
運行時，函數內部使用的變量，函數一旦結束，就釋放空間。
=======================================================================================
堆空間：
運行時，可以自由，自我管理的分配和釋放的空間。生存周期是由程序員決定。
分配：
malloc()，一旦成功，返回分配好的地址給我們，只需要接受。對於新地址讀法，
由程序員制定。輸入參數制定分配大小，單位Byte
char *p;
p = (char *)malloc(100)；
int *p ;
p=(int *)malloc(5*sizeof(int));
釋放：
free(p);
========================================================================================
3-4:C語言函數的使用
1.函數的概述：
一堆代碼的集合，用一個標簽去描述它 （優點：復用化）
訪問：標簽--- 函數名
函數與數組的區別：
函數具備3要素
char *p:
int a[100]:
函數3要素：1.函數名（地址） 2.輸入參數 3.返回值
1.函數名：
在定義函數標簽 是，必須將3要素告知編譯器
int fun(int strm,char ch){};
如何用指針保存函數？
char *p;
char (*p)[10];
int (*p)(int char) 保存函數地址
定義函數，調用函數。
int func(int a,int b)
{
xxxx
}
int main()
{
func(10,2);
}
舉例：lesson2/002.c
void main()
{
void *p;
p = (void *)printf;
int(*myshow)(const char *,...);
printf("printf() addr:%p\n",p);
myshow = (int (*)(const char *,...))p;
myshow("myshow\n");
myshow("P:%p,M:%p\n",printf,myshow);
}
2.輸入參數（值得傳遞，地址的傳遞）
承上啟下的功能
調用者：
函數名（要傳遞的數據） //實參
背調者：
函數的具體實現
函數的返回值 函數名（接受的數據）//形參 只開辟空間 用於放數據
{
具體的實現
}
數據流向 ： 實參 -----》 形參
傳遞的形式：拷貝；
舉例：lesson2/003.c
void myswap(int buf)
{
char str[20];
strncpy(str,(char *)(buf),20);
printf("The buf is:%x\n",buf);
printf("str:%s",str);
}
void main()
{
int a = 0x20;
char *p = "hello world!\n";
myswap(p);
void (*func)(int);
func = myswap;
char *T = "My is func !\n";
func(T);
}
--------值傳遞------------------------------
#include <stdio.h>
void swap(int a ,int b)
{
int temp;
temp = a;
a = b;
b = temp;
}
void main()
{
int a =30, b =10;
int c ;
printf("This a :%d,b:%d\n",a,b);
#ifdef A
c =a;
a =b;
b =c;
printf("This a :%d,b:%d\n",a,b);
#endif
#ifdef B
swap(a,b);
printf("This a :%d,b:%d\n",a,b);
#endif
}
結果：004-1 / -D A a:30,b:10 a:10 b:30
004-2 / -D B a:30,b:10 a:30 b:10
上層調用者保護自己的空間不被修改的能力
---------地址傳遞----------------------------
#include <stdio.h>
void swap(int *a ,int*b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
void main()
{
int a =30, b =10;
int c ;
printf("This a :%d,b:%d\n",a,b);
#ifdef A
c =a;
a =b;
b =c;
printf("This a :%d,b:%d\n",a,b);
#endif
#ifdef B
swap(&a,&b);
printf("This a :%d,b:%d\n",a,b);
#endif
}
結果：005-1 / -D A a:30,b:10 a:10 b:30
005-2 / -D B a:30,b:10 a:10 b:30
上層，調用者讓下層子函數 修改自己的空間值得方式
連續空間的傳遞的方式使用地址傳遞
註意修飾符 const 只讀空間
int a
scanf("%d",&a);
-------------連續空間的傳遞------------------------
1.數組
數組名 --- 標簽(地址)
實參：
int abc[10];
fun(abc);
形參：
void fun(int *p)(推薦) <====> void fun (int p[10])
2.結構體
結構體變量
struct abc{
int a,b,c;
};
struct abc buf;
實參：
fun(buf); fun(&buf)
形參：
void fun(struct abc buf_t)---->浪費空間 void fun(struct abc *buf_p)---->節約空間
連續空間的傳遞的方式使用地址傳遞
sprintf(char *str ,const char*format,...)
空間傳遞：
1.子函數只看空間裏面的內容情況 —--+ const void func(const char *string);
2.子函數修改上層空間裏面的內容
空間與空間操作註意要素：1.首地址 2.結束標誌
結束標誌：內存裏面存放了0x00（1B），針對於字符空間的結束標誌 。
非字符空間0x00不是結束標誌，只是表示當前狀態。
字符空間操作模板：
void fun(char *p)
{
int i;
while(p[i]){
p[i] 操作 p[i] = x a = p[i] + -
i++
}
}
非字符空間(不已0x00作為結束標誌 )
int *p unsigned char *p short *p struct abc *p void *p(任何類型)
結束標誌：數量（Byte）
void fun(unsigned char *p ,int size) ===升級====> void fun(void *p,int size)
{
int i;
for(i=0;i<size;i++){
p[i] = ;
a =p[i]
++ -- + -
}
}
//內存拷貝
void *memcpy(void *dest，const void *str,size_t size);
ssize_t recv(int sockfd,void *buf,size_t len,int flags);
ssize_t send(int sockfd ,const void *buf,size_t len,int flags);
======================================================================
函數三要素之返回值（出口參數---啟下作用（返回值 地址傳遞））
基本語法：
返回類型 函數名稱（輸入列表）
{
return （返回信息）
}
調用者：
返回值接受 = fun();
被調者：
int fun ()
{
int ret;
xxxxx
return ret ;
}
拷貝
返回數據類型：
基本類型
指針類型（空間）
指針作為空間返回的唯一數據類型
int *fun（）
地址：指向的合法性
作為函數的設計者，必須保證函數返回的地址所指向的空間是合法。（不是局部變量）
使用者：
int *fun()
int *p = fun();
函數內部實現
基本數據類型返回：
基本數據類型 fun()
{
基本數據類型 ret
ret = xxx;
return ret;
}
返回數據類型為地址空間：
char *fun() =====> 錯誤 函數返回局部變量地址 ====》改變將局部變量轉化成靜態區
{
char buf[] = "hello wolrd\n";
return buf;
}
升級 （局部變量地址轉化到）=== 靜態區 只讀區 堆區
char * fun(void)
{
char *str = (char *)malloc(sizeof(char)*100);
strcpy(str,"hello wolrd\n");
return str;
}
======================================================================================
常見面試題解析：
預處理器（Preprocessor）
1 . 用預處理指令#define 聲明一個常數，用以表明1年中有多少秒（忽略閏年問題）
#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在這想看到幾件事情：
1) #define 語法的基本知識（例如：不能以分號結束，括號的使用，等等）
2)懂得預處理器將為你計算常數表達式的值，因此，直接寫出你是如何計算一年中有多少秒而不是計算出實際的值，是更清晰而沒有代價的。
3) 意識到這個表達式將使一個16位機的整型數溢出-因此要用到長整型符號L,告訴編譯器這個常數是的長整型數。
4) 如果你在你的表達式中用到UL（表示無符號長整型），那麽你有了一個好的起點。記住，第一印象很重要。
2 . 寫一個"標準"宏MIN ，這個宏輸入兩個參數並返回較小的一個。
#define MIN(A,B) （（A） <= (B) ? (A) : (B)) 這個測試是為下面的目的而設的：
1) 標識#define在宏中應用的基本知識。這是很重要的。因為在 嵌入(inline)操作符 變為標準C的一部分之前，宏是方便產生嵌入代碼的唯一方法，對於嵌入式系統來說，為了能達到要求的性能，嵌入代碼經常是必須的方法。
2)三重條件操作符的知識。這個操作符存在C語言中的原因是它使得編譯器能產生比if-then-else更優化的代碼，了解這個用法是很重要的。
3) 懂得在宏中小心地把參數用括號括起來
4) 我也用這個問題開始討論宏的副作用，例如：當你寫下面的代碼時會發生什麽事？
least = MIN(*p++, b);
3. 預處理器標識#error的目的是什麽？
如果你不知道答案，請看參考文獻1。這問題對區分一個正常的夥計和一個書呆子是很有用的。只有書呆子才會讀C語言課本的附錄去找出象這種問題的答案。當然如果你不是在找一個書呆子，那麽應試者最好希望自己不要知道答案。
死循環（Infinite loops）
4. 嵌入式系統中經常要用到無限循環，你怎麽樣用C編寫死循環呢？ 這個問題用幾個解決方案。
我首選的方案是：
while(1)
{
}
一些程序員更喜歡如下方案：
for(;;)
{
}
這個實現方式讓我為難，因為這個語法沒有確切表達到底怎麽回事。如果一個應試者給出這個作為方案，我將用這個作為一個機會去探究他們這樣做的基本原理。如果他們的基本答案是："我被教著這樣做，但從沒有想到過為什麽。"這會給我留下一個壞印象。
第三個方案是用 goto
Loop:
...
goto Loop;
應試者如給出上面的方案，這說明或者他是一個匯編語言程序員（這也許是好事）或者他是一個想進入新領域的BASIC/FORTRAN程序員。
數據聲明（Data declarations）
5. 用變量a給出下面的定義
a) 一個整型數（An integer）
b)一個指向整型數的指針（ A pointer to an integer）
c)一個指向指針的的指針，它指向的指針是指向一個整型數（ A pointer to a pointer to an intege）r
d)一個有10個整型數的數組（ An array of 10 integers）
e) 一個有10個指針的數組，該指針是指向一個整型數的。（An array of 10 pointers to
integers）
f) 一個指向有10個整型數數組的指針（ A pointer to an array of 10 integers）
g) 一個指向函數的指針，該函數有一個整型參數並返回一個整型數（A pointer to a function
that takes an integer as an argument and returns an integer）
h) 一個有10個指針的數組，該指針指向一個函數，該函數有一個整型參數並返回一個整型數（ An array of ten pointers to functions that take an integer argument and return an integer ）
答案是：
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that
takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to
functions that take an integer argument and return an
integer
人們經常聲稱這裏有幾個問題是那種要翻一下書才能回答的問題，我同意這種說法。當我寫這篇文章時，為了確定語法的正確性，我的確查了一下書。但是當我被面試的時候，我期望被問到這個問題（或者相近的問題）。因為在被面試的這段時間裏，我確定我知道這個問題的答案。應試者如果不知道所有的答案（或至少大部分答案），那麽也就沒有為這次面試做準備，如果該面試者沒有為這次面試做準備，那麽他又能為什麽出準備呢？
Static
6. 關鍵字static的作用是什麽？
這個簡單的問題很少有人能回答完全。在C語言中，關鍵字static有三個明顯的作用：
1)在函數體，一個被聲明為靜態的變量在這一函數被調用過程中維持其值不變。
2) 在模塊內（但在函數體外），一個被聲明為靜態的變量可以被模塊內所用函數訪問，但不能被模塊外其它函數訪問。它是一個本地的全局變量。
3) 在模塊內，一個被聲明為靜態的函數只可被這一模塊內的其它函數調用。那就是，這個函數被限制在聲明它的模塊的本地範圍內使用。
大多數應試者能正確回答第一部分，一部分能正確回答第二部分，同是很少的人能懂得第三部分。這是一個應試者的嚴重的缺點，因為他顯然不懂得本地化數據和代碼範圍的好處和重要性。
Const
7．關鍵字const有什麽含意？
我只要一聽到被面試者說："const意味著常數"，我就知道我正在和一個業余者打交道。去年Dan
Saks已經在他的文章裏完全概括了const的所有用法，因此ESP(譯者：Embedded Systems
Programming)的每一位讀者應該非常熟悉const能做什麽和不能做什麽.如果你從沒有讀到那篇文章，只要能說出const意味著"只讀"就可以了。盡管這個答案不是完全的答案，但我接受它作為一個正確的答案。（如果你想知道更詳細的答案，仔細讀一下Saks的文章吧。）
如果應試者能正確回答這個問題，我將問他一個附加的問題：下面的聲明都是什麽意思？
const int a;
int const a;
const int *a;
int * const a;
int const * a const;
/******/
前兩個的作用是一樣，a是一個常整型數。第三個意味著a是一個指向常整型數的指針（也就是，整型數是不可修改的，但指針可以）。第四個意思a是一個指向整型數的常指針（也就是說，指針指向的整型數是可以修改的，但指針是不可修改的）。最後一個意味著a是一個指向常整型數的常指針（也就是說，指針指向的整型數是不可修改的，同時指針也是不可修改的）。如果應試者能正確回答這些問題，那麽他就給我留下了一個好印象。順帶提一句，也許你可能會問，即使不用關鍵字 ，也還是能很容易寫出功能正確的程序，那麽我為什麽還要如此看重關鍵字const呢？我也如下的幾下理由：
1) 關鍵字const的作用是為給讀你代碼的人傳達非常有用的信息，實際上，聲明一個參數為常量是為了告訴了用戶這個參數的應用目的。如果你曾花很多時間清理其它人留下的垃圾，你就會很快學會感謝這點多余的信息。（當然，懂得用const的程序員很少會留下的垃圾讓別人來清理的。）
2) 通過給優化器一些附加的信息，使用關鍵字const也許能產生更緊湊的代碼。
3) 合理地使用關鍵字const可以使編譯器很自然地保護那些不希望被改變的參數，防止其被無意的代碼修改。簡而言之，這樣可以減少bug的出現。
Volatile
8. 關鍵字volatile有什麽含意?並給出三個不同的例子。
一個定義為volatile的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到這個變量時必須每次都小心地重新讀取這個變量的值，而不是使用保存在寄存器裏的備份。下面是volatile變量的幾個例子：
1) 並行設備的硬件寄存器（如：狀態寄存器）
2) 一個中斷服務子程序中會訪問到的非自動變量(Non-automatic variables)
3) 多線程應用中被幾個任務共享的變量
回答不出這個問題的人是不會被雇傭的。我認為這是區分C程序員和嵌入式系統程序員的最基本的問題。搞嵌入式的家夥們經常同硬件、中斷、RTOS等等打交道，所有這些都要求用到volatile變量。不懂得volatile的內容將會帶來災難。 假設被面試者正確地回答了這是問題（嗯，懷疑是否會是這樣），我將稍微深究一下，看一下這家夥是不是直正懂得volatile完全的重要性。
1)一個參數既可以是const還可以是volatile嗎？解釋為什麽。
2); 一個指針可以是volatile 嗎？解釋為什麽。
3); 下面的函數有什麽錯誤：
int square(volatile int *ptr)
{
return *ptr * *ptr;
}
下面是答案：
1)是的。一個例子是只讀的狀態寄存器。它是volatile因為它可能被意想不到地改變。它是const因為程序不應該試圖去修改它。
2); 是的。盡管這並不很常見。一個例子是當一個中服務子程序修該一個指向一個buffer的指針時。
3) 這段代碼有點變態。這段代碼的目的是用來返指針*ptr指向值的平方，但是，由於*ptr指向一個volatile型參數，編譯器將產生類似下面的代碼：
int square(volatile int *ptr)
{
int a,b;
a = *ptr;
b = *ptr;
return a * b;
}
由於*ptr的值可能被意想不到地該變，因此a和b可能是不同的。結果，這段代碼可能返不是你所期望的平方值！正確的代碼如下：
long square(volatile int *ptr)
{
int a;
a = *ptr;
return a * a;
}
位操作（Bit manipulation）
9. 嵌入式系統總是要用戶對變量或寄存器進行位操作。給定一個整型變量a，寫兩段代碼，第一個設置a的bit 3，第二個清除a 的bit 3。在以上兩個操作中，要保持其它位不變。 對這個問題有三種基本的反應
1)不知道如何下手。該被面者從沒做過任何嵌入式系統的工作。
2) 用bit fields。Bit fields是被扔到C語言死角的東西，它保證你的代碼在不同編譯器之間是不可移植的，同時也保證了的你的代碼是不可重用的。我最近不幸看到 Infineon為其較復雜的通信芯片寫的驅動程序，它用到了bit fields因此完全對我無用，因為我的編譯器用其它的方式來實現bit fields的。從道德講：永遠不要讓一個非嵌入式的家夥粘實際硬件的邊。
3) 用 #defines 和 bit masks 操作。這是一個有極高可移植性的方法，是應該被用到的方法。最佳的解決方案如下：
#define BIT3 (0x1 << 3)
static int a;
void set_bit3(void)
{
a |= BIT3;
}
void clear_bit3(void)
{
a &= ~BIT3;
}
一些人喜歡為設置和清除值而定義一個掩碼同時定義一些說明常數，這也是可以接受的。我希望看到幾個要點：說明常數、|=和&=~操作。
訪問固定的內存位置（Accessing fixed memory locations）
10. 嵌入式系統經常具有要求程序員去訪問某特定的內存位置的特點。
在某工程中，要求設置一絕對地址為0x67a9的整型變量的值為0xaa66。編譯器是一個純粹的ANSI編譯器。寫代碼去完成這一任務。這一問題測試你是否知道為了訪問一絕對地址把一個整型數強制轉換（typecast）為一指針是合法的。這一問題的實現方式隨著個人風格不同而不同。典型的類似代碼如下：
int *ptr;
ptr = (int *)0x67a9;
*ptr = 0xaa55;
A more obscure approach is: ( 一個較晦澀的方法是)：
*(int * const)(0x67a9) = 0xaa55;
即使你的品味更接近第二種方案，但我建議你在面試時使用第一種方案。
中斷（Interrupts）
11.
中斷是嵌入式系統中重要的組成部分，這導致了很多編譯開發商提供一種擴展—讓標準C支持中斷。具代表事實是，產生了一個新的關鍵字 __interrupt。下面的代碼就使用了__interrupt關鍵字去定義了一個中斷服務子程序(ISR)，請評論一下這段代碼的。
__interrupt double compute_area (double radius)
{
double area = PI * radius * radius;
printf("\nArea = %f", area);
return area;
}
這個函數有太多的錯誤了，以至讓人不知從何說起了：
1)ISR 不能返回一個值。如果你不懂這個，那麽你不會被雇用的。
2) ISR 不能傳遞參數。如果你沒有看到這一點，你被雇用的機會等同第一項。
3) 在許多的處理器/編譯器中，浮點一般都是不可重入的。有些處理器/編譯器需要讓額處的寄存器入棧，有些處理器/編譯器就是不允許在ISR中做浮點運算。此外，ISR應該是短而有效率的，在ISR中做浮點運算是不明智的。
4) 與第三點一脈相承，printf()經常有重入和性能上的問題。如果你丟掉了第三和第四點，我不會太為難你的。不用說，如果你能得到後兩點，那麽你的被雇用前景越來越光明了。
代碼例子（Code examples）
12 . 下面的代碼輸出是什麽，為什麽？
void foo(void)
{
unsigned int a = 6;
int b = -20;
(a+b > 6) ? puts("> 6") : puts("<= 6");
}
這個問題測試你是否懂得C語言中的整數自動轉換原則，我發現有些開發者懂得極少這些東西。不管如何，這無符號整型問題的答案是輸出是 ">6"。原因是當表達式中存在有符號類型和無符號類型時所有的操作數都自動轉換為無符號類型。因此-20變成了一個非常大的正整數，所以該表達式計算出的結果大於6。這一點對於應當頻繁用到無符號數據類型的嵌入式系統來說是豐常重要的。如果你答錯了這個問題，你也就到了得不到這份工作的邊緣。
13. 評價下面的代碼片斷：
unsigned int zero = 0;
unsigned int compzero = 0xFFFF;
/*1‘s complement of zero */
對於一個int型不是16位的處理器為說，上面的代碼是不正確的。應編寫如下：
unsigned int compzero = ~0;
這一問題真正能揭露出應試者是否懂得處理器字長的重要性。在我的經驗裏，好的嵌入式程序員非常準確地明白硬件的細節和它的局限，然而PC機程序往往把硬件作為一個無法避免的煩惱。
到了這個階段，應試者或者完全垂頭喪氣了或者信心滿滿誌在必得。如果顯然應試者不是很好，那麽這個測試就在這裏結束了。但如果顯然應試者做得不錯，那麽我就扔出下面的追加問題，這些問題是比較難的，我想僅僅非常優秀的應試者能做得不錯。提出這些問題，我希望更多看到應試者應付問題的方法，而不是答案。不管如何，你就當是這個娛樂吧...
動態內存分配（Dynamic memory allocation）
14.
盡管不像非嵌入式計算機那麽常見，嵌入式系統還是有從堆（heap）中動態分配內存的過程的。那麽嵌入式系統中，動態分配內存可能發生的問題是什麽？這裏，我期望應試者能提到內存碎片，碎片收集的問題，變量的持行時間等等。這個主題已經在ESP雜誌中被廣泛地討論過了（主要是 P.J. Plauger, 他的解釋遠遠超過我這裏能提到的任何解釋），所有回過頭看一下這些雜誌吧！讓應試者進入一種虛假的安全感覺後，我拿出這麽一個小節目：下面的代碼片段的輸出是什麽，為什麽？
char *ptr;
if ((ptr = (char *)malloc(0)) == NULL)
puts("Got a null pointer");
else
puts("Got a valid pointer");
這是一個有趣的問題。最近在我的一個同事不經意把0值傳給了函數malloc，得到了一個合法的指針之後，我才想到這個問題。這就是上面的代碼，該代碼的輸出是"Got a valid pointer"。我用這個來開始討論這樣的一問題，看看被面試者是否想到庫例程這樣做是正確。得到正確的答案固然重要，但解決問題的方法和你做決定的基本原理更重要些。
Typedef
15 Typedef
在C語言中頻繁用以聲明一個已經存在的數據類型的同義字。也可以用預處理器做類似的事。例如，思考一下下面的例子：
#define dPS struct s *
typedef struct s * tPS;
以上兩種情況的意圖都是要定義dPS 和 tPS 作為一個指向結構s指針。哪種方法更好呢？（如果有的話）為什麽？
這是一個非常微妙的問題，任何人答對這個問題（正當的原因）是應當被恭喜的。答案是：typedef更好。思考下面的例子：
dPS p1,p2;
tPS p3,p4;
第一個擴展為
struct s * p1, p2;
上面的代碼定義p1為一個指向結構的指，p2為一個實際的結構，這也許不是你想要的。第二個例子正確地定義了p3 和p4 兩個指針。
晦澀的語法
16 . C語言同意一些令人震驚的結構,下面的結構是合法的嗎，如果是它做些什麽？
int a = 5, b = 7, c;
c = a+++b;
這個問題將做為這個測驗的一個愉快的結尾。不管你相不相信，上面的例子是完全合乎語法的。問題是編譯器如何處理它？水平不高的編譯作者實際上會爭論這個問題，根據最處理原則，編譯器應當能處理盡可能所有合法的用法。因此，上面的代碼被處理成：c = a++ + b;
因此, 這段代碼持行後a = 6, b = 7, c = 12。
如果你知道答案，或猜出正確答案，做得好。如果你不知道答案，我也不把這個當作問題。我發現這個問題的最大好處是這是一個關於代碼編寫風格，代碼的可讀性，代碼的可修改性的好的話題。
嵌入式LInux之C語言提升篇---Skr Skr Up Up