介紹

我們在日常的嵌入式開發(fā)中，經(jīng)常會遇到各種C/C++的使用問題，并且C/C++純軟件的常用開發(fā)技巧有些嵌入式并不常用，而嵌入式開發(fā)中使用到的C/C++知識與技巧有些也非常特別，這里我們來具體介紹一下嵌入式開發(fā)常C/C++知識。

必備知識

include “filename.h”’和include <filename.h>有什么區(qū)別？

“filename.h”是從本項目里搜索filename.h，<filename.h> 是從標(biāo)準(zhǔn)庫里搜索filename.h文件

靜態(tài)/非靜態(tài)、全局/局部 相關(guān)知識

問題：“靜態(tài)全局變量”和“非靜態(tài)全局變量”有什么區(qū)別？ “靜態(tài)局部變量”和“非靜態(tài)局部變量”有什么區(qū)別？ “靜態(tài)函數(shù)”和“非靜態(tài)函數(shù)”有什么區(qū)別？
靜態(tài)全局變量只在本文件中定義，其他文件不能引用.
局部變量所在函數(shù)每次調(diào)用的時候都會被重新分配存儲空間，函數(shù)結(jié)束后，就會回收該存儲空間。靜態(tài)局部變量不會，始終保持當(dāng)前值。

calloc 和 malloc 有什么區(qū)別？

calloc在動態(tài)分配完內(nèi)存后，將內(nèi)存空間置為零。malloc不初始化，里邊數(shù)據(jù)是隨機(jī)的臟數(shù)據(jù)。

static

靜態(tài)全局變量：在全局變量前，加上關(guān)鍵字static，該變量就被定義成為一個靜態(tài)全局變量。靜態(tài)變量在應(yīng)用層面上主要是限定作用域。
靜態(tài)全局變量有以下特點：

1. 該變量在全局?jǐn)?shù)據(jù)區(qū)分配內(nèi)存

2. 未經(jīng)初始化的靜態(tài)全局變量會被程序自動初始化為0（在函數(shù)體內(nèi)聲明的自動變量的值是隨機(jī)的，除非它被顯式初始化，而在函數(shù)體外被聲明的自動變量也會被初始化為0）

3. 靜態(tài)全局變量在聲明它的整個文件都是可見的，而在文件之外是不可見的
   靜態(tài)變量都在全局?jǐn)?shù)據(jù)區(qū)分配內(nèi)存，包括后面將要提到的靜態(tài)局部變量。對于一個完整的程序，在內(nèi)存中的分布情況：

代碼區(qū)low address全局?jǐn)?shù)據(jù)區(qū)堆區(qū)棧區(qū)high address

一般程序把新產(chǎn)生的動態(tài)數(shù)據(jù)存放在堆區(qū)，函數(shù)內(nèi)部的自動變量存放在棧區(qū)。自動變量一般會隨著函數(shù)的退出而釋放空間，靜態(tài)數(shù)據(jù)（即使是函數(shù)內(nèi)部的靜態(tài)局部變量）也存放在全局?jǐn)?shù)據(jù)區(qū)。全局?jǐn)?shù)據(jù)區(qū)的數(shù)據(jù)并不會因為函數(shù)的退出而釋放空間。
定義全局變量就可以實現(xiàn)變量在文件中的共享，但定義靜態(tài)全局變量還有以下好處：

1. 靜態(tài)全局變量不能被其它文件所用

2. 其它文件中可以定義相同名字的變量，不會發(fā)生沖突

• static在函數(shù)中的用法
  當(dāng)函數(shù)中定義一個static變量，除了第一次調(diào)用這個函數(shù)會定義這個變量以外，其他情況下，均不會重新定義了。下面舉個例子，對比靜態(tài)變量和常規(guī)變量在函數(shù)調(diào)用中的區(qū)別。

執(zhí)行此程序，主函數(shù)會先調(diào)用三次staticFun();函數(shù)，再調(diào)用三次NostaticFun();函數(shù)。最后的輸出結(jié)果為：

