指针和数组，const int *，sizeof，优先级等的一些坑

指针和数组

先瞅一段code
    char *aa="adbs";
    char *bb="adbs";
    char *cc="adbss";
    cout<<"aa addr: "<<static_cast<const void *>(aa)<<endl;
    cout<<"&aa addr: "<<static_cast<const void *>(&aa)<<endl;
    cout<<"bb addr: "<<static_cast<const void *>(bb)<<endl;
    cout<<"&bb addr: "<<static_cast<const void *>(&bb)<<endl;
    char dd[10]="adbs";
    cout<<"dd addr: "<<static_cast<const void*>(&dd)<<endl;
    cout<<"&dd addr: "<<static_cast<const void*>(dd)<<endl;
    输出如下：
    -- aa addr: 0x40149c
    -- &aa addr: 0x7fff037fe3d0
    -- bb addr: 0x40149c
    -- &bb addr: 0x7fff037fe3c8
    -- dd addr: 0x7fff037fe3b0
    -- &dd addr: 0x7fff037fe3b0
    首先指针的地址和指针指向的地址是不同的，指针是个变量，自身需要占据存储单元，指针的地址就是存放该指针的内存单元所在的地址值，那么在这个内存单元里存的值就是该指针指向的对象所在的地址。
    C++对于同样的字符串值，在栈中只存储一份，所以aa，bb指向的字符串是相同的，该字符串在栈中只存在一份，所以aa和bb 存放的地址是一样的。
    指针和数组的一点区别在于，数组自身的地址就是数组中首元素的地址。

const 的一些坑

const是修饰符，const 指向的常量并不是真正意义的常量
1、const int *a
    a 指向一个常量，因此不能通过*a来改变a所指向的对象值。但是a本身可以被赋值。
    const int *a = 0;
    const int b = 1;
    int c = 1;
    a = &b //ok！ 注意不能通过a来修改b的值
    a = &c //ok！ c本身可以不是一个常量
    *a = 2 //error！ 不能通过修改*a来修改c的值
    int *d=&b;
    *d=2;
    printf("%d\n",b);//print 2 ，此时b的值将被改成了2
2、int *const a
const 修饰啊，a是个常量，同时a的类型是个指针，并且指针指向一个int，因此a是个指向int的常量指针。
    int m=1,n=2;
    int * const a=&m;
    m=10；//ok
    printf("%d\n",*a);//print 10
    a=&n;//error，a是个常量

3、int const *a 和 const int *a一个意思 
4、const int * const a 
a所指向的对象的值以及它的地址本身都不能被改变

关于const的点滴补充:
1、const 对象的地址只能赋值给指向const 对象的指针
2、指向const 对象的指针可以 被赋 以 一个非const 对象的地址 
3、指向const 的指针常被用作函数的形式参数，保证被传递给函数的实际对象在函数得实际对象在函数中不会被修改
4、常量在定义后就不能被修改,所以它必须被初始化。未初始化的常量定义将导致编译错误（上面都是在说明const得问题，所以没有赋值，实际语句中要赋值的）

sizeof 的一些坑

char *s="1234";
    char t[10]="123456";
    printf("%d %d %d %d\n",sizeof(*s),sizeof(s),strlen(s),sizeof(t));//1 8 4 10
    int *sss=&a;
    int q=10 *sizeof(*sss);
    int q2=10 *sizeof(sss);
    int mm=sizeof(int)*q;
    printf("%d %d  %d\n",q,q2,mm);//40 80 160

指针数组和数组指针的一些坑

--------------指针数组（首先是个数组）--------------------
int *p[10];//指针数组，含有10个指针元素 
也就是说每一个元素都是指针。先是解析[]表示它是一个数组，然后*表示指针，int表示为int型指针，即表示定义一个指针数组，含有10个int类型指针元素。
--------------数组指针（首先是个指针）--------------------
int (*p)[10];//数组指针，这个指针能够用来指向含有10个元素的整数数组。
先是解析（），括号里表示这个是个指针，然后[]表示数组，即表示定义了一个指向数组的指针。数组指针。

声明和定义的一些坑

同一变量定义只有一个，但是可以声明多次
int a； 是个声明 也是个定义
extern int a； 只是声明
有足够的信息让编译器建立变量的声明 就是一个定义
extern int a=10；//error

优先级的一些坑

1、.的优先级高于*
    *p.f 对p 取f 偏移，作为指针，然后进行解除引用操作 ，相当于*(p.f)
2、[] 的优先级高于*
    int *ap[]   代表ap是个元素为int指针的数组相当于int*(ap[])，而不是指向int数组的指针(int(*ap)[])。 
3、函数()的优先级高于*
    int*fp() fp是个函数，返回int* 相当于int*(fp())
    int(*fp)() fp是个指针，指向的函数返回int
4、==和!=高于位运算符
    (val & mask !=0) 实际上是(val & (mask!=0))
5、== 高于赋值符号
    c=getchar()!=EOF 相当于 c=(getchar()!=EOF)
6、算数运算符高于移位运算符
    msb<<4+lsb相当于 msb<<(4+lsb)