指针与数组的关系和malloc动态分配空房间

思考1： 

    2个指针变量能否同时指向1个变量，要是这样做了，会有什么不好的后果?

若指针类型不一致，很可能导致修改过程中出现错误。尽量避免这种写法。

若类型一致暂时没找到毛病，但这肯定不是一个好习惯。避免这种写法。

思考2：

     const的指针与数组的关系，数组是可以看作const的指针，还是说数组就是const的指针？

附上代码：

#include<stdio.h>
void text(int array[], int *const p1, const int *p2);
int  main()
{
     int array[] = {1,2,3,4,5,6};
     int array1[] = {1,2,3,4,5,6};
     int array2[] = {1,2,3,4,5,6};
     int *const p1 = array1;
     const int *p2 = array2;
     text(array, p1, p2);
     return 0;
}
void text(int array[], int *const p1, const int *p2)
{
    printf("Opreation1:\n");
    printf("array[0] = %d\n", array[0]);
    printf("*p1 = %d\n*p2 = %d\n", *p1, *p2);
    
    array++, p2++;
    printf("Opreation2:\n");
    printf("array[0] = %d\n", array[0]);
    printf("p2 = %d\n", *p2);
    
    *array = *array + 1, *p1 = *p1 + 1;
    printf("Opreation3:\n");
    printf("array[0] = %d\n", array[0]);
    printf("p1 = %d\n", *p1);
}

这里通过一个自定义函数，可以对const的两种指针变量做的操作经过验证全部可以对数组变量做

即：数组变量可以实现自身地址改变的操作，也可以实现自身值的改变操作。

但对于const的两种指针变量，均不能单独实现这两种操作，

所以说数组就是const的指针，且功能更加强大。

数组还有一个很有意思的地方，可以试试：

 int a[] = {1,2,3,4,5,6,7};
    printf("a = %p\n", a);
    printf("&a = %p\n", &a);
    printf("a + 1 = %p\n", a + 1);
    printf("&a + 1 = %p\n", &a + 1);

一开始a和&a的值是相等的，但加了1之后就不等了。（差了28个字节）

即a是数组首元素的地址，&a是整个数组的地址。

a++的地址是数组第2个元素的地址，而&a++则是整个数组接下来的地址。

思考3：

    malloc动态分配空间比较有意思，附代码和运行结果如下:

代码：

    int *p =(int*) malloc (0);
    int *q =(int*) malloc (0);
    int *p1 = (int*) malloc (0);
    int *q1 = (int*) malloc (0);
    printf("p = %p\nq = %p\n",p, q);
    printf("p1 = %p\nq1 = %p\n", p1, q1);

    int *p2 =(int*) malloc (1);
    int *q2 =(int*) malloc (1);
    int *p3 = (int*) malloc (1);
    int *q3 = (int*) malloc (1);
    printf("p2 = %p\nq2 = %p\n", p2, q2);
    printf("p3 = %p\nq3 = %p\n", p3, q3);

运行结果：

p = 00000000001713E0
q = 0000000000171400
p1 = 0000000000171420
q1 = 0000000000171440

p2 = 0000000000179DC0
q2 = 0000000000179DE0
p3 = 0000000000179E00
q3 = 0000000000179E20
000000000062FDDC
000000000062FDD8

有趣的是，相邻的4次动态分配地址每次虽然不是相邻的，但很默契的差了32个字节。这其中有什么深明大义呢？动手查查。