123111

因為每次NostaticFun中的data 都會被重新定義，而staticFun中的data不會重復(fù)定義。

const

修飾變量

用來修飾不可賦值的變量，如果一個變量在聲明初始化之后不希望被修改，可以聲明為const；
const修飾的變量應(yīng)該進(jìn)行初始化；
const修飾的變量有可能改變，部分編譯器可用scanf修改；
const常用來修飾函數(shù)的形參，保證該參數(shù)在函數(shù)內(nèi)部不會被修改。

修飾指針

1. const修飾指針——常量指針( const int *p = &a )，指針的指向可以修改，但是指針指向的值不可以修改。

2. const修飾常量——指針常量( int * const p = &a )，指針的指向不可以修改，但是指針指向的值可以修改。

3. const即修飾指針，又修飾常量(const int * const p = &a )，指針的指向不可以修改，指針指向的值也不可以修改.

extren

extern表明變量或者函數(shù)是定義在其他其他文件中的。用來修飾外部變量(全局)，表示該變量在其他文件中定義。首先講一下聲明與定義，
聲明不等于定義，聲明只是指出了變量的名字，并沒有為其分配存儲空間；定義指出變量名字同時為變量分配存儲空間，定義包含了聲明。extern是用來聲明全局變量的。注意：在程序中一個變量可以聲明多次，但只能定義一次。

volatile

volatile提醒編譯器它后面所定義的變量隨時都有可能改變，因此編譯后的程序每次需要存儲或讀取這個變量的時候，告訴編譯器對該變量不做優(yōu)化，都會直接從變量內(nèi)存地址中讀取數(shù)據(jù)，從而可以提供對特殊地址的穩(wěn)定訪問。如果沒有volatile關(guān)鍵字，則編譯器可能優(yōu)化讀取和存儲，可能暫時使用寄存器中的值，如果這個變量由別的程序更新了的話，將出現(xiàn)不一致的現(xiàn)象。（簡潔的說就是：volatile關(guān)鍵詞影響編譯器編譯的結(jié)果，用volatile聲明的變量表示該變量隨時可能發(fā)生變化，與該變量有關(guān)的運(yùn)算，不要進(jìn)行編譯優(yōu)化，以免出錯）。

c語言內(nèi)存分配方式

1. 從靜態(tài)存儲區(qū)域分配：由編譯器自動分配和釋放，在程序編譯的時候就已經(jīng)分配好內(nèi)存，這塊內(nèi)存在程序的整個運(yùn)行期間都存在，直到整個程序運(yùn)行結(jié)束時才被釋放，如全局變量與static變量。

2. 在棧上分配
   同樣由編譯器自動分配和釋放，在函數(shù)執(zhí)行時，函數(shù)內(nèi)部的局部變量都可以在棧上創(chuàng)建，函數(shù)執(zhí)行結(jié)束時，這些存儲單元將被自動釋放。
   （需要注意的是，棧內(nèi)存分配運(yùn)算內(nèi)置于處理器的指令集中，它的運(yùn)行效率一般很高，但是分配的內(nèi)存容量有限。）

3. 從堆上分配
   也稱為動態(tài)分配內(nèi)存，由程序員手動完成申請和釋放。程序在運(yùn)行的時，由程序員使用內(nèi)存分配函數(shù)（如malloc函數(shù)）來申請內(nèi)存，使用完之后再由程序員自己負(fù)責(zé)使用內(nèi)存釋放函數(shù)（如free函數(shù)）來釋放內(nèi)存。
   （需要注意的是，如果在堆上分配了內(nèi)存空間，就必須及時釋放它，否則將會導(dǎo)致運(yùn)行的程序出現(xiàn)內(nèi)存泄漏等錯誤）

變量的作用域及生命周期

1.全局變量

