亲宝软件园·资讯

展开

C语言 指针和数组

Dark And Grey 人气:0

指针 和 数组 试题解析 小编,在这里想说一下,c语言的最后一节 C预处理,可能还需要一些时间,因为小编,昨天才下载了虚拟机 和 linux 系统,还没开始安装。所以无法着手写,因为 C预处理,vs2013很难表达,也就意味可能会讲不清楚。所以这篇文章可能需要点时间,再加上小编初期的文章,是没有排版的(而且可能有些错误,请大家以重置版为准),所以这几天我就把这些重新写。有兴趣的朋友可以看看。(ps:如果哪一天没有更新,意味着小编正在努力学习,为了能给大家呈现一片详细好懂的文章。)

下面直接进入正文

数组题:

先给你们打个底

1. sizeof(数组名) ,此时的 数组名 代表的是 整个数组。

2. &数组名,此时的 数组名 代表的是 整个数组。

除了以上两种特殊情况,其它的,几乎 100% 代表的是首元素地址

另外有一点请记住: arr[ i ] == *(arr + i ); arr[ i ][ j ] == *( *(arr + i)+ j)

好的,现在就让我们进入习题中,去磨练这份知识,让它再我们脑子里扎根

程序一(一维数组):

一维数组
#include<stdio.h>
int main()
{
	int a[] = {1,2,3,4};
	printf("%d\n", sizeof(a));// 16  计算的是整个数组的内存大小
	// sizeof(数组名) 和 &数组名,此时数组名,代表的是整个数组 

	printf("%d\n", sizeof(a+0));// 输出为 4 / 8 (地址所占大小只与多少位操作系统有关,4byte【32位】,8byte【64】)
	// 因为 sizeof()的括号里放的不是数组名,而是 首元素地址 + 0,即sizeof(a[0])

	printf("%d\n", sizeof(*a));// 4  因为 a 没有 &(取地址),没有单独放在sizeof()里(属于非特殊情况,数组名代表首元素地址)
	// *a 就是首元素,这里求的是 首元素 的内存大小,因为 这是一个整形数组,里面的每个元素都是 int 类型,即为 4 byte

	printf("%d\n", sizeof(a+1));// 4 / 8  与a + 0 的意思是一样的,只是现在这里跳过一个元素,也就是说现在这是第二个元素的地址,地址的大小无非 就是 4/8 byte(受多少位系统影响,4byte【32位】,8byte【64位】)


	printf("%d\n", sizeof(a[1]));// 4  a[1] == *(a+1) 第二个元素的地址对齐解引用找到第二个元素,sizeof(a[1]),就是在求 第二个元素的大小,因为 这是一个整形数组,里面的每个元素都是 int 类型,即为 4 byte

	printf("%d\n", sizeof(&a));// 4 / 8 &a 取出的是数组的地址,数组名没有单独放在sizeof括号里,而且 &a 取出的是整个数组的地址,sizeof(&a) 就是在爱求 数组的地址大小
	//  数组的地址也是地址 ,也受多少位操作系统影响: 4 byte【32位】 / 8byte 【64位】

	printf("%d\n", sizeof(*&a));// 16  &a 取出的是数组的地址,对取其解引用,找到数组名a,也就是说 * 和 & 相互抵消了,等于就是说 sizeof(数组名) ,此时数组名代表的是整个数组

	printf("%d\n", sizeof(&a+1));// 4 / 8  &a,拿出的是数组a的地址,+1跳过整个数组,但还是一个地址,受多少位操作系统影响: 4 byte【32位】 / 8byte 【64位】

	printf("%d\n", sizeof(&a[0]));// 4 / 8  [] 的优先级 比 & 高,a 先和 [] 结合形成一个数组,在对其取地址,又因为 a[0] == *(a+0),即这里 &a[0],取出的是 首元素的地址,既然是地址,就要受多少位操作系统影响: 4 byte【32位】 / 8byte 【64位】

	printf("%d\n", sizeof(&a[0]+1));// 4 / 8    [] 的优先级 比 & 高,a 先和 [] 结合形成一个数组,在对其取地址,又因为 a[0] == *(a+0),即这里 &a[0],取出的是 首元素的地址,此时加一,跳过一个整形,也就是说 此时的地址 是 第二个元素的地址,既然是地址,就要受多少位操作系统影响: 4 byte【32位】 / 8byte 【64位】

	return 0; 
}

