首先我们来明确一些基础概念

   声明与定义：
   声明 可以出现多次，表述对象的类型。
   定义 只能出现一次，确定对象的类型并分配内存。定义是一种特殊的声明，因为牠为对象分配了内存。

   左值和右值：
   左值 编译时可知，表示的是变量的地址。
   右值 运行时可知，表示的是变量的地址中的内容。
   值得注意的是，C语言包括C++中左值右值都和常量没有必然联系，C语言中还引入了“可修改的左值”的概念，标准规定赋值操作符左侧必须为一个可修改的左值。按照上面的定义，我们可以看到，数组名是一个左值（表示地址，编译时可知），但是是一个不可修改的左值，因此不能把数组名放在赋值操作符的左侧。

   现在让我们来看数组和指针在访问上的差异。

   数组：数组名所表示的地址存在于符号表中，所需地址编译时便可知，直接加上偏移量即可。
   extern char p[]; p[3];
   1.取得符号表中p的地址，并与下标所表示的偏移量相加，生成一个新的地址。
   2.访问上面的地址，取得字符，
   若此时p的定义为指针，则会取到指针所在地址的偏移量处的内容。

   指针：需要先得到指针的值，然后将此值作为地址，再加上偏移量等操作。
   extern char *p; p[3];
   1.取得符号表中p的地址，提取存储于此处的指针。
   2.把下标所表示的偏移量和指针的值相加，生成一个地址。
   3.访问上面的地址，取得字符，
   若此时p的定义为数组，则会把一个char值解释为地址而出错。

   也就是说，编译器是根据声明时的类型来确定访问的方式，声明和定义的不一致就像混用malloc()和delete一样可怕，定义和声明应当匹配。

   另一方面，作为极容易混淆的两个概念，数组和指针必然有相同或者说相通之处，主要有以下三点：
   1.表达式中的数组名被编译器当作一个指向该数组第一个元素的指针。
   2.下标总和指针的偏移量相同。
      对数组的引用例如a[i]总是会被编译器改写为*(a+i)，这是标准规定的编译器必须具有的概念性行为。
   3.在函数参数的声明中，数组名被编译器当作指向该数组第一个元素的指针。
      关于这条，有段挺有意思的小程序可以验证。

   #include <stdio.h>

   char ga[] = "abcdefghijklm";

   void myArrayFunc(char ca[])
   {
       printf("Address of ca = %#x\n", &ca);
       printf("Address of (ca[0]) = %#x\n\n", &(ca[0]));
   }

   void myPointerFunc(char *pa)
   {
       printf("Address of pa = %#x\n", &pa);
       printf("Address of (pa[0]) = %#x\n\n", &(pa[0]));
   }

   int main(int argc, char *argv[])
   {
       printf("Address of ga = %#x\n", &ga);
       printf("Address of (ga[0]) = %#x\n\n", &(ga[0]));
       myArrayFunc(ga);
       myPointerFunc(ga);
       return 0;
   }

   我在VC9下的运行结果为：
   Address of ga = 0x417000
   Address of (ga[0]) = 0x417000

   Address of ca = 0x12fe98
   Address of (ca[0]) = 0x417000

   Address of pa = 0x12fe98
   Address of (pa[0]) = 0x417000

   ca和ca[0]的地址居然不同，是不是很有出乎意料又在情理之中的味道。

   OK,两者在概念层面上的异同基本就是上面这些了，最后谈谈效率。

   访问效率，仅以一维数组为例做个对比。

   //array.c
   void array()
   {
      int a[10];
      int i;
      for(i = 0; i < 10; ++i)
      {
         a[i] = 0;
      }
   }

   //pointer.c
   void pointer()
   {
      int a[10];
      int *p = a;
      int i;
      for (i = 0; i < 10; ++i)
      {
         *p++ = 0;
      }
   }

   从理论上来说，array.c中的a[i] = 0;会被改写为*(a+i) = 0，注意包含对步长的调整，也就是会出现乘法或者移位运算，而pointer.c中仅仅需要将指针的值加1即可，用指针访问的效率更高。

实际情况如何呢？让我们来看看汇编吧。编译器版本：gcc version 3.4.4 (cygming special) (gdc 0.12, using dmd 0.125)

//array.s
    .file   "array.c"
    .text
.globl _array
    .def    _array; .scl    2;  .type   32; .endef
_array:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $72, %esp
    movl    $0, -60(%ebp)
L2:
    cmpl    $9, -60(%ebp)
    jg  L1
    movl    -60(%ebp), %eax
    movl    $0, -56(%ebp,%eax,4)
    leal    -60(%ebp), %eax
    incl    (%eax)
    jmp L2
L1:
    leave
    ret

//pointer.s
    .file   "pointer.c"
    .text
.globl _pointer
    .def    _pointer;   .scl    2;  .type   32; .endef
_pointer:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $72, %esp
    leal    -56(%ebp), %eax
    movl    %eax, -60(%ebp)
    movl    $0, -64(%ebp)
L2:
    cmpl    $9, -64(%ebp)
    jg  L1
    movl    -60(%ebp), %eax
    movl    $0, (%eax)
    leal    -60(%ebp), %eax
    addl    $4, (%eax)
    leal    -64(%ebp), %eax
    incl    (%eax)
    jmp L2
L1:
    leave
    ret

   居然是指针版本在关键的L2循环中执行的指令数量更多，是不是很出人意料，所以，千万不要低估现代编译器的智慧，选择可读性和效率都占优的数组下标访问吧。

    int main(int argc, char *argv[])
    {
       printf("%d\n", sizeof('A'));
       return 0;
    }

   用gcc编译后运行结果为4，用g++编译后运行结果为1。

   说明C语言中默认把单字符视为int，也就是sizeof ('A')默认和sizeof(65)等同，加上强制类型转换sizeof((char)'A')输出的就是期望结果1。

    C++中看来默认把单字符就作为一个char处理，比较符合直觉感受。