從靜態(tài)存儲區(qū)域分配，其作用域是全局作用域，也就是整個程序的生命周期內(nèi)都可以使用。如果程序是由多個源文件構(gòu)成的，那么全局變量只要在一個文件中定義，就可以在其他所有的文件中使用，但必須在其他文件中通過使用extern關(guān)鍵字來聲明該全局變量。

2.全局靜態(tài)變量

從靜態(tài)存儲區(qū)域分配，其生命周期也是與整個程序同在的，從程序開始到結(jié)束一直起作用。與全局變量不同的是，全局靜態(tài)變量作用域只在定義它的一個源文件內(nèi)，其他源文件不能使用。

3.局部變量

從棧上分配，其作用域只是在局部函數(shù)內(nèi)，在定義該變量的函數(shù)內(nèi)，只要出了該函數(shù)，該局部變量就不再起作用，也即該變量的生命周期和該函數(shù)同在。

4.局部靜態(tài)變量

從靜態(tài)存儲區(qū)域分配，其在第一次初始化后就一直存在直到程序結(jié)束。該變量的特點是其作用域只在定義它的函數(shù)內(nèi)可見，出了該函數(shù)就不可見了。

內(nèi)存對齊（結(jié)構(gòu)體內(nèi)存大小規(guī)則）

基礎(chǔ)知識

在 C/C++ 中，結(jié)構(gòu)體/類是一種復(fù)合數(shù)據(jù)類型，其構(gòu)成元素既可以是基本數(shù)據(jù)類型（如int、long、float等）的變量，也可以是一些復(fù)合數(shù)據(jù)類型（如數(shù)組、結(jié)構(gòu)、聯(lián)合等）的數(shù)據(jù)單元。編譯器為每個成員按其自然邊界（alignment）分配空間。各個成員按照它們被聲明的順序在內(nèi)存中順序存儲，第一個成員的地址和整個結(jié)構(gòu)的地址相同。

如果一個變量的內(nèi)存地址正好位于它長度的整數(shù)倍，他就被稱做自然對齊。如果在 32 位的機(jī)器下，一個int類型的地址為0x00000004，那么它就是自然對齊的。同理，short 類型的地址為0x00000002，那么它就是自然對齊的。char 類型就比較 “隨意” 了，因為它本身長度就是 1 個字節(jié)。自然對其的前提下：

char ? 偏移量為sizeof(char) ? 即 1 的倍數(shù) short ?偏移量為sizeof(short) ?即 2 的倍數(shù) int ? ?偏移量為sizeof(int) ? ?即 4 的倍數(shù) float ?偏移量為sizeof(float) ?即 4 的倍數(shù) double 偏移量為sizeof(double) 即 8 的倍數(shù)

結(jié)構(gòu)體的總大小為最大對齊數(shù)（每個成員變量都有一個對齊數(shù)）的整數(shù)倍

實例解析

1. 在設(shè)置結(jié)構(gòu)體或類時，不考慮內(nèi)存對齊問題，會浪費(fèi)一些空間，例如實驗一：

struct asd1{ ? ?char a; ? ?int b; ? ?short c; };//12字節(jié) struct asd2{ ? ?char a; ? ?short b; ? ?int c; };//8字節(jié)

上面兩個結(jié)構(gòu)體擁有相同的數(shù)據(jù)成員 char、short 和 int，但由于各個成員按照它們被聲明的順序在內(nèi)存中順序存儲，所以不同的聲明順序?qū)е铝私Y(jié)構(gòu)體所占空間的不同。具體如下圖：

2. 看到上面的第二張圖，有的人可能會有疑問，為什么 short 不是緊挨著 char 呢？其實這個原因在上面已經(jīng)給出了答案——自然對齊。為此，我們可以創(chuàng)建結(jié)構(gòu)體驗證自然對齊的規(guī)則。實驗很簡單，在原本 short 類型變量前后添加 char 類型，看結(jié)果是怎樣的。實驗二：