字符数组

1. sizeof(数组名) ,此时的 数组名 代表的是 整个数组。

2. &数组名,此时的 数组名 代表的是 整个数组。

除了以上两种特殊情况,其它的,几乎 100% 代表的是首元素地址

另外有一点请记住: arr[ i ] == *(arr + i );

arr[ i ][ j ] == *( *(arr + i)+ j)

程序二(字符数组):

#include<stdio.h>
int main()
{
	char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
	printf("%d\n",sizeof(arr));// 6  arr是一个字符数组,每一个元素的内存大小为 1 byte,该数组有 5个 元素,即 6 byte
	
	printf("%d\n", sizeof(arr+0));//4 / 8  arr+0 == 首元素地址,既然是地址,就要受多少位操作系统影响: 4 byte【32位】 / 8byte 【64位】

	printf("%d\n", sizeof(*arr));// 1   *arr(对首元素地址进行解引用) == 首元素,此时计算的是首元素的大小,即 1 byte
	
	printf("%d\n", sizeof(arr[1]));// 1   arr[1] == *(arr+1),即第二个元素,即 sizeof 计算的是一个元素的大小,即 1 byte
	
	printf("%d\n", sizeof(&arr));// 4 / 6  &arr  取出的是 数组的地址,既然是地址,就要受多少位操作系统影响: 4 byte【32位】 / 8byte 【64位】
	
	printf("%d\n", sizeof(&arr+1));// 4 / 8 &arr  取出的是数组的地址,在对其 加一,即跳过整个数组,此时地址是数组中不包含的地址,越界了,假设  数组有 5 个元素,下标0 ~ 4,此时的地址是 下标为 5 的地址,有人肯能会有,那这个不应该是错的吗》怎么还有大小?,
	//因为 sizeof 是不会真的去访问越界的位置,只是看看那个位置的数据是什么类型,并不涉及访问和计算。
	//因为是第六个元素的地址,既然是地址,就要受多少位操作系统影响: 4 byte【32位】 / 8byte 【64位】
	
	printf("%d\n", sizeof(&arr[0]+1));// 4 / 8  这个就不用我多说了,它就就是一个地址,第二个元素的地址(&arr[0] + 1 == 首元素地址 + 1,即首元素地址 挑过一个 字节,),既然是地址,就要受多少位操作系统影响: 4 byte【32位】 / 8byte 【64位】
	
	return 0; 
}

接下我们把 sizeof 换成 strlen ,来看看这些题会发生什么变化? 在开始之前请注意一下内容: 1. strlen 只有 遇到 ‘\0',才会停止计数。计数个数(不包括 ‘\0' 这个元素),如果没有 ‘\0',strlen 这个函数就会往后面找 ‘\0',所以 strlen 的返回值,在没有 '\0'的情况下,返回 一个随机值。 2.strlen(这里要放一个地址),如果不是,会导致程序崩溃 举个列子:strlen(a),a 的 地址为 97,strlen 就会 以 97 为地址,开始往后 一边寻找 ‘\0',一边计数,很容易形成越界访问,从而导致程序崩溃

程序三(字符数组):

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
	printf("%d\n", strlen(arr));//  随机值, 没有'\0'·从首元素开始计数,且向后寻找'\0',但是该数组里没有'\0'的,所以它会一直往后找'\0',直到找到了才停止计数,所以返回的是一个随机值
	
	printf("%d\n", strlen(arr + 0));// 随机值,还是从首元素开始计数,且向后寻找'\0',但是该数组里没有'\0'的,所以它会一直往后找'\0',直到找到了才停止计数,所以返回的是一个随机值
	
	//printf("%d\n", strlen(*arr));// *arr == 'a' == 97 strlen(把97当成一个地址),非法访问,程序崩溃
	
	//printf("%d\n", strlen(arr[1]));// 与上表达式一样, 非法访问,程序崩溃
	
	printf("%d\n", strlen(&arr));//  随机值
	printf("%d\n", strlen(&arr + 1));//  随机值 - 6 ,与上表示式的随机值 ,相差 6,因为 &arr 读取的是数组的地址,加一 等于 跳过一个个数组,也就是跳过了 6 个元素,也就是说这六个元素,没有被计入,现在是 第 7 个元素的地址,从第七个元素开始 计数 和 寻找 '\0'
	
	printf("%d\n", strlen(&arr[0] + 1));// 随机值 - 1,与 上上 表达式的随机值,相差 1,这里是从 第二个元素,开始 计数 与 寻找'\0',第一个元素没有计入在内
	
	return 0;
}

