C语言学习笔记

Char ** 与Char * 与Char

char  str[10] = "hello" 占10个字节

str = &str[0] ， 也等于 "hello"的首地址。

Char *a 占四个字节 32位 用来保存地址

Sizeof（a）=4  Sizeof（str）=10

可以a=str 但是不能str=a

数组名可以复制给指针表示地址，但是却不能赋给数组名，因为他是一个常量不能修改。

字符指针可以用 间接操作符 *取其内容，也可以用数组的下标形式 [ ]，数组名也可以用 *操作，因为它本身表示一个地址

其中 *str就是首字节h

a表示单元中所保存的地址 而&a表示变量本身所在内存的单元地址

而如 char *a[ ] = {"China","French","America","German"}；

Sizeof(a)=16

由于[ ] 的优先级高于* 所以a先和 [ ]结合，他还是一个数组，数组中的元素才是char * ，前面讲到char * 是一个变量，保存的地址

printf("%p %p %p %p\n",a[0],a[1],a[2],a[3]); //数组元素中保存的地址
printf("%p %p %p %p\n",&a[0],&a[1],&a[2],&a[3]);//数组元素单元本身的地址

char **为二级指针， s保存一级指针 char *的地址

例：

 char *a [ ] = {"China","French","America","German"};

 char **s =   a;

组名a代表数组元素内存单元的首地址，即 a = &a[0] = 0012FF38;

 而 0x12FF38即 a[0]中保存的又是 00422FB8 ,这个地址， 00422FB8为字符串"China"的首地址。

 即 *s = 00422FB8 = "China";

 但还是要注意，不能a = s，前面已经说到，a 是一个常量

 char **s = "hello world";是不行的

虽然都是地址， 但是指向的类型不一样，因此，不能这样用。，从其本质来分析，"hello world",代表一个地址，比如0x003001,这个地址中的内容是 'h'，为 char 型，而 s 也保存一个地址 ，这个地址中的内容(*s) 是char *　，是一个指针类型，　所以两者类型是不一样的

用char**s时 要给它分配一个内存地址。

      char  **s ;

      s = (char **) malloc(sizeof(char**));

      *s =  "hello world";

      这样 s 给分配了了一个可用的地址，比如 s = 0x412f;

      然后在 0x412f所在的内存中的位置，保存 "hello world"的值

Volatile关键字作用

Volatile与优化有关，编译器在进行数据流分析时，会消除一些代码，但有时这种优化并不是程序所需的，所以需要用Volatile关键字禁用这种优化。他更可以被倾向理解为“直接存取原始内存地址”

例1：

比如要往某一地址送两指令：

int *ip =...;      //设备地址

*ip = 1;         //第一个指令

*ip = 2;        //第二个指令

以上程序compiler可能做优化而成：

int *ip = ...;

*ip = 2;

结果第一个指令丢失。如果用volatile, compiler就不允许做任何的优化，从而保证程序的原意：

volatile int *ip = ...;

*ip = 1;

*ip = 2;

即使你要compiler做优化，它也不会把两次付值语句间化为一。它只能做其它的优化。

几个应用场景：

（1）中断服务程序中修改的供其它程序检测的变量需要加volatile

例如:

static int i=0;

int main(void)

{

     ...

     while (1){

         if (i) dosomething();

     }

｝

/* Interrupt service routine. */

void ISR_2(void)

{

      i=1；

}

     程序的本意是希望ISR_2中断产生时，在main函数中调用dosomething函数，但是，由于编译器判断在main函数里面没有修改过i，因此可能只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致dosomething永远也不会被调用。如果将变量加上volatile修饰，则编译器保证对此变量的读写操作都不会被优化（肯定执行）。此例中i也应该如此说明。

（2）多任务环境下各任务间的共享标志位应该加Volatile

（3）存储器映射的硬件寄存器通常也要加voliate，因为每次对它的读写都可能有不同意义。

int  *output = (unsigned  int *)0xff800000;//定义一个IO端口；

int   init(void)

{

      int i;

      for(i=0;i< 10;i++){

         *output = i;

}

}

        经过编译器优化后，编译器认为前面循环半天都是废话，对最后的结果毫无影响，因为最终只是将output这个指针赋值为9，所以编译器最后给你编译编译的代码结果相当于*output直接被赋值为了9。

Volatile本质：

1> 编译器的优化

       在本次线程内, 当读取一个变量时，为提高存取速度，编译器优化时有时会先把变量读取到一个寄存器中；以后，再取变量值时，就直接从寄存器中取值；当变量值在本线程里改变时，会同时把变量的新值copy到该寄存器中，以便保持一致。

       当变量在因别的线程等而改变了值，该寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致。（参考APUE二版10.15节，267页，最下方：当变量被不同的线程——main函数和异步执行的信号处理程序访问时，将该变量设置为volatile类型）

      当该寄存器在因别的线程等而改变了值，原变量的值不会改变，从而造成应用程序读取的值和实际的变量值不一致。

2>volatile应该解释为“直接存取原始内存地址”比较合适，“易变的”这种解释简直有点误导人。

Const关键字

1.作用

用const定义后，该常量就不能再被改变。

2与#define相比的优点

1.预编译指令只是对值进行简单的替换，不能进行类型检查。

2.可以保护被修饰的变量，防止意外修改，增强程序的健壮性。

3.在C++语言中编译器通常不为普通的const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

3.与static对比

static修饰的变量为静态变量，存储再全局（静态）区,生命周期从程序编译到运行结束。

const修饰的变量不会存放在全局（静态）区，而是取决于它定义的地方，局部定义的就存在栈区，全局定义的就存放在静态区。

4. 变量指针，指针变量与指向常量的常指针：

常量指针是指针指向的内容是常量，下面两种定义方式是相同的：

const int *n;

int const *n;

常量指针说的是不能通过这个指针改变变量的值（但是可以通过其他方式改变变量的值）。

int a=5;

const int* n=&a;

a=6;

printf("%d",a); //此时打印出来a=6

*n=7；//报错，*n是不可修改的左值

printf（“%d”,a）; //通过指针解引用的方式找到a的值去改变，这种方法不可行，因为定义了常量指针

还有一点重要的是常量指针指向的值不能改变，但是这部意味着指针本身不能改变，常量指针也可以指向其他地方的地址。

int a=5;

int b=6;

const int*n=&a;

n=&b;

指针常量是指指针本身是个常量，不能再指向其他的地址，写法如下： int  * const n；

如下是使用的例子

int a=5;

int b=6;

int *const n=&a;

printf("%d",a);

*n=7;

printf("%d",a);  //此时可以打印出来a的值为7，也就是可以通过指针解引用的方式改变指向的值

n=&b； //此时报错，不允许，因为定义了指针常量

我们不难发现指针常量和常量指针的区别就在于星号的位置：Int const *n是常量指针 int *const n是指针常量。