struct asd3{ ? ?char a; ? ?char b; ? ?short c; ? ?int d; };//8字節(jié) struct asd4{ ? ?char a; ? ?short b; ? ?char c ? ?int d; };//12字節(jié)

3. 當(dāng)數(shù)據(jù)成員中有 double 和 long 時，情況又會有一點變化。還是以上面的結(jié)構(gòu)體 asd1 和 asd2 為基礎(chǔ)，都添加 double 型數(shù)據(jù)成員。來看看結(jié)果是什么，實驗三：

struct asd1{ char a; int b; short c; double d; };//24個字節(jié) struct asd2{ char a; short b; int c; double d; };//16個字節(jié)

只添加了一個 double，但 struct asd1 的大小從 12 變到了 24。而 struct asd2 的大小從 8 變到了 16。不需要迷惑，因為這和 double 的自然對其有關(guān)(需要注意)。原本的 asd1 占 12 個字節(jié)大小，但是 double 對齊需要是 8 的倍數(shù)，所以在 short 后面又填充了 4 個字節(jié)。此時，asd1 的占 16 個字節(jié)，再加上 double 的 8 個字節(jié)就成了 24 個字節(jié)。而 asd2 沒有這個問題，它原本占 8 個字節(jié)。因為正好能對齊，所以添加 double 后占 16 個字節(jié)。具體情況如下圖所示：

4. 指定對齊值
在缺省情況下，C 編譯器為每一個變量或是數(shù)據(jù)單元按其自然對界條件分配空間。一般地，可以通過下面的方法來改變?nèi)笔〉膶鐥l件：
使用偽指令 #pragma pack (n)，C 編譯器將按照 n 個字節(jié)對齊。
使用偽指令 #pragma pack ()，取消自定義字節(jié)對齊方式。

實驗四：

#pragma pack(4) struct asd5{ ? ?char a; ? ?int b; ? ?short c; ? ?float d; ? ?char e; };//20 #pragma pack() #pragma pack(1) struct asd6{ ? ?char a; ? ?int b; ? ?short c; ? ?float d; ? ?char e; };//12 #pragma pack()

使用 #pragma pack (value) 指令將結(jié)構(gòu)體按相應(yīng)的值進(jìn)行對齊。兩個結(jié)構(gòu)體包含同樣的成員，但是卻相差 8 個字節(jié)。難道我們只需要通過簡單的指令就能完成內(nèi)存對齊的工作嗎？其實不是的。上面的對齊結(jié)果如下：

以 32 位機(jī)器為例，CPU 取的字長是 32 位。所以上面的對齊結(jié)果會這樣帶來的問題是：訪問未對齊的內(nèi)存，處理器需要作兩次內(nèi)存訪問。如果我要獲取 int 和 float 的數(shù)據(jù)，處理器需要訪問兩次內(nèi)存，一次獲取 “前一部分” 的值，一次獲取 “后一部分” 的值。這樣做雖然減少了空間，但是增加訪問時間的消耗。其實最理想的對齊結(jié)果應(yīng)該是：

ps.使用 #pragma pack(4) 可以讓前面的實驗三中的 asd1 少占用 4 字節(jié)。

對其原則

對齊原則

1. 數(shù)據(jù)類型自身的對齊值：對于 char 型數(shù)據(jù)，其自身對齊值為1，對于 short 型為2，對于 int，float，double 類型，其自身對齊值為 4，單位字節(jié)。

2. 結(jié)構(gòu)體或者類的自身對齊值：其成員中自身對齊值最大的那個值。

3. 指定對齊值：#pragma pack (value) 時的指定對齊值 value。

4. 數(shù)據(jù)成員、結(jié)構(gòu)體和類的有效對齊值：自身對齊值和指定對齊值中小的那個值。

共用體

