數組
開發中數組是一種常見的資料結構，當然我們知道數組相當於一種容器，但是它不僅僅只能存數值和字符，同時它還可以存放函數的入口地址，以及結構體的數據。
typedef struct _value
{
int val_1;
int val_2;
}VALUE;
typedef struct _table
{
char index;
char data[100];
int (*UniSetFunc)(VALUE*);
}TABLE;
int add(VALUE *val )
{
int temp = 0;
temp = val->val_1 + val->val_2;
return temp;
}
TABLE page[10]
{
{“ First section ”, “abcdefghijklmn”, add},
{“Second section”, “opqrstuvwxyz”, NULL}
};
int main()
{
VALUE AddValue;
AddValue.val_1 = 2;
AddValue.val_2 = 4;
int result = 0;
result = page[0]-> UniSetFunc(&AddValue);
printf(“The Result of add is %d\n”, result);
return 0;
}此時數組就轉換為類似於Python語言中的字典的結構，便於後續的開發利用以及追加升級和維護。
程式碼分析：首先我們知道函數的名字可以做為函數的入口位址（類似陣列的名稱代表陣列的位址一樣），所以在TABLE結構體中我們定義了一個成員函式int (*UniSetFunc)(VALUE *); 此處UniSetFunc作為函數的入口參數，VALUE*代表函數的形參類型；TABLE類型的陣列 page[10]即包含了結構體的資料以及函數的入口位址，可以透過呼叫page[0]- > UniSetFunc(&AddValue)來間接呼叫add函數並實作AddValue中AddValue.val_1和AddValue.val_1的兩個數字總和運算。
記憶體命中率問題：
為了可以提高程式碼運作效率，要才充分的利用記憶體空間，應連續的存取記憶體區域。
我們知道數組在記憶體中存放的位置是一整塊的區域，並且是連續存放的，對於定義的數組array[2][2]來說，假設array[0][0]的位址為0x04030 ,則array[0][1]，array[1][0]，array[1][1] 的位址分別為0x04031, 0x04032, 0x04033；提高記憶體命中率的即是應該盡可能的連續的存取記憶體空間區域，而非跳躍式的訪問；接下來讓我們來看一個矩陣相乘的問題。
for (int i = 0; i < 2; ++i)
{
for (int j = 0; j < 2; ++j)
{
for (int k = 0; k < 3; ++k)
{
matrix[i][j] += matrix1[i][k] * matrix2[k][j];
}
}
}以上程式碼是常用的將矩陣matrix1與matrix2相乘然後賦值給matrix的方法，即用matrix1矩陣得到行向量乘以矩陣matrix2的列向量，然後賦值給matrix，這樣由於矩陣在內存存儲的結構，我們可以清楚的知道存取matrix2的時候並非採用連續的存取方式，故記憶體的命中率較低。接下來我們來看一種高記憶體命中率的方法。
for (int i = 0; i < 2; ++i)
{
for (int k = 0; k < 3; ++k)
{
for (int j = 0; j < 2; ++j)
{
matrix[i][j] += matrix1[i][k] * matrix2[k][j];
}
}
}可以看出程式碼僅僅將第二個for迴圈與第三個for迴圈交換了位置，而其他的部分沒有任何變化，然而記憶體的命中率卻大大的提高了，我們採用將matrix1與matrix2矩陣內部各原素依序相乘然後再累加的方式，來進行矩陣相乘的目的，這樣在訪問matrix1與matrix2矩陣時沒有發生任何內存未命中的問題，從而提高了內存命中的機率。
volatile，const以及static之間的關係：
constst ，如const int value = 12；此常數value值不允許程式將其改變，在開發的過程const關鍵字會經常用到，為了防止程式意外的改變某一固定的常數，我們應及時的給其加上const關鍵字；另外const關鍵字作用於常數時必須直接給常數初始化，因為在整個程式運行大的過程中不允許對其改變，故必須立即初始化，例如：const int value = 12 是正確的，而const int value; value = 12;這樣的語法是錯誤的! 接下來我們來研究一個稍微難一點的問題，即常數指標與指標常數。先看一段程式碼：
#define SWITCH 1
int main()
{
int val_1 = 5;
int val_2 = 10;
const int *p1 = &val_1;
int const *p2 = &val_1;
int *const p3 = &val_1;
#ifdef SWITCH // This is a switch
*p1 = 20;
*p2 = 21;
*p3 = 22;
#endif
#ifndef SWITCH
p1 = &val_2;
p2 = &val_2;
p3 = &val_2;
#endif
printf("%d\n", *p1);
printf("%d\n", *p2);
printf("%d\n", *p3);
return 0;
}在cygwin編譯器下執行，我們可以看到這樣的錯誤：
int main()
{
int val_1 = 5;
int val_2 = 10;
const int *p1 = &val_1;
int const *p2 = &val_1;
int *const p3 = &val_1;
printf("Frist\n");
printf("%d\n", *p1);
printf("%d\n", *p2);
printf("%d\n", *p3);
p1 = &val_2;
p2 = &val_2;
*p3 = 22;
printf("Second\n");
printf("%d\n", *p1);
printf("%d\n", *p2);
printf("%d\n", *p3);
return 0;
}const int * const p = &a;或int const *const p = &a; 在定义函数的时候,若该入口参数在程序执行的过程中不希望被改变,则一定要将该形参用const来修饰,一来这样可以防止该段程序将其改变,二来对于形参而言,一个无论是否是const修饰的实参都可以将其传入const形的形参,而一个const形的实参是无法传入非const形的形参中，所以为了使编译不出错在定义函数的时候，一定要将不希望被改变的量用const关键字来修饰。
Static关键字为静态关键字，它的作用是将作用的变量存入内存中，而非存入寄存器中（即将变量存入堆中而非栈中），并且该作用的变量仅保存最近一次获取的值。接下来我们来看一段代码。
void countfun ()
{
static int count = 0;
++count;
printf(“This is %d number, enter into this function !\n”, count );
}
int main()
{
for (int i = 0; i < 5; ++i)
{
countfun();
}
return 0;
}这段代码的运行结果如下：
而若将除去static关键字，则运行的结果如下：
由此我们可以清楚的看出，static作用的变量count只会存入当前的结果，因此循环调用countfun( )函数的时候并没有从新将count变量置为0，而是保存了前一次的值。
Static关键字在项目中的应用是很广泛的，它不仅仅有上述所介绍的特点，同时若想要定义的全局变量在整个工程中仅在当前.C文件中有效时，也应该将这个全局变量用static来修饰，这样在其他的文件中是无法访问这个变量，从而降低了模块间的耦合度，提高了模块的内聚性，防止其他文件将其改变，从而更加的安全。
volatile关键字在嵌入式领域中是十分重要的一个关键字，尤其是在与硬件相关或多线程的编程中更为重要。volatile关键字修饰的变量说明它是可以随时发生改变的，我们不希望编译器去优化某些代码的时候，需要将这个变量用volatile关键字来修饰，从而程序每次访问该变量的时候是直接从内存中提取出来，而不是从临时的寄存器中将该变量的副本给提取出来利用！例如当我们想要实现某个中断处理时，其用来做判断条件的标记位则应该用volatile来修饰，这样当这个中断在别的地方被触发的时候就可以被实时的检测到，不至于由于优化而忽略中断。接下来我们看一段代码：
int main（）
{
volatile int i = 10;
int a = i;
printf(“i = %d\n”, a);
__asm
{
mov dword ptr[ebp-4], 0x10
}
int b = i;
printf(“i = %d\n”, b);
return 0;
}此程序输出结果为i = 10;i = 16; 若将volatile关键字去掉，则结果为i = 10;i = 10;
即不加关键字会将汇编代码忽略掉，所以为了防止代码优化以及可以及时检测到外部程序对该变量的改变，我们必须将该变量加上volatile关键字。我们知道volatile关键字表征该量是易变的，const关键字代表该量是常量不能改变，那么volatile与const是否可以一起修饰同一个量呢，是肯定的，例如在硬件编程中ROM所存储的数据是不允许用户改变的，即指向该数据的指针必须为常量指针（const int *p = &ram_data），然而开发商却可以将其意外的改变，为了防止ROM的内容被意外的改变时，而用户程序没有及时的发现，必须将该量用volatile修饰，所以应这样定义该指针（volatile const int *p = &rom_data）。
位运算
在数字解码与编码的过程中，位运算的操作是司空见惯的事，同时位运算在提高程序的性能方面也独占鳌头，因此位运算操作是必需要深入了解的问题。
在乘法以及除法的操作中我可以使用未运行来提高代码的质量，例如：a = a * 16;这种操作完全可以替换为:a = a << 4;我们知道左移一位相当于将原数乘以2,左移N位则相当于乘以2^N,前提是在没有发生溢出的情况下；故上例即相当于将数a左移4位，对于某些乘以非2的整数幂情况，如 a = a * 9;则可以改写为a = (a << 3) + a; 同理右移相当于除以2的整数幂，当然以上所有情况都是在没有发生数据溢出的情况下，因此位运算操作要格外的小心，否则极有可能发生出错的情况。
在数据类型转换的过程中也需要做位运算操作，例如我们想将一个unsigned short类型的数据存入unsigned char类型的数组中，就需要进行位运算，首先分析知道unsigned short占用16个字节，unsigned char占用8个字节，想要将大字节的数据存入小字节，必须要对大字节进行分割，即将高8位与低8为分离开来分别存放，来看实现代码：
unsigned char * DrawCompo_Pj_BT_Change(unsigned short *subarray)
{
unsigned char temp[500];
(void)_sys_memset(&temp, 0x00, sizeof(temp) );
unsigned short i = 0;
while (subarray[i] != 0x0000)
{
if( (subarray[i] & 0xff00) == 0x0000)
{
temp[i++] = (unsigned char)(subarray[i] & 0x00ff);
}
else
{
temp[i] = (unsigned char)( (subarray[i] & 0xff00) >> 8);
temp[i++] = (unsigned char)(subarray[i] & 0x00ff);
}
}
temp[i] = '\0';
return temp;
}temp[i] = (unsigned char)( (subarray[i] & 0xff00) >> 8);即取subarray[i]数据的高8位，temp[i++] = (unsigned char)(subarray[i] & 0x00ff);取低8位。这样就可以实现将高字节的数据完整的存入到低字节中。
位运算还可以用来判断变量的符号,我们知道对于一个有符号的变量,其最高位为其符号位,故检查改变的最高位即可知道该变量为正还是为负。看一段代码：
int main()
{
short test_data = -12;
if (test_data & 0xF000)
{
printf("This number is negative ");
}
else
{
printf("This number is positive ");
}
return 0;
}对于想要交换两个数的值的时候，通常我们的做法如下：
void swap（int &data1, int &data2）
{
int temp = 0;
temp = data1;
data1 = data2;
data2 = temp;
}这样的代码比较简单易懂，然而美中不足的是它会产生一个临时变量temp,接下来我们用位运算来重写这个程序；
void swap（int &data1, int &data2）
{
data1 = data1 ^ data2;
data2 = data1 ^ data2;
data1 = data1 ^ data2;
}从上面的代码我们可以看出少了一个临时变量，同时也加快了代码的运行效率。
尾递归:
递归调用给我们带来了很多方便,也简化了代码,使程序看起来更加的简洁和明了,但递归调用也通常伴随着一个潜在的危险:出栈，接下来我们来看一个常见的递归。
int factorial(int n)
{
if (n < 1)
{
return 1;
}
else
{
return factorial(n-1)*n;
}
}通常在求一个数的阶乘的时候我们习惯于采用上述方法，然而分析来看当输入的n值较大时，factorial(n-1)*n所计算的值会不断的压入堆栈，生成很多的临时变量，等待下一个的值的确定才得以计算，然而在内存中堆栈的大小是固定的，当输入的n值很大时，极有可能产生堆栈溢出！因此，有一个好的方法解决这种问题即尾递归调用。接下来我们来看这种强大的算法。
int factorial(int n, int m)
{
if (n < 2)
{
return m;
}
else
{
factorial(n-1, n*m);
}
}从代码中可以看出，通过引入一个新的参数m来存放每次递归所产生的值，这样就避免了每次递归都要进行压栈操作，也就不会产生堆栈溢出的现象，而且普通的递归每次递归只能等待下一次递归得到的结果后才能继续运算，而尾递归每次执行都会进行运算，一次循环执行完毕即可得到结果，其时间复杂度为O(n);
