C语言进阶第28式：指针和数组分析（下）

数组名可以当作常量指针使用，那么指针是否也可以当作数组名来使用呢?

数组的访问方式

以下标的形式访问数组中的元素

int main()
{
    int a[5]= {0};
    a[1]= 3;
    a[2] = 5;
    return 0;
}

以指针的形式访问数组中的元素

int main()
{
    int a[5]= {0};
    *(a+ 1)= 3;
    *(a+ 2)= 5;
    return 0;
}

指针以固定增量在数组中移动时，效率高于下标形式；

指针增量为1且硬件具有硬件增量模型时，效率更高；

下标形式与指针形式的转换：

a[n]  ==  *(a + n)  ==  *(n + a)  ==  n[a]

注意:
现代编译器的生成代码优化率已大大提高，在固定增量时，下标形式的效率已经和指针形式相当﹔但从可读性和代码维护的角度来看，下标形式更优。

数组的访问方式示例如下：

#include <stdio.h>

int main()
{
    int a[5] = {0};
    int* p = a;
    int i = 0;
    
    for(i=0; i<5; i++)
    {
        p[i] = i + 1;
    }
    
    for(i=0; i<5; i++)
    {
        printf("a[%d] = %d\n", i, *(a + i));
    }
    
    printf("\n");
    
    for(i=0; i<5; i++)
    {
        i[a] = i + 10;
    }
    
    for(i=0; i<5; i++)
    {
        printf("p[%d] = %d\n", i, p[i]);
    }
    
    return 0;
}

数组与指针的不同示例如下：

#include <stdio.h>

int main()
{
    extern int* a;
    
    printf("&a = %p\n", &a);
    printf("a = %p\n", a);
    printf("*a = %d\n", *a);

    
    return 0;
}

a和&a的区别

a为数组首元素的地址

&a为整个数组的地址

a和&a的区别在于指针运算：
a +1  <=>  (unsigned int)a + sizeof(*a)
&a + 1  <=>  (unsigned int)(&a)+ sizeof(* &a)  <=>  (unsigned int)(&a)+ sizeof(a)

指针运算示例如下：

#include <stdio.h>

int main()
{
    int a[5] = {1, 2, 3, 4, 5};
    int* p1 = (int*)(&a + 1); 
    int* p2 = (int*)((int)a + 1);
    int* p3 = (int*)(a + 1);
    
    printf("%d, %d, %d\n", p1[-1], p2[0], p3[1]);
    
    return 0;
}
// A. 数组下标不能是负数，程序无法运行
// B. p1[-1]将输出随机数，p2[0]输出2， p3[1]输出3
// C. p1[-1]将输出乱码， p2[0]和p3[1]输出2

数组参数

数组作为函数参数时，编译器将其编译成对应的指针；

void f(int a); <=> void f(int* a);

void f(int a[5]); <=> void f(int* a);
结论︰
—般情况下，当定义的函数中有数组参数时，需要定义另一个参数来标示数组的大小。

数组参数示例如下：

#include <stdio.h>

void func1(char a[5])
{
    printf("In func1: sizeof(a) = %d\n", sizeof(a));
    
    *a = 'a';
    
    a = NULL;
}

void func2(char b[])
{
    printf("In func2: sizeof(b) = %d\n", sizeof(b));
    
    *b = 'b';
    
    b = NULL;
}

int main()
{
    char array[10] = {0};
    
    func1(array);
    
    printf("array[0] = %c\n", array[0]);
    
    func2(array);
    
    printf("array[0] = %c\n", array[0]);
    
    return 0;
}

小结

1、数组名和指针仅使用方式相同
              数组名的本质不是指针；
              指针的本质不是数组；
2、数组名并不是数组的地址，而是数组首元素的地址；

3、函数的数组参数退化为指针；