根據(jù)實際情況，有時需要把幾種類型不同的數(shù)據(jù)，如一個整型變量、一個字符變量、一個實型變量存放在起始地址相同的同一段存儲單元種。這三個變量在內(nèi)存種所占的字節(jié)數(shù)不同，但都從同一個地址開始存放。這種幾個類型不同的變量共同占用同一段內(nèi)存的結(jié)構(gòu)，稱為“共用體”類型結(jié)構(gòu)。共用體，也稱為聯(lián)合體。

union 共用體名 { ? ?成員表列 };

共用體變量的所有成員共享同一段存儲空間，這個存儲空間等于共用體變量種占據(jù)內(nèi)存字節(jié)數(shù)最多的成員的字節(jié)數(shù)。

‘##’連接符

##用來連接前后兩個參數(shù)，把它們變成一個字符串。
例子如下：

#define main(x,y) x##yint xy=1;cout < < main(x,y) < < endl;

將會使編譯器把
cout < < main(x,y) < < endl;
解釋為
cout < < xy < < endl;
理所當(dāng)然,將會在標(biāo)準(zhǔn)輸出處顯示’1’。
從此可以看出，x##y的效果就是將x和y連在一起了。
而#define main(x,y) x##y 則相當(dāng)于把main(x,y)等價于x##y

宏定義與條件變量

#if…#else…#endif

我們在調(diào)試程序時，經(jīng)常會遇到某段功能的實現(xiàn)，寫了兩種版本的程序，但調(diào)試時又不想來回切換。，這時候我們可以使用條件變量。
比如：想測試__set_FAULTMASK(1);和__disable_fault_irq();的區(qū)別，就可以使用如下方式，只需要更改#if后面是1還是0就可以選擇是使用哪段程序。

#if 1// ? __set_FAULTMASK(1); ? ? ? ?NVIC_SystemReset(); #else __disable_irq(); delay_ms(1000); ?__disable_fault_irq(); ? ?NVIC_SystemReset(); ? ?#endif

string.h 庫函數(shù)（以memcpy函數(shù)為例）

C庫函數(shù)是我們開發(fā)過程中必不可少的，其中面試中突出考察的大多為string.h中的庫函數(shù)。
memcpy函數(shù)的用法，memcpy （void* _Dst,void const* _Src,size_t _Size）
memcpy函數(shù)是將后面地址的內(nèi)容一個數(shù)據(jù)一個數(shù)據(jù)放在前面的地址，注意，是先放低位。
_Size是字節(jié)數(shù)，也就是說如果是32位數(shù)組，兩個數(shù)組值就應(yīng)該是_Size就應(yīng)該是4。
例子：

char a[8]={0x12,0x34,0x56,0x78,0x90,0x14,0x52,0x46 };short b=0;memcpy(&b,a+1,2);printf("b=%x", b);此段代碼的作用是把0x34和0x56拼接起來送到b，輸出的最終結(jié)果是：0x5634。

void 指針

void 指針可以指向任意類型的數(shù)據(jù)，就是說可以用任意類型的指針對 void 指針對 void 指針賦值。如果要將 void 指針 p 賦給其他類型的指針，則需要強(qiáng)制類型轉(zhuǎn)換，就本例而言：a=（int *）p。在內(nèi)存的分配中我們可以見到 void 指針使用：內(nèi)存分配函數(shù) malloc 函數(shù)返回的指針就是 void * 型，用戶在使用這個指針的時候，要進(jìn)行強(qiáng)制類型轉(zhuǎn)換，也就是顯式說明該指針指向的內(nèi)存中是存放的什么類型的數(shù)據(jù) (int?)malloc(1024) 表示強(qiáng)制規(guī)定 malloc 返回的 void?指針指向的內(nèi)存中存放的是一個個的 int 型數(shù)據(jù)。

int *Q；void *P； P=Q；

我們可以看到void指針類型是可以指向int *指針類型的。

指針大小

