C/C++深度分析

数组

开发中数组是一种常见的数据结构，固然咱们知道数组至关于一种容器，可是它不只仅只能存数值和字符，同时它还能够存放函数的入口地址，以及结构体的数据。

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之间的关系：

const关键字为常量关键字，它做用的量为常量，不容许程序去改变该常量的值，如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编译器下执行，咱们能够看到这样的错误：

从图中咱们能够清楚的看到，指针p1与p2仅能读取val_1中的值为指针常量，即不能改变它所指的变量的内容，因此*p1 = 20; *p2 = 21;两条命令是错误的！(#ifdef SWITCH … #endif 为条件编译即为宏开关)。而后咱们将#define SWITCH 1 语句给注释掉，此时将运行第二块代码，获得结果以下：

 

从错误中能够看出p3为常量指针，它只能指向一个固定的地址，而不能改变它所指的方向，故p3 = &val_2;的操做是错误的，所以正确的代码以下：

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 *p或int const *p）表示指针p不能改变它所指向地址里面所存的值，而能够改变它所指向的地址；指针常量（int *const p）表示指针p不能改变它所指向的地址，即指针不能改变它所指向的位置，可是能够改变它所指的位置中的内容。若想要指针既不能改变所指向的位置，又不能改变该处的内容，那么能够这样定义：

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);