程序四(字符数组):

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = "abcdef";//  ==  "abcdef" == 'a', 'b', 'c', 'd', 'e', 'f', '\0'
	printf("%d\n", sizeof(arr));// 7  后面隐藏一个元素 '\0'
	
	printf("%d\n", sizeof(arr + 0));// 4 / 8 是一个地址,
	printf("%d\n", sizeof(*arr));//  1   *arr == 首元素,这里计算的是首元素的内存大小
	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   遇到'\0'停止计数,'\0'不计入在内
	printf("%d\n", strlen(arr + 0));//  6  arr+0 == arr 从首元素开始计数,遇到'\0'停止计数,'\0'不计入在内
	printf("%d\n", strlen(*arr));//   *arr  ==  a == 97,以97为地址( 从 97 开始计算直到遇到'\0' ),属于非法访问,程序崩溃
	printf("%d\n", strlen(arr[1]));//  arr[1]  ==  b == 98,以98为地址( 从 98 开始计算直到遇到'\0' ),属于非法访问,程序崩溃
	printf("%d\n", strlen(&arr));//  6  &arr 虽然是数组的地址,但是对于strlen函数来说,它就只是第一个元素的地址,从该元素开始计数,遇到'\0'停止计数,'\0'不计入在内
	printf("%d\n", strlen(&arr + 1));// 随机值,跳过了一个数组,从 '\0' 后面 开始计数,直到遇到'\0'停止计数,'\0'不计入在内
	printf("%d\n", strlen(&arr[0]) + 1);// 5 从第二个元素开始计数,遇到'\0'停止计数,'\0'不计入在内

	return 0;
}

程序五(字符数组):

#include<stdio.h>
#include<string.h>
int main()
{
	char* p = "abcdef";// p 存的是 字符串的首元素的a的地址
	printf("%d\n", sizeof(p));// 4  / 8    a 的地址
	printf("%d\n", sizeof(p + 0));// 4 / 8 b 的地址,
	printf("%d\n", sizeof(*p));//  1   *arr == 首元素 a,这里计算的是首元素的内存大小
	printf("%d\n", sizeof(p[0]));// 1  计算第一个元素的内存大小 p[0] == *(p+0) == a
	printf("%d\n", sizeof(&p));//  4 / 8  把指针变量本身的地址取出来了,是一个地址
	printf("%d\n", sizeof(&p + 1));// 4 / 8   取出 指针变量 p的 地址,加上 1,是谁的地址,不知道也不重要,因为它还是一个地址
	printf("%d\n", sizeof(&p[0] + 1));// 4 / 8, &(*(p+0)) +1 ,a的地址加上一字节,改地址是 b 的地址



	printf("%d\n", strlen(p));//  6  指针变量 p 存的是 a的地址,从a开始计算,直到遇到'\0'停止,'\0'不计入在内
	printf("%d\n", strlen(p + 1));// 5  指针变量 p 存的是 b 的地址,从b开始计算,直到遇到'\0'停止,'\0'不计入在内
	printf("%d\n", strlen(*p));//  *p == a == 97,以97为地址( 从 97 开始计算直到遇到'\0' ),属于非法访问,程序崩溃
	printf("%d\n", strlen(p[0]));//  p[0] == a == 97,以97为地址( 从 97 开始计算直到遇到'\0' ),属于非法访问,程序崩溃
	printf("%d\n", strlen(&p));// 随机值, 这里是指针变量 p 的地址,不是a的地址,而 p 后面什么时候能遇到 '\0',我们不知道,所以返回一个 随机值
	printf("%d\n", strlen(&p + 1));// 随机值,这里还是取的 指针变量 p 的地址,对齐加一,跳过一个p,意味着 strlen 少计数 一整个 p 所含的元素
	printf("%d\n", strlen(&p[0] + 1));//  5  取出第一个元素的地址加一,到第 二 个元素,从第二个元素计算,直到遇到'\0'停止,'\0'不计入在内

	return 0;
}

