C语言 指针数组
七忆岁和 人气:0前言：指针与数组的知识往往让我们无法给自己定位，似乎是懂了，但真的碰上了又一言难尽。接下来有一些关于指针与数组的知识和例题讲解，来看看你对指针和数组到底有多了解吧！
指针与数组中的sizeof与strlen
sizeof
sizeof值关注占用空间的大小，单位是字节，不关注元素的类型，是一个操作符。
strlen
strlen是计算字符串中\0之前出现了多少个字符，只针对字符串，是一个库函数。
数组名
数组名是数组首元素地址，但是在这里有两个例外：
（1）sizeof（数组名），这里的数组名表示的是整个数组，计算的是整个数组的大小，单位是字节。
（2）&数组名，这里的数组名也表示整个数组，取出的是数组的地址
除了上面两种情况外，所有的数组名表示的都是数组首元素地址。
下面我们就来看一看数组、指针的一些运用
1、一维数组
整型数组
#include<stdio.h>
int main()
{
//一维数组
int a[] = {1,2,3,4};
printf("%d\n",sizeof(a));// 16
printf("%d\n",sizeof(a+0));// 4/8
printf("%d\n",sizeof(*a));// 4
printf("%d\n",sizeof(a+1));// 4/8
printf("%d\n",sizeof(a[1]));// 4
printf("%d\n",sizeof(&a));// 4/8
printf("%d\n",sizeof(*&a));// 16
printf("%d\n",sizeof(&a+1));// 4/8
printf("%d\n",sizeof(&a[0]));// 4/8
printf("%d\n",sizeof(&a[0]+1));// 4/8
return 0;
}接下来我们就一句一句讲解：
sizeof（a）
数组名a单独放在sizeof内部，计算的是整个数组的大小，单位是字节，所以计算结果：4*4=16个字节。
sizeof（a+0）
a没有单独存放，所以表示的是首元素的地址，a+0还是数组首元素的地址，是地址的话大小就是4/8个字节。（在32位环境下为4,64位环境下为8）
sizeof（*a）
a表示的是首元素的地址，*a就是对首元素的地址解引用，所以就是首元素，大小为4个字节
sizeof（a+1）
a表示首元素地址，a+1就是第二个元素的地址，是地址的话大小就是4/8个字节。
sizeof（a[1]）
a[1]表示数组的第二个元素，大小是4个字节。
sizeof（&a）
&a表示的是整个数组的地址，数组的地址也是地址，所以大小为4/8个字节。
sizeof（*&a）
&a是数组的地址，类型是int（*）[4]，是一个数组指针，如果解引用，访问的就是4个int的数组，可以理解为*与&抵消效果，所以*&a相当于a，所以sizrof（a）是16。
sizeof（&a+1）
&a是数组地址，&a+1跳过整个数组后的地址，是地址就是4/8个字节大小。
sizeof（&a[0]）
&a[0]取出的是数组第一个元素的地址，是地址就是4/8个字节大小。
sizeof（&a[0]+1）
&a[0]+1就是第二个元素的地址，是地址大小就是4/8个字节。
字符数组
#include<stdio.h>
int main()
{
//字符数组
char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", sizeof(arr));// 6
printf("%d\n", sizeof(arr+0));// 4/8
printf("%d\n", sizeof(*arr));// 1
printf("%d\n", sizeof(arr[1]));// 1
printf("%d\n", sizeof(&arr));// 4/8
printf("%d\n", sizeof(&arr+1));// 4/8
printf("%d\n", sizeof(&arr[0]+1));// 4/8
printf("%d\n", strlen(arr));// 随机值
printf("%d\n", strlen(arr+0));// 随机值
printf("%d\n", strlen(*arr));// err
printf("%d\n", strlen(arr[1]));// err
printf("%d\n", strlen(&arr));// 随机值
printf("%d\n", strlen(&arr+1));// 随机值
printf("%d\n", strlen(&arr[0]+1));// 随机值
return 0;
}1、sizeof
sizeof（arr）
arr作为数组名单独存放在sizeof内部，计算的是整个数组的大小，所以是6个字节。
sizeof（arr+0）
arr没有单独存放，所以这里的arr表示的是首元素地址，arr+0还是首元素地址，是地址就是4/8个字节大小。
sizeof（*arr）
arr表示数组的首元素地址，*arr表示的就是首元素，由于是char类型，所以是1字节。
sizeof（arr[1]）
arr[1]就是数组中的第二个元素，大小是1字节。
sizeof（&arr）
&arr取出的是数组的地址，地址大小为4/8个字节。
sizeof（&arr+1）
&arr+1跳过了整个数组，还是地址，所以大小为4/8个字节。
sizeof（&arr[0]+1）
&arr[0]是第一个元素的地址，&arr[0]+1就是第二个元素的地址，地址就是4/8个字节。
2、strlen
strlen（arr）
arr是首元素地址，但是arr数组中没有\0，计算的时候不知道什么时候停止，所以结果是随机值。
strlen（arr+0）
arr+0还是首元素地址，同上
strlen（*arr）、strlen（arr[1]）
strlen需要的是一个地址，从这个地址开始向后计算字符，直到碰上\0停止，统计字符的个数，而*arr是首元素'a'，也就是传给strlen的是'a'的ASCII码值97，strlen会把97作为起始地址，统计字符串，会形成内存访问冲突，所以会报错！arr[1]也一样，是第二个元素'b'。
strlen（&arr）
&arr是arr数组的地址，虽然类型和strlen的参数类型有所差异，但是传参过去后，还是从第一个字符的位置向后数字符，而arr数组中没有\0，所以结果还是随机值。
strlen（&arr+1）
跳过整个数组，但还是不知道哪里会出现\0，所以结果还是随机值。
strlen（&arr[0]+1）
&arr[0]表示首元素的地址，&arr[0]+1表示第二个元素的地址，也就是从第二个字符还是往后数，但由于\0不能确定所以还是随机值。
下面这个就用来自测吧！
#include<stdio.h>
int main()
{
char arr[] = "abcdef";
printf("%d\n", sizeof(arr));// 7 整个数组的大小，包括\0
printf("%d\n", sizeof(arr+0));// 4/8
printf("%d\n", sizeof(*arr));// 1
printf("%d\n", sizeof(arr[1]));// 1
printf("%d\n", sizeof(&arr));// 4/8
printf("%d\n", sizeof(&arr+1));// 4/8
printf("%d\n", sizeof(&arr[0]+1));// 4/8
printf("%d\n", strlen(arr));// 6
printf("%d\n", strlen(arr+0));// 6
printf("%d\n", strlen(*arr));// err
printf("%d\n", strlen(arr[1]));// err
printf("%d\n", strlen(&arr));// 6
printf("%d\n", strlen(&arr+1));// 随机值
printf("%d\n", strlen(&arr[0]+1));// 5
return 0;
}指针数组
#include<stdio.h>
int main()
{
char *p = "abcdef";
printf("%d\n", sizeof(p));// 4/8
printf("%d\n", sizeof(p+1));// 4/8
printf("%d\n", sizeof(*p));// 1
printf("%d\n", sizeof(p[0]));// 1
printf("%d\n", sizeof(&p));// 4/8
printf("%d\n", sizeof(&p+1));// 4/8
printf("%d\n", sizeof(&p[0]+1));// 4/8
printf("%d\n", strlen(p));// 6
printf("%d\n", strlen(p+1));// 5
printf("%d\n", strlen(*p));// err
printf("%d\n", strlen(p[0]));// err
printf("%d\n", strlen(&p));// 随机值
printf("%d\n", strlen(&p+1));// 随机值
printf("%d\n", strlen(&p[0]+1));// 5
return 0;
}1、sizeof
sizeof（p）
p是一个指针变量，sizeof（p）计算的是指针变量大小，4/8个字节。
sizeof（p+1）
p是指针变量，用来存放地址的，p+1也是地址，地址大小就是4/8个字节。
sizeof（*p）
*p访问的是字符a，大小1字节。
sizeof（p[0]）
p[0]相当于*（p+0），相当于*p，同上。
sizeof（&p）
&p也是地址，是地址就是4/8个字节。
sizeof（&p+1）
&p是地址，+1是在内存中跳过p变量后的地址，还是地址，所以为4/8字节。
sizeof（&p[0]+1）
p[0]就是a，&p[0]就是a的地址，&p[0]+1就是b的地址，是地址就是4/8个字节。
2、strlen
strlen（p）
这里的p是首元素地址，也就是'a'的地址，strlen（p）就是从'a'的位置向后求字符串的长度，长度是6。
strlen（p+1）
p是首元素地址，p+1就是第二个元素的地址，也就是'b'，从b开始数直到\0，所以长度是5。
strlen（*p）、strlen（p[0]）
*p、p[0]都是首元素'a'，传的是a的ASCII码值，会有警报。
strlen（&p）、strlen（&p+1）
&p是指针p的地址，也就是算p的地址的字符串长度，由于不知道什么时候碰到\0，所以是随机值；&p+1就是跳过p的地址访问字符，\0未知，所以也是随机值。如图：
strlen（&p[0]+1）
&p[0]就是首元素地址，+1就是从第二个元素开始计算，长度为5；p[0]也可以看做*（p+0），也就是*p。
2、二维数组
#include<stdio.h>
int main()
{
//二维数组
int a[3][4] = {0};
printf("%d\n",sizeof(a)); // 48
printf("%d\n",sizeof(a[0][0])); // 4
printf("%d\n",sizeof(a[0])); // 16
printf("%d\n",sizeof(a[0]+1)); // 4/8
printf("%d\n",sizeof(*(a[0]+1)));// 4
printf("%d\n",sizeof(a+1)); // 4/8
printf("%d\n",sizeof(*(a+1))); // 16
printf("%d\n",sizeof(&a[0]+1)); // 4/8
printf("%d\n",sizeof(*(&a[0]+1))); // 16
printf("%d\n",sizeof(*a)); // 16
printf("%d\n",sizeof(a[3])); // 16
return 0;
}sizeof（a）
这里的a表示的是整个数组，所以大小为4*（3*4）=48。
sizeof（a[0][0]）
a[0][0]表示第一行第一列的元素，由于数组是int型，所以一个元素的字节大小为4.
sizeof（a[0]）
a[0]表示第一行的数组名，a[0]作为数组名单独放在sizeof内部，计算的是整个数组大小，即第一行的大小，4*4=16。
sizeof（a[0]+1）
这里的a[0]作为第一行的数组名，没有&，没有单独放在sizeof内部，所以a[0]表示的就是首元素的地址，即a[0][0]的地址，a[0]+1就是第一行第二个元素的地址，是地址就是4/8。
sizeof (*(a[0]+1))
a[0]+1就是第一行第二个元素的地址，对其解引用，就是第一行第二个元素，大小为4。
sizeof（a+1）
a是二维数组的数组名，是类型为 int（*）[4] 的数组指针，没有&，没有单独存放在sizeof内部，a表示首元素的地址，即第一行的地址，a+1就是第二行地址，是地址，大小就为4/8个字节。
sizeof (*(a+1))
（a+1）就是第二行元素的地址，解引用就是第二行的数组名，计算的是第二行的大小，所以大小为16个字节。（ *(a+1) --> a[1] ）
sizeof（&a[0]+1）
a[0]是第一行，&a[0]是地址，&a[0]+1就是第二行的地址，是地址大小就为4/8字节。
sizeof (*(&a[0]+1))
对第二行的地址解引用，也就是a[1]，大小为16字节。
sizeof（*a）
a是二维数组的数组名，没有&，没有单独放在sizeof内部，a表示首元素地址，*a就是二维数组的首元素，也就是第一行，大小为16字节。（ *a --> *(a+0) --> a[0] ）
sizeof（a[3]）
a[3]看起来是越界了，但是计算的时候它会去推导要计算的类型，例如：
int a=10； sizeof（int）和 sizeof（a）计算的大小一样，它会去推导a的类型是int型。同理，它也会去推导a[3]的类型，a[3]的类型是 int [4]，所以大小为16。
通过上面的一些讲解，接下来我们看一些实战题：
指针笔试题
笔试题1
#include<stdio.h>
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int *)(&a + 1);
printf( "%d,%d", *(a + 1), *(ptr - 1));
return 0;
}
//程序的结果是什么？讲解 ：
如图，a是数组名，也就是首元素的地址，a+1就是第二个元素的地址，对（a+1）解引用就是第二个元素2，打印出来2；
ptr是一个指针，指向的是数组的末尾，且被强制转换成int *类型，所以ptr-1跳过的是一个int，对其解引用就是数组的最后一个元素5。
笔试题2
#include<stdio.h>
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
p = (struct Test*)0x100000;
printf("%p\n", p + 0x1);
printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1);
return 0;
}讲解：
已知这里的p是一个结构体指针，p+0x1就相当于结构体指针+1，而这个结构体类型的变量大小是20个字节，也就是加了20个字节，化为十六进制为0x100014；
(unsigned long) p把p强制转换成unsigned long型，这里的p就相当于是一个无符号类型的数，内存里面就默认为存的就是一个普普通通的整形数字，整型数字加1就是加1，所以结果为0x100001;
(unsigned int *)p把p强制转换成unsigned int *，这里的p就是整型指针，而整型指针加1就是加4个字节，所以结果为0x100004。
笔试题3
#include<stdio.h>
int main()
{
int a[4] = { 1, 2, 3, 4 };
int *ptr1 = (int *)(&a + 1);
int *ptr2 = (int *)((int)a + 1);
printf( "%x,%x", ptr1[-1], *ptr2);
return 0;
}
如图，ptr1就是&a+1，跳过整个数组，再强制转换成int * 型，而ptr1[-1]相当于 *（ptr1-1），也就是跳过一个int * 型，所以ptr1[-1]==4，用%x打印出来也是4；
(int *)((int)a + 1)，a是首元素地址，强转换为int型，也就是把这个地址看成普普通通的整型数字，一个整型数字加1就是简简单单的加1，是地址这个数字+1，而不是地址+1，所以跳过的是一个字节。而我们知道数据在内存中的存储分大小端，这里我们以小端为例，如图ptr2指向的是一个整型中的第二个字节，从第二个字节开始取出一个整型，以小端输出，所以结果为02000000。
笔试题4
#include <stdio.h>
int main()
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) };
int *p;
p = a[0];
printf( "%d", p[0]);
return 0;
}讲解：
这里要看清楚题目，数组里面的是圆括号，所以是逗号表达式，数组其实就是
int a[3][2] = { 1, 3, 5 };
p = a[0] 即p指向的是数组的第一行，p[0]就是数组第一行一个元素，所以打印出来是1。
笔试题5
#include<stdio.h>
int main()
{
int a[5][5];
int(*p)[4];
p = a;
printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
return 0;
}这里p是一个数组指针，p指向的数组是4个元素，而a是一个5行5列的数组，如下图：
好了，今天就讲到这里！这些是否让你对数组和指针有了新的看法呢？
加载全部内容