在64位系統(tǒng)中，不管什么樣的基類型，系統(tǒng)指針給指針變量分配的內(nèi)存空間都是8字節(jié)，在C語言中，指針變量的“基類型”僅用來指定該指針變量可以指向的變量類型，并沒有其他意思。 不管基類型是什么類型的指針變量，他仍然是指針變量，所以仍然占用 8 字節(jié)。

%*c

%*c表示忽略一個字符

strstr()

此函數(shù)在嵌入式的日常開發(fā)中使用頻繁，功能為：在字符串 A中查找第一次出現(xiàn)字符串B的位置。
C 標(biāo)準(zhǔn)庫 - <string.h>
C 庫函數(shù) char *strstr(const char *haystack, const char *needle) 在字符串 haystack 中查找第一次出現(xiàn)字符串 needle 的位置，不包含終止符 ‘\0’。

atoi()

C 標(biāo)準(zhǔn)庫 - <stdlib.h
描述
C 庫函數(shù) int atoi(const char *str) 把參數(shù) str 所指向的字符串轉(zhuǎn)換為一個整數(shù)（類型為 int 型）。

rename()

描述
C 庫函數(shù) int rename(const char *old_filename, const char *new_filename) 把 old_filename 所指向的文件名改為 new_filename。
參數(shù)
old_filename – 這是 C 字符串，包含了要被重命名/移動的文件名稱。
new_filename – 這是 C 字符串，包含了文件的新名稱。

面試?yán)}

敘述題

1. 請按時間復(fù)雜度對以下排序方法進(jìn)行分類
   a) 快速排序； b) 冒泡排序； c) 歸并排序； d) 堆排序； e) 插入排序

O(n^2):b、e
O(n*logn):a、c、d

1. #define sum(a, b) a + b
   好嗎？ 如果不好，如何糾正？
   可以改為#define sum(a, b) （（a）+（b））

2. 給出變量“a”的以下定義
   a) An integer
   b) A pointer to an integer
   c) A pointer to a pointer to an integer
   d) An array of 10 integers
   e) An array of 10 pointers to integer
   f) 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) An array of ten pointers to functions that take an integer argument and return an integer
   a) int a;
   b) int *a;
   c) int **a;
   d) int a[10];
   e) int *a[10];
   f) int (*a)[10];
   g) int (*a)(int);
   h) int (*a[10])(int);

3. 以下函數(shù)的輸出是什么？ 為什么？
   void foo(void)
   {
   unsigned int a = 6;
   int b = -20;
   (a+b > 6) ? puts(“> 6”) : puts(“<= 6”);
   }
   應(yīng)該是“>6”，因為表達(dá)式中存在有符號類型和無符號類型，所有的數(shù)都自動轉(zhuǎn)換為無符號類型。因此-20的代表的不再是負(fù)數(shù)，而是一個很大的數(shù)字，所以結(jié)果也變?yōu)楹艽蟮臄?shù)。

4. 讀C程序，下面運(yùn)行測試功能時的每個結(jié)果是什么。
   （1）

void GetMemory(char *p){p = (char *)malloc(100);}void Test(void){char *str = NULL;GetMemory(str);strcpy(str, "hello world");printf(str);}

解答;會崩潰：因為GetMemory 并不能傳遞動態(tài)內(nèi)存，Test 函數(shù)中的 str 一直都是 NULL。strcpy(str, “hello world”);將使程序崩潰；動態(tài)申請內(nèi)存有可能失敗，所以應(yīng)該增加判斷；
執(zhí)行GetMemory之后，p得到新分配的空間地址，str依然為NULL；
沒有對內(nèi)存進(jìn)行回收free()，局部變量存在棧區(qū)，malloc()在堆區(qū)；
局部變量在函數(shù)執(zhí)行完畢之后回收?？臻g；
調(diào)用時傳遞進(jìn)去的參數(shù)是str的一份備份。既然是備份，那么無論函數(shù)內(nèi)部如何操作，都只是操作它的備份，與原本的str值沒有關(guān)系。所以Test里的str經(jīng)過GetMemory之后仍然是原本定義時的NULL，使用strcpy字符串到NULL時自然就會發(fā)生段錯誤。另外，如果第7行不初始化為NULL，編譯時不會報錯，但是，它就成了野指針野指針野指針啊，操作野指針是很危險的；
一級指針傳遞的函數(shù)內(nèi)部更改不影響實參一級指針的值，所以此處要么使用二級指針，要么使用引用。