二维数组

1. sizeof(数组名) ,此时的 数组名 代表的是 整个数组。

2. &数组名,此时的 数组名 代表的是 整个数组。

除了以上两种特殊情况,其它的,几乎 100% 代表的是首元素地址

另外有一点请记住: arr[ i ] == *(arr + i );

arr[ i ][ j ] == *( *(arr + i)+ j)

arr[ i ][ j ] ,arr[ i ] 就是一维数组的数组名

在这里插入图片描述

程序六( 二维数组):

#include<stdio.h>
#include<string.h>
int main()
{
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//  48   此时 数组名 a 代表的是整个数组,意味着 sizeof 计算的是整个数组的大小; 3*4*4 = 12*4 = 48
	printf("%d\n", sizeof(a[0][0]));// 4  第一行第一个元素
	printf("%d\n", sizeof(a[0]));//  16 把第0行看成一个一维数组,a[0]就是一个一维数组的数组名,所以计算的整个第 0 行元素的内存大小 4 * 4 = 16
	printf("%d\n", sizeof(a[0] + 1));//  4 / 8   第0行 第2个元素的地址
	printf("%d\n", sizeof(*(a[0] + 1)));//  4    第0行 第2个元素  a[0][1] == *(*(a+0)+1)

	printf("%d\n", sizeof(a + 1));// 4  / 8     第1行 的 一维数组 的 地址,*(a +1) = arr[1],不就是第1行 一维数组的 数组名,在对其 &(取地址),既然是一个地址,就要受多少位操作系统影响: 4 byte【32位】 / 8byte 【64位】
	
	printf("%d\n", sizeof(*(a + 1)));// 16   解引用 第一行的一维数组的数组名(首元素)的地址,等于就是找到第一行的一维数组的数组名,
	                                 //sizeof(第一行 的 数组名 ),所以计算的是整个第一行元素的内存大小

	printf("%d\n", sizeof(&a[0] + 1));//  4 / 8   第 1 行(第一行的一维数组名)的 地址,
	printf("%d\n", sizeof(*(&a[0]) + 1));// 16 解引用 第 1 行(第一行的一维数组名)的 地址,等于找到了 第 1 行的一维数组的数组名
	                                     //sizeof(第一行 的 数组名 ),所以计算的是整个第一行元素的内存大小
	printf("%d\n", sizeof(*a));// 16  a是首元素的地址(第 0 行的数组地址) ,*a(解引用 a )找到了第0行数组名,
	                           //计算的是整个第 0 行所有元素的内存大小
	printf("%d\n", sizeof(a[3]));//16  ,另外  sizeof()括号里表达式不会计算,也就是说不会真的访问第四行数据,它只是把第四行的数组名放在这里()
	                             //意思这里有第四行,就意味着 第四行 有 它自己 的 类型  ,其实这里  a[3] 跟 a[0] 一样的道理,
	                             //a[3] 是第四行的数组名,那有 第四行吗?其实没有,但并不妨碍,因为我们不去访问 
	                             // 而且 sizeof() 括号里的 表达式 是不参与真实运算的 ,只是 根据 它的类型 计算 它的大小
	                            // 所以 a[3] 是一个一维数组,而且有 4 个整形的一维数组,sizeof(a[3]) == 4 * 4 == 16

	return 0;
}

指针题

在这里插入图片描述

程序七( 指针):

#include<stdio.h>
int main()
{
	int a[5] = { 1, 2, 3, 4, 5 };
	int* ptr = (int*)(&a + 1);// 数组的指针类型,不能放进一个整形指针里,所以这里强制类型转换,但值没有发生变换,
	                         // 存的值,还是跳过一个数组的指向的那个值(未知量)
	printf("%d,%d\n", *(a + 1), *(ptr - 1));// 整形指针 ptr 减一,指向 5 的 那个位置,再解引用就是5
	return 0;         //  2         5
}

