在之前的深入理解指针(4)中我们学习了回调函数相关知识,并且学会了如何使用库函数qsort,以及模拟实现了qsort,接下来在本篇中将对srtlen和sizeof进行细致的讲解,并对相关的题型进行讲解,一起加油吧!!!
1.strlen与sizeof的区别
1.sizeof
在之前学习操作符的时候就已经了解过了sizeof这个操作符,sizeof计算变量所占内存内存空间大小,单位是字节,例如当变量类型是整形时,变量大小和变量类型的大小都是一样的
#inculde <stdio.h> int main() { int a = 10; printf("%d\n", sizeof(a)); printf("%d\n", sizeof(int)); return 0; }
例如以上代码打印结果都是4
2.strlen
strlen是一个用来求字符串长度的函数,计算的是字符串\0之前的字符的个数
strlen 函数会从起始地址一直向后找 \0 字符,直到找到为止,所以可能存在越界查找
函数的原型如下:
size_t strlen(const char * str );
#include<string.h> #include<stdoio.h> int main() {char arr1[]="abc";char arr2[]={'a','b','c'};printf("%d\n",strlen(arr1));printf("%d\n",strlen(arr2));return 0; }
在以上代码中数组arr1中存放的是字符串,数组的末尾包含\0;而数组arr2中存放的是字符,数组的末尾不包含\0,因此当使用strlen函数时,当参数为arr1时,可以求出地址arr1到\0之前元素的个数为3,所以打印结果为3. 但当参数为arr2时,由于原arr2数组中无\0因此会一直向后直到找到\0为止,所以打印出结果为随机数
3.sizeof与strlen的区别
sizeof | strlen |
sizeof是操作符 | strlen是库函数,使⽤需要包含头⽂件 string.h |
sizeof计算操作数所占内存的大小,单位是字节 | srtlen是求字符串(字符数组)⻓度的,统计的是 \0 之前字符的个数 |
不关注内存中存放什么数据 | 关注内存中是否有 \0 ,如果没有 \0 ,就会持续往后找,可能 会越界 |
2.数组和指针笔试题解析
2.1 一维数组
int a[] = {1,2,3,4};
printf("%d\n",sizeof(a));
printf("%d\n",sizeof(a+0));
printf("%d\n",sizeof(*a));
printf("%d\n",sizeof(a+1));
printf("%d\n",sizeof(a[1]));
printf("%d\n",sizeof(&a));
printf("%d\n",sizeof(*&a));
printf("%d\n",sizeof(&a+1));
printf("%d\n",sizeof(&a[0]));
printf("%d\n",sizeof(&a[0]+1));
以上各代码输出结果及解析:
int a[ ] = {1,2,3,4};
printf("%d\n",sizeof(a));数组名a单独放在sizeof中,a表示的是整个数组,计算的是整个数组的大小,单位是字节,又因为数组a中元素类型都为int大小为4字节,所以整个数组大小就为16字节,打印结果为16
printf("%d\n",sizeof(a+0));数组名a不是单独放在sizeof内,所以a表示的是数组首元素的地址,所以sizeof求出的是数组首元素指针的大小,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n",sizeof(*a));数组名a不是单独放在sizeof内,在此a表示的是数组首元素的地址,所以对a解引用后得出的就是数组首元素,因为数组元素为int类型,所以求出结果为4,打印结果为4
printf("%d\n",sizeof(a+1));在此a表示的是数组首元素的地址,在对指针a加一后表示的是数组的第二个元素的地址,所以sizeof求出的是数组首元素指针的大小,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n",sizeof(a[1]));在此a[1]表示的是数组的第一个元素1,因为数组元素为int类型,所以结果为4,打印结果为4
printf("%d\n",sizeof(&a));取地址取出的是整个数组的地址,所以sizeof求出的是整个数组的指针大小,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n",sizeof(*&a));有两种角度分析以上代码:
1.在此次*可以与&消除后sizeof中就剩a,这里的a单独放在sizeof内,sizeof求出的是整个数组的大小,为16字节,打印结果为16
2.在此&a取出的是整个数组的地址,类型为int(*)[4],解引用&a后访问的就是整个数组,数组大小为16字节,打印结果为16
printf("%d\n",sizeof(&a+1));首先&a取出的是整个数组的地址,之后&a+1后的步长就为sizeof(int(*)[4]),为16字节,所以&a+1表示的是跳过整个数组后那个位置的地址,sizeof(&a+1)求出的就是这个位置地址的大小,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n",sizeof(&a[0]));a[0]表示的是数组首元素1,&a[0]就是将首元素1的地址取出,因此sizeof(&a[0])求出的就是首元素的地址大小,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n",sizeof(&a[0]+1));a[0]表示的是数组首元素1,&a[0]就是将首元素1的地址取出,再对&a[0]+1得出的就是数组第二个元素的地址,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
2.2 字符数组
代码1
char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", sizeof(arr));
printf("%d\n", sizeof(arr+0));
printf("%d\n", sizeof(*arr));
printf("%d\n", sizeof(arr[1]));
printf("%d\n", sizeof(&arr));
printf("%d\n", sizeof(&arr+1));
printf("%d\n", sizeof(&arr[0]+1));
char arr[ ] = {'a','b','c','d','e','f'};
printf("%d\n", sizeof(arr));在此数组名单独在sizeodf内表示的是整个数组,有因为每个数组元素为char类型,大小为1字节,所以结果就为6字节,输出结果为6
printf("%d\n", sizeof(arr+0));在此数组名arr不是单独放在sizeof内,因此arr表示的就是数组首元素的地址,又因为sizeof(arr)=sizeof(arr+0),求出的为首元素地址大小,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n", sizeof(*arr));在此数组名arr不是单独放在sizeof内,因此arr表示的就是数组首元素的地址,再对arr解引用后表示的就是数组首元素,所以sizeof(*arr)计算的就是首元素大小,大小为1,输出结果为1
printf("%d\n", sizeof(arr[1]));arr[1]表示的是数组第二个元素b,因为数组arr每个元素类型为都为char,大小为1字节,所以sizeof(arr[1])大小为1,输出结果为1
printf("%d\n", sizeof(&arr));在此&arr取出的是整个数组arr的地址,sizeof(&arr)求出的就是整个数组地址大小,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n", sizeof(&arr+1));在此&arr取出的是整个数组arr的地址,再加一求出的是跳过整个数组那个位置的地址,
在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n", sizeof(&arr[0]+1));arr[0]表示的是数组第一个元素,再&得出首元素的地址,再对该地址加一得到的就是数组第二个元素的地址,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
代码2:
char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", strlen(arr));
printf("%d\n", strlen(arr+0));
printf("%d\n", strlen(*arr));
printf("%d\n", strlen(arr[1]));
printf("%d\n", strlen(&arr));
printf("%d\n", strlen(&arr+1));
printf("%d\n", strlen(&arr[0]+1));
char arr[ ] = {'a','b','c','d','e','f'};
printf("%d\n", strlen(arr));在此数组名arr表示的是数组首元素的地址,由于字符数组arr种无\0,所以从首元素到\0之间的元素个数为随机值,输出结果为随机值
printf("%d\n", strlen(arr+0));在此数组名arr表示的是数组首元素的地址,arr+0表示的还是首元素,由于字符数组arr种无\0,所以从首元素到\0之间的元素个数为随机值,输出结果为随机值
printf("%d\n", strlen(*arr));在此*arr得出的是数组首元素a,在strlen中传参数不为指针时,程序会奔溃
printf("%d\n", strlen(arr[1]));在此arr[1]表示的是数组第二个元素b,在strlen中传参数不为指针时,程序会奔溃
printf("%d\n", strlen(&arr));在此&arr得出的是数组arr的地址,由于字符数组arr种无\0,所以从首元素到\0之间的元素个数为随机值,输出结果为随机值
printf("%d\n", strlen(&arr+1));在此&arr得出的是数组arr的地址,再加一求出的是跳过整个数组那个位置的地址,由于字符数组arr种无\0,所以从这个元素到\0之间的元素个数为随机值,输出结果为随机值
printf("%d\n", strlen(&arr[0]+1));在此&arr[0]得出的是数组首元素的地址,再加一得到的就是第二个元素的地址,由于字符数组arr种无\0,所以从第二个元素到\0之间的元素个数为随机值,输出结果为随机值
代码3:
char arr[] = "abcdef";
printf("%d\n", sizeof(arr));
printf("%d\n", sizeof(arr+0));
printf("%d\n", sizeof(*arr));
printf("%d\n", sizeof(arr[1]));
printf("%d\n", sizeof(&arr));
printf("%d\n", sizeof(&arr+1));
printf("%d\n", sizeof(&arr[0]+1));
char arr[ ] = "abcdef";
printf("%d\n", sizeof(arr));在此数组名arr表示的是数组首元素的地址,所以sizeof内求出的是整个数组的大小为6字节,输出结果为6
printf("%d\n", sizeof(arr+0));在此数组名arr表示的是数组首元素的地址,arr+0表示的还是首元素地址,所以sizeof内求出的是整个数组的大小为6字节,输出结果为6
printf("%d\n", sizeof(*arr));在此*arr得出的是数组首元素a,所以sizeof内求出的是数组首元素的大小为1字节,输出结果为1
printf("%d\n", sizeof(arr[1]));在此arr[1]表示的是数组第二个元素b,所以sizeof内求出的是数组第二个元素的大小为1字节,输出结果为1
printf("%d\n", sizeof(&arr));在此&arr得出的是整个数组arr的地址,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n", sizeof(&arr+1));在此&arr得出的是数组arr的地址,再加一求出的是跳过整个数组那个位置的地址,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n", sizeof(&arr[0]+1));在此&arr[0]得出的是数组首元素的地址,再加一得到的就是第二个元素的地址,所以sizeof内求出的是数组第二个元素的大小为1字节,输出结果为1
代码4:
char arr[] = "abcdef";
printf("%d\n", strlen(arr));
printf("%d\n", strlen(arr+0));
printf("%d\n", strlen(*arr));
printf("%d\n", strlen(arr[1]));
printf("%d\n", strlen(&arr));
printf("%d\n", strlen(&arr+1));
printf("%d\n", strlen(&arr[0]+1));
char arr[ ] = "abcdef";
printf("%d\n", strlen(arr));在此数组名arr表示的是数组首元素的地址,由于字符串arr末尾含有\0,所以从首元素到\0之间的元素个数为6,输出结果为6
printf("%d\n", strlen(arr+0));在此数组名arr表示的是数组首元素的地址,arr+0表示的还是首元素,由于字符串arr末尾含有\0,所以从首元素到\0之间的元素个数为6,输出结果为6
printf("%d\n", strlen(*arr));在此*arr得出的是数组首元素a,在strlen中传参数不为指针时,程序会奔溃
printf("%d\n", strlen(arr[1]));在此arr[1]表示的是数组第二个元素b,在strlen中传参数不为指针时,程序会奔溃
printf("%d\n", strlen(&arr));在此&arr得出的是数组arr的地址,由于字符串arr末尾含有\0,所以从首元素到\0之间的元素个数为6,输出结果为6
printf("%d\n", strlen(&arr+1));在此&arr得出的是数组arr的地址,再加一求出的是跳过整个数组那个位置的地址,而字符数组内的\0已经在该指针前,所以到下一个\0之间的元素个数为随机值,输出结果为随机值
printf("%d\n", strlen(&arr[0]+1));在此&arr[0]得出的是数组首元素的地址,再加一得到的就是第二个元素的地址,由于字符串arr末尾含有\0,所以从第二个元素到\0之间的元素个数为5,输出结果为5
代码5:
char *p = "abcdef";
printf("%d\n", sizeof(p));
printf("%d\n", sizeof(p+1));
printf("%d\n", sizeof(*p));
printf("%d\n", sizeof(p[0]));
printf("%d\n", sizeof(&p));
printf("%d\n", sizeof(&p+1));
printf("%d\n", sizeof(&p[0]+1));
char *p = "abcdef";
在此字符指针中存放了一个常量字符串首元素的地址,指针p表示的是字符串首元素的地址
printf("%d\n", sizeof(p));在此计算的是指针变量p的大小,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n", sizeof(p+1));p+1得到的是字符串中第二个元素b的地址,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n", sizeof(*p));在此p表示的是字符串首元素a的地址,*p是对指针p进行解引用,得到的就是字符串的首元素,在内存空间所占大小为1字节,输出结果为1
printf("%d\n", sizeof(p[0]));
p[0]=*(p+0),在此p[0]得到的就是字符串的首元素,在内存空间所占大小为1字节,输出结果为1
printf("%d\n", sizeof(&p));在此&p得到的是指针变量p的地址,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8 (注:在此&p是一个二级指针)
printf("%d\n", sizeof(&p+1));在此&p得到的是指针变量p的地址,后再加一是跳过了p变量,指向了p后面的地址,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n", sizeof(&p[0]+1));在此p[0]=*(p+0,这时&就可以与*相抵消,得到sizeof(p+1),p+1得到的是字符串中第二个元素b的地址,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
代码6:
char *p = "abcdef";
printf("%d\n", strlen(p));
printf("%d\n", strlen(p+1));
printf("%d\n", strlen(*p));
printf("%d\n", strlen(p[0]));
printf("%d\n", strlen(&p));
printf("%d\n", strlen(&p+1));
printf("%d\n", strlen(&p[0]+1));
char *p = "abcdef";
在此指针变量p存放的是常量字符串中a的地址,同时常量字符串末尾包含\0
printf("%d\n", strlen(p));strlen求出的是首元素到\0之间的元素个数,也就字符串中的元素个数为6,输出结果为6
printf("%d\n", strlen(p+1));p+1得到的是字符串中第二个元素b的地址,strlen求出的是第二个元素到\0之间的元素个数,也就字符串中的元素个数为5,输出结果为5
printf("%d\n", strlen(*p));*p得到的是字符串的首元素a,程序会奔溃
printf("%d\n", strlen(p[0]));在此p[0]=*(p+0),得到就是字符串的首元素a,程序会崩溃
printf("%d\n", strlen(&p));在此&p得到的是指针变量p的地址,而在此地址中无\0需要向后找到\0才停止,所以结果为随机值,输出结果为随机值
printf("%d\n", strlen(&p+1));在此&p得到的是指针变量p的地址,再加上一得到的是跳过过了变量p,指向了后边,而在此地址中无\0需要向后找到\0才停止,所以结果为随机值,输出结果为随机值
printf("%d\n", strlen(&p[0]+1));在此p[0]=*(p+0),&可与*相抵消,最终只剩strlen(p+1),strlen求出的是第二个元素到\0之间的元素个数,也就字符串中的元素个数为5,输出结果为5
2.3 二维数组
int a[3][4] = {0};
printf("%d\n",sizeof(a));
printf("%d\n",sizeof(a[0][0]));
printf("%d\n",sizeof(a[0]));
printf("%d\n",sizeof(a[0]+1));
printf("%d\n",sizeof(*(a[0]+1)));
printf("%d\n",sizeof(a+1));
printf("%d\n",sizeof(*(a+1)));
printf("%d\n",sizeof(&a[0]+1));
printf("%d\n",sizeof(*(&a[0]+1)));
printf("%d\n",sizeof(*a));
printf("%d\n",sizeof(a[3]));
int a[3][4] = {0};
二维数组a可以看作是由3个一维数组组成的,每个一维数组有4个元素
printf("%d\n",sizeof(a));数组名单独放在sizeof内得出的是整个数组的大小,a数组元素类型为int,所以整个数组大小为48字节,输出结果为48
printf("%d\n",sizeof(a[0][0]));在此a[0][0]=*(*(a+0)+0),得到的是数组第一个元素,该元素大小为4,输出结果为4
printf("%d\n",sizeof(a[0]));在此a[0]得到的是二维数组中的第一行的数组名,单独放在sizeof内,第一行有4个元素,大小为16字节,输出结果为16
printf("%d\n",sizeof(a[0]+1));在此a[0]+1=*(a+0)+1,得到是第一行的第二个元素的地址,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n",sizeof(*(a[0]+1)));*(a[0]+1))=*(*(a+0)+1)得到的是二维数组内第一行的第二个元素,大小为4,输出结果为4
printf("%d\n",sizeof(a+1));在此a表示二维数组首元素的地址也就是数组第一行的地址,再加上一得到的就是数组第二行的的地址,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n",sizeof(*(a+1)));a+1得到的是二维数组第二行的地址,再解引用后得到是二维数组内第二个一维数组的数组名,单独放在sizeof内求出是整个一维数组的大小,一共有4个元素,大小为16字节,输出结果为16
printf("%d\n",sizeof(&a[0]+1));在此&a[0]得到就是二维数组第一行的地址,再加一得到为第二行的地址,在32位环境下为4字节,在64位环境下位8字节,打印结果为4或者8
printf("%d\n",sizeof(*(&a[0]+1)));在此&a[0]得到就是二维数组第一行的地址,再加一得到为第二行的地址,再进行解引用后得到是二维数组内第二个一维数组,sizeof求出的就是这个一维数组的大小,有4个元素,大小为16字节,输出结果为16
printf("%d\n",sizeof(*a));
在此a不是单独放在sizeof内,所以a表示的是二维数组首元素的地址即是第一个一维数组的地址,再进行解引用因为指针a类型为int(*)[4],所以sizeof求出的是数组第一行的大小,大小为16字节,输出结果为16
printf("%d\n",sizeof(a[3]));a[3]=*(a+3),得到的是数组第四行的数组名,也有4个int类型的元素(虽然a[3]不存在,但我们知道sizeof内部表达式时不会真正计算的)大小为16字节,输出结果为16
3. 指针运算笔试题解析
3.1 题目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表示数组首元素的地址,再加一解引用得到就是数组第二个元素2
&a+1原来的类型是int(*)[5]后强制类型转换为int*,这就改变了指针加减时的步长,所以str再减一步长就为4,得到的是数组第五个元素的地址,再解引用后就得到第五个元素5所以输出结果为2 5
3.2 题目2
//在X86环境下
//假设结构体的⼤⼩是20个字节
//以上程序输出的结果是什么呢?
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p = (struct Test*)0x100000;
int main()
{
printf("%p\n", p + 0x1);
printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1);
return 0;
}
在以上代码中先创建了一个struct Test的结构体类型,后再创建一个结构体指针变量p,并将0x00100000这个整形的16进制数字强制类型转换为struct Test*后存储在p指针变量内
因此对指针变量p+0x1,因为指针变量类型为struct Test*,该结构体大小为20字节,所以指针加1后步长为20字节,又因为%p打印的是16进制的数,所以指针变量变为0x00100014
将指针变量强制类型转换为unsigned long后,因为对整型变量加一就是直接加一又因为%p打印的是16进制的数,所以变量就变为0x00100001
将指针变量强制类型转换为unsigned int*后,因为unsigned int的大小是4个字节,所以指针变量加一的步长是4个字节,又因为%p打印的是16进制的数,所以指针变量变0x00100004最终输出结果为:
0x00100014
0x00100001
0x00100004
3.3 题目3
#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[0]就为数组中首元素1
输出结果为1
3.4 题目4
//假设环境是x86环境,程序输出的结果是啥?
#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中,当a的类型是int(*)[5],而int(*)[4],两个变量类型不同,这时在变量p就会遵循int(*)[4]这个类型,&p[4][2]就是指针变量p跳过4个16字节后再跳过2个4字节得到处的地址,又因为&a[4][2]得到的是数组a第5行第2列的元素地址,这两地址处相减后就得到之间的元素个数为-4
%p就是将-4的补码按照16进制的方式打印出,因为4个二进制位数表示一个16进制数
所以补码转换为16进制就为:0xFFFFFFFC输出结果为0xFFFFFFFC
3.5 题目5
#include <stdio.h>
int main()
{
int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int *ptr1 = (int *)(&aa + 1);
int *ptr2 = (int *)(*(aa + 1));
printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
return 0;
}
首先先将&aa+1强制类型转换为int*后存储在指针变量ptr1中,再将 *(aa+1)也就是aa[1]强制类型转换为int*后存储在指针变量ptr2中,因此在对str1和str2减一时步长为4,再解引用后分别得到为10 5
所以输出结果为10 5
3.6 题目6
#include <stdio.h>
int main()
{
char *a[] = {"work","at","alibaba"};
char**pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}
a是一个字符指针数组,存放的是w,a,a三个字符的地址 ,而pa指针变量是一个二级指针,存放p指针变量的地址,同时指向的是存放p中首元素w的地址的地址
再对pa++后就使得pa变量指向的为p中第二个元素,也就是存放a的地址的地址,再*pa后就得到a的地址,再%s打印就可以将字符串at打印出
输出结果为at
3.7 题目7
#include <stdio.h>
int main()
{
char *c[] = {"ENTER","NEW","POINT","FIRST"};
char**cp[] = {c+3,c+2,c+1,c};
char***cpp = cp;
printf("%s\n", **++cpp);
printf("%s\n", *--*++cpp+3);
printf("%s\n", *cpp[-2]+3);
printf("%s\n", cpp[-1][-1]+1);
return 0;
}
以上图示就将各指针数组和指针变量之间的关系清晰的展现出
后先是**++cpp关系图就变为了以下形式
先是++cpp就使cpp指针变量指向为cp[1],再*得到c+2,再*得到字符P的地址
之后 *--*++cpp+3关系图就变为了以下形式
先++cpp后就使cpp指针变量指向为cp[2],再*得到cp[2],再--使cp[2]指向变为c[0],再*得到c[0]也就是字符E的地址,再对该地址+3就使指针指向了ENTER中的第四个字符
在 *cpp[-2]+3=**(cpp-2)+3关系图就变为了以下形式
先cpp-2后就使cpp指针变量指向为cp[0],再*得到cp[0],再*得到c[3]也就是字符F的地址,再对该地址+3就使指针指向了ENTER中的第四个字符
cpp[-1][-1]+1=*(*(cpp-1)-1)+1关系图就变为了以下形式
先cpp-1后就使cpp指针变量指向为cp[1],再*得到cp[1],再-1使cp[1]指向变为c[1],再*得到c[1]也就是字符N的地址,再对该地址+1就使指针指向了NEW中的第二个字符
所以以上代码输出结果为:
POINT
ER
ST
EW
以上就深入理解指针(5)的全部内容,希望看完以上内容你能有所收获,到此就是深入理解指针章节的全部内容了,感谢你的支持,接下来我将会继续带来c语言其他的知识,希望能得到你的点赞,收藏