（2）

char *GetMemory(void){char p[] = "hello world";return p;}void Test(void){char *str = NULL;str = GetMemory();printf(str);}

解答：亂碼：char p[ ]是函數(shù)內(nèi)部局部自動變量，存在于“棧內(nèi)存（stack）”中，當(dāng)GetMemory函數(shù)運(yùn)行結(jié)束之后p的內(nèi)存釋放了，將它返回給調(diào)用者去操作就自然出錯；
有些初學(xué)者可能會好奇，明明以前開發(fā)時，經(jīng)常會用到函數(shù)返回值，沒出現(xiàn)過亂碼?造成這種不同的原因，其實是因為返回類型的不一樣，函數(shù)返回的是返回值副本，如果你返回的是一個值那無所謂，這個值本身就是你需要的，但如果像上述程序一樣返回的是一個指針地址，因為此地址的指向的棧內(nèi)存已經(jīng)釋放了，那你讀取的就是臟數(shù)據(jù)了。也就是亂碼。
（3）

Void GetMemory2(char **p, int num){*p = (char *)malloc(num);}void Test(void){char *str = NULL;GetMemory(&str, 100);strcpy(str, "hello");printf(str);}

解答：正常輸出hello
（4）

void Test(void){char *str = (char *) malloc(100);strcpy(str, “hello”);free(str);if(str != NULL){strcpy(str, “world”);printf(str);}}

解答：str的動態(tài)內(nèi)存已經(jīng)被釋放

代碼題

1. 實現(xiàn)一個函數(shù)“revstr()”，不允許使用任何C標(biāo)準(zhǔn)庫函數(shù)，定義函數(shù)原型，返回輸入字符串的反轉(zhuǎn)。

char *revstr(char *str, size_t len){ ? ?char ? ?*start = str; ? ?char ? ?*end = str + len - 1; ? ?char ? ?ch; ? ?if (str != NULL) ? ?{ ? ? ? while (start < end) ? ? ? { ? ? ? ch = start; end=ch; start=end; ? ? ? *start++; *end--; ? ? ? } } ? ?return str;}

1. 字符串小寫轉(zhuǎn)大寫

//將字符串中的小寫字母轉(zhuǎn)換為大寫//str:要轉(zhuǎn)換的字符串//len：字符串長度void litterTobig(u8 *str,u8 len){ u8 i; for(i=0;i<len;i++) { if((96<str[i])&&(str[i]<123)) //小寫字母 str[i]=str[i]-32; //轉(zhuǎn)換為大寫 }}

1. 字符串大寫轉(zhuǎn)小寫

int8_t* CapToLow(int8_t* str){ ? ?int i; ? ?for (i = 0; i < sizeof(str); i++) ? ?{ ? ? ? ?if ((64 < str[i]) && (str[i] < 91)) //大寫 ? ? ? ? ? ?str[i] = str[i] + 32; ? ? ? ? ? //小寫 ? ?} ? ?return str;}

1. 將某幾位清0，并保留其他位的狀態(tài)
   使用”&= ~"進(jìn)行清零。
   我們以下面的程序為例：

uint32_t ultmp;ultmp=0x12345678;ultmp&= ~(0XFFFF0000);printf("ultmp=0x%d\n",ultmp);

上述程序的作用就是將ultmp的高16位 置0，低16位保留.
最后輸出的結(jié)果是0x00005678。

后續(xù)

這里知識幫大家總結(jié)一下，有什么錯誤的地方歡迎指正。

關(guān)注微信公眾號

編寫不易，感謝支持。