程序八( 指针):

include<stdio.h>
struct test
{
	int num;
	char* pcname;
	short s_date;
	char cha[2];
	short s_ba[4];
}* p;

 假设 p 的 值为  0x10 00 00 00,如下表达式分别为多少
 已知结构体 test 类型 的 变量 大小为 20个字节
#include<stdio.h>
int main()
{
	p = (struct test*)0x100000;
	printf("%p\n", p + 0x1);// 0x1 == 1 这里加1 等于跳过了一个结构体(20字节)
	//0x10 00 00 + 20 ==0x10 00 14  因为 %p(32位)
	//打印  0x 00 10 00 14

	printf("%p\n", (unsigned long)p + 0x1); // 强制类型转换 无符号长整形类型,0x100000 转换为 10 进制 -> 1048576 + 1 = 1048577 -> 0x10 00 01
	     // %p, 即0x 00 10 00 01

	printf("%p\n", (unsigned int*)p + 0x1);//强制类型转换 无符号整形指针类型 加1 == 就是跳过一个无符号整形 指针(4 byte)
	// 即 0x 00 10 00 04
	return 0;   
}

程序九( 指针):

在这里插入图片描述

#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);// %x 十六进制数
	return 0;     //   4      2 000 000
}  
//       1                 2                    3                   4
//  01 00 00 00        02 00 00 00         03 00 00 00         04 00 00 00
// 低地址                                                         高地址(小端 存储:低字节存低地址,高字节存高地址)
// a 是数组名(首元素地址),指向 1 所在的地址(01前面)。这时类型强制转换 整形,加1(1字节),
// 再将他转换为一个地址,在对其解引用 ,此时它(ptr2)指向 01 的后面,又因为ptr2是int 类型
//也就是说它一次访问 4 个字节的内容( 00 00 00 02 ) 取出来使反着读取(从高位开始读取),02 00 00 00 
// 按十六进制 输出 (0x 02 00 00 00) 即,2 000 000

程序十( 指针):

#include<stdio.h>
int main()
{                  //    1       3         5
	int a[3][2] = { ( 0, 1 ), ( 2, 3 ), ( 4, 5) };// a 是一个 3排 2列 的 二维数组
	int* p;         //逗号表达式,以最后一个表达式结果为准
	               //  数组存储情况      1 3
	               //                   5 0
	               //                   0 0
	p = a[0];
	printf("%d\n",p[0]); //  1
	return 0;
}

程序十( 图):

在这里插入图片描述

#include<stdio.h>
int main()
{
	int a[5][5];
	//    a[0]        a[1]         a[2]         a[3]           a[4]
	// 口口口口口  口口口口口   口口口口口   口口口口口     口口口口口
	// |      |         |         |         |   |         |
	//p[0]   p[1]      p[2]       p[3]     p[4] |       a[4][2]
	//                                       p[4][2]
 	int(*p)[4]; 
	p = a;//  p的类型 int(*)[4]    a的类型 int(*)[5]
	// p 是一个指向整形数组的指针,有4个元素
	printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);// a 先和 [] 集合([]的优先级高)
	return 0;      //  p[4] == *(p+4)   p[4][2] == *(*(p + 4) + 2)
	              // 指针减指针 等于两个指针之间的元素个数 ,&p[4][2] - &a[4][2]  ==  - 4
} 
 打印的条件  :%d == - 4
 -4  1000 0000 0000 0000 0000 0000 0000 0100 原码(打印)
 1111 1111 1111 1111 1111 1111 1111 1100  补码(存储)
 
 %p 认为内存上放的是地址,地址就没有原反补码的概念(无符号数) 
 整形在内存中,以补码类型存储,所以直接以补码当做地址输出
     1111 1111 1111 1111 1111 1111 1111 1100 原码符号位不变,其余位按位取反,再加 1
 0x    f    f   f     f    f   f    f   c
 所以%p 的输出结果是 ffff fffc

程序十一( 指针):

