个人理解

int ages[] = {12,23,42,19}
ages其实是一个指针，指向数组的首地址，也就是第一个元素12的地址。
下面用代码进行验证：

.|数组和指针的基本操作有哪些？
.|
数组和指针的基本操作，除了sizeof，其他相同。

  1. 数组+i，获取第i个元素的地址
  2. 数组[i]，获取第i个元素的值
  3. *数组，获取首元素的值
  4. *(数组+i)，获取第i个元素的值
  5. &(数组[i])，获取第i个元素的地址

将上面的数组，替换为指针，同理。

测试代码

  1. #include <stdio.h>
  2. int main(int argc, char *argv[])
  3. {
  4.     char name[] = {'A','l','a','n', '\0'};
  5.     char *vname = name;
  7.     /*
  8.        第一种操作方式：指针+i  == 第i个元素的地址
  9.     */
  10.     printf("%s \n", name+1);   //输出:lan，name+1是第二个元素的地址，又以%s读取，完整的意思是从第二个元素开始读取，一直读取\0截止，所以此处可以读取到lan
  11.     printf("%s \n", vname+1);  //输出:lan，vname与和name都是指针，所以操作相同
  13.     //name+1 等同于 &name[1]
  14.     printf("%s \n", &name[1]); //输出:lan，name[1]='l'，而&name[1]是第二个元素的地址
  16.     /*
  17.        第二种操作方式：指针[i] == 第i个元素的值
  18.     */
  19.     //printf("%s \n", name[1]);  //异常报错，name[1]='l'，ascii码为108，导致读取了地址为108的内存内容，直接导致访问报段错误
  20.     printf("%d \n", name[1]);       //输出：108
  21.     printf("%d \n", vname[1]);      //输出: 108
  23.     /*
  24.        第三种操作方式：*指针 == 取出指针指向地址的值
  25.     */
  26.     //下面两者输出相同的地址，证实name是一个指针，指向第一个元素
  27.     printf("%p \n", name);   //输出：0x7ffc4e166bf3
  28.     printf("%p \n", vname);  //输出：0x7ffc4e166bf3
  29.     printf("%c \n", *name);  //输出: A
  30.     printf("%c \n", *vname); //输出: A
  32.     /*
  33.     指针和数组的区别：
  34.     sizeof(数组) == 数组元素的个数
  35.     sizeof(指针）== 指针地址的字节数,
  36.     */
  37.     printf("%d \n", sizeof(name));  //输出：5, 数组有5个元素
  38.     printf("%d \n", sizeof(vname)); //输出：8, 指针地址为8个字节
  39.     return 0;
  40. }

.|指针和数组：下面代码的输出是什么？
#include
int main(int argc, char argv[])
{
char name[] = {‘A’,’l’,’a’,’n’, ‘\0’};
char vname = name;
printf(“%s \n”, name+1);
printf(“%s \n”, vname+1);
}
.|
name其实是一个指针，指向数组首元素

  1. /*
  2.    第一种操作方式：指针+i  == 第i个元素的地址
  3. */
  4. printf("%s \n", name+1);   //输出:lan，name+1是第二个元素的地址，又以%s读取，完整的意思是从第二个元素开始读取，一直读取\0截止，所以此处可以读取到lan
  5. printf("%s \n", vname+1);  //输出:lan，vname与和name都是指针，所以操作相同

.|指针和数组：下面代码的输出是什么？
#include
int main(int argc, char *argv[])
{
char name[] = {‘A’,’l’,’a’,’n’, ‘\0’};
printf(“%s \n”, &name[1]);
}
.|
name其实是一个指针，指向数组首元素

//name+1 等同于 &name[1] printf(“%s \n”, &name[1]); //输出:lan，name[1]=’l’，而&name[1]是第二个元素的地址

.|指针和数组：下面代码的输出是什么？
#include
int main(int argc, char argv[])
{
char name[] = {‘A’,’l’,’a’,’n’, ‘\0’};
char vname = name;
printf(“%d \n”, name[1]);
printf(“%d \n”, vname[1]);
printf(“%d \n”, (name+1));
printf(“%d \n”, (vname+1));
}
代码输出是什么？
name[1]和(name+1), 是否有区别？
.|
name[1] 等同于 (name+1)

printf(“%d \n”, name[1]); //输出：108 printf(“%d \n”, vname[1]); //输出: 108 printf(“%d \n”, (name+1)); //输出：108 printf(“%d \n”, (vname+1)); //输出: 108

.|指针和数组：下面代码的输出是什么？
#include
int main(int argc, char argv[])
{
char name[] = {‘A’,’l’,’a’,’n’, ‘\0’};
char vname = name; 

  1. printf("%p \n", name); <br />    printf("%p \n", vname);<br />    printf("%c \n", *name);  <br />    printf("%c \n", *vname);<br />}<br />代码输出是什么？<br />name和vname是否相同？<br />.|<br />name[1] 等同于 *(name+1)
  1. /*
  2.    第三种操作方式：*指针 == 取出指针指向地址的值
  3. */
  4. //下面两者输出相同的地址，证实name是一个指针，指向第一个元素
  5. printf("%p \n", name);   //输出：0x7ffc4e166bf3
  6. printf("%p \n", vname);  //输出：0x7ffc4e166bf3
  7. printf("%c \n", *name);  //输出: A
  9. printf("%c \n", *vname); //输出: A

.|指针和数组：下面代码的输出是什么？
#include
int main(int argc, char argv[])
{
char name[] = {‘A’,’l’,’a’,’n’, ‘\0’};
char vname = name;
printf(“%d \n”, sizeof(name));
printf(“%d \n”, sizeof(vname));
}
.|

  1. /*
  3. 指针和数组的区别：
  5. sizeof(数组) == 数组元素的个数
  7. sizeof(指针）== 指针地址的字节数,
  9. */
  11. printf("%d \n", sizeof(name));  //输出：5, 数组有5个元素
  13. printf("%d \n", sizeof(vname)); //输出：8, 指针地址为8个字节