#include<stdio.h>
int main()
{
	int a[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int* ptr1 = (int*)(&a + 1);//跳过整个二维数组
	int* ptr2 = (int*)(*(a + 1));// 第一行的数组名
	// int aa[5]={0};
	// int* p = arr;
	// *(aa+2) == a[2] == *(p + 2) 
	printf("%d,%d\n",*(ptr1 - 1),*(ptr2 - 1));
	return 0;//           10            5
}

程序十二( 指针):

#include<stdio.h>
int main()
{
	char* a[] = { "work", "at", "alibaba" };// char *p = "abcdef"; p 存的是字符串首元素(a)的地址
	  //这里也是一样,字符指针数组 a ,数组名 a == 首元素("work")中 'w ' 的地址
	char* *pa = a;// *pa(指针),类型 char* ,*pa指向第一个元素(a == 首元素的地址)
    //  遗迹指针的地址需要一个二级指针来接收
    
	pa++;//跳过一个char*,指向第二个元素,
	printf("%s\n",*pa);// at
	return 0;
}

程序十三( 指针):

#include<stdio.h>
int main()
{
	char*c[] = { "ENTER", "NEW", "POINT", "FIRST" };
	char* *cp[] = { c + 3, c + 2, c + 1, c };
	           // FIRST   POINT   NEW   ENTER

	// c[]                       cp
	// char*   ENTER          c+3  char**   FIRST  -> cpp
	// char*   NEW            c+2  char**   POINT
	// char*   POINT          c+1  char**   NEW 
	// char*   FIRST           c   char**   ENTER

	char** *cpp = cp;
	printf("%s\n",* *++cpp); // POINT   此时cpp指向第二个元素(c+2),再对其解引用  POINT 的首元素地址

       此时 cpp 指向 c+2(第二个元素) 处,因为 上面 ++cpp  改变 cpp 的指向
	printf("%s\n", *--*++cpp + 3); // ER  ++  -- 优先级比 + 高,
	//所以先加加,此时cpp指向第三个元素,再进行 *(解引用)== 第三个元素(c+1),
	//再 -- (第三个元素减一),即 c + 1 - 1 == c ,再进行 *(解引用),此时 等于  ENTER (此时类似于数组名)
	// 最后再加 3 (ENTER + 3),最终指向 "ENTER"中第四个元素 E 的地址  ,然后从 E 开始往后打印,直到遇到'\0'停止,
	// 即 最后输出为 :  ER
	
注意此时的 char**cp[]={c+3,c+2,c,c};因为 在 *++p,解引用找到第三个元素 c+1之后,前置减减了一波。所以改变了 第三个元素的值
      

	// 另外 注意 此时 cpp是指向第三个元素 c 的。
	printf("%s\n", *cpp[-2] + 3); // *cpp[-2] + 3 = *(cpp-2) + 3  ; cpp-2 == cpp[0] ==(c+3)
	                              // 再对其解引用,等于 FIRST
	                              // 再加上三,此时指向(FIRST 此时类似于数组名),FIRST + 3 第四个元素 S 的地址
	                              // 然后从 S 开始打印,直到遇到'\0'停止。
	                              //  即 最后输出为:ST

	// 注意 此时 cpp 还是指向第三个元素 c 的(前面 *cpp[-2],并不会改变其值,它只是加上一个数,然后去访问,就好比 一个人 站着凳子 去拿柜子上高处的东西,并不会改变自身身高,而前置和后置 ++,自增,也就是说等自己长高了再去拿,此时的身高已经改变了),
	printf("%s\n", cpp[-1][-1] + 1);
	           // ==  *( *(cpp - 1) -1 ) + 1
	           //  *(cpp - 1) == c + 2
	          // 再 减 1, c + 2 - 1 = c + 1
	          // 在对其解引用 等于 NEW
	          // 再加 1 ,NEW(此时类似于数组名) +1 ,此时得到了第二个元素(E)的地址
	          //然后 从  E 这里开始打印,直到遇到'\0'停止。
	          // 即 最后输出为 EW

	return 0;
}

如果有疑问,欢迎在下面评论。本文至此就全部结束了。

加载全部内容

相关教程
猜你喜欢
用户评论