C语言指针plus版练习

上期我们讲了进阶的指针，本期内容我们来强化一下上期学的内容

一、字符串左旋

实现一个函数，可以左旋字符串中的k个字符。

1.1 分析题目

假设字符串为abcde，左旋一个以后就变成bcdea，就是把第一个字符移到一个新的变量里面，再把后一个字符移到前一个字符上，再把第一个字符放到最后一里就行啦

1.2 解题代码

void left_move(char arr[], int sz, int n)
{
	while (n % sz)
	{
		//将第一个元素存入tmp
		char tmp = arr[0];
		int i = 0;
		//将后一个元素存入前一个
		for (i = 0; i < sz - 1; i++)
		{
			arr[i] = arr[i + 1];
		}
		//将tmp存入最后一个元素
		arr[i] = tmp;
		n--;
	}
}

int main()
{
	char arr[] = "abcdef";
	int n = 0;
	int sz = strlen(arr);
	scanf("%d", &n);
	left_move(arr,sz, n);
	printf("%s\n", arr);
	return 0;
}

1.3 另解

聪明的你一定发现了此题另有他法，太聪明了太聪明了！

只要仔细观察，我们其实可以发现，左旋x个字符，就将前x个字符反过来，再将剩下的字符反过来，最后把全部的字符再反过来就可以得到

所以代码也可以这样写

void left_move(char arr[],int sz, int n)
{
	//反转前n个
	rollback(arr, arr + n - 1);
	//反转剩下的
	rollback(arr + n , arr + sz - 1);
	//反转全部
	rollback(arr, arr + sz - 1);
}

int main()
{
	char arr[] = "abcdef";
	int n = 0;
	int sz = strlen(arr);
	scanf("%d", &n);
	left_move(arr, sz, n % sz);
	printf("%s\n", arr);
	return 0;
}

二、指针和数组试题解析

除了&数组名和sizeof（数组名），这两个情况表示整个数组，其他都是表示数组首元素地址

2.1 一维整型数组

我们一个一个来分析：

1. sizeof( a )，这里的a表示整个数组，因此他的大小为——>16字节

2. sizeof( a+0 )，这里的a不是单独放在数组里面的，所以这里的a表示数组首元素地址，a+0也是表示首元素地址，是地址就是4/8个字节

3. sizeof( *a+0 )，*a表示数组的第一个元素+0以后也是整型的，所以这里是4个字节

4. sizeof( a+1 )，a是数组首元素地址，a+1就是数组第二个元素的地址，是地址就是4/8个字节

5. sizeof(a[ 1 ]), a[ 1 ] 等价于 *（ a + 1），就是数组中第二个元素的大小，因为是int型，所以是4个字节

6. sizeof( &a ), &a就是取出数组a的地址，是地址就是4/8个字节

7. sizeof( *&a ), *&a就是先取出整个数组的地址，然后再解应用，所以和sizeof( a )是一样的，16个字节

8. sizeof( &a + 1), &a + 1是跳过整个数组取出的地址，是地址就是4/8个字节

9. sizeof( a[ 0 ]), a[ 0 ] 就是* ( a + 0),也就是数组中第一个元素的地址，是地址就是4/8个字节

10. sizeof( a[ 0 ] + 1 ), 就是* ( a + 0 ) + 1,也就是数组中第二个元素的地址，是地址就是4/8个字节

答案如下：

2.2 一维字符数组

2.2.1 char arr[] = {'a','b','c','d','e','f'};

sizeof

1. sizeof( arr ), 就是数组占用空间的大小，所以为6个字节

2. sizeof( arr + 0 ),这里arr没有单独放在sizeof中，因此它表示数组中首元素的地址，是地址就是4/8个字节

3. sizeof( *arr ), 同上，arr表示数组首元素地址，解引用之后就是数组首元素的大小，所以是1个字节

4. sizeof( arr[ 1 ]), arr[ 1 ]等价于*(arr + 1)，就是数组中第二个元素的大小，就是1个字节

5. sizeof( &arr), &arr表示取出整个数组的地址，是地址就是4/8个字节

6. sizeof( &arr + 1 ),&arr + 1表示跳过这个数组取出的地址，是地址就是4/8个字节

7. sizeof( &arr[0] + 1), &arr[ 0 ] + 1,表示数组的第二个元素的地址，是地址就是4/8个字节

答案如下：

strlen

1. strlen( arr ), 表示从数组首元素开始，直到‘\0’出现的字符个数，因此是个随机值

2.strlen( arr + 0 ), 同上，随机值

3. strlen( *arr ), 这里的意思为strlen( ‘a’ )就是strlen( 97 ),传给strlen是一个非法的地址,非法访问

4.strlen( arr[ 1 ]), 同上，非法访问

5. strlen( &arr ), &arr 虽然是数组的地址，但也是从数组的首元素开始找‘\0’的，所以也是随机值

6. strlen( &arr + 1), 同上，跳过一整个数组开始找‘\0’ ,随机值

7. strlen( &arr[ 0 ] + 1), 同上，从第二个元素的地址开始找‘\0’, 随机值

答案如下：

2.2.2 char arr[] = "abcdef";

sizeof

1. sizeof( arr ), 这里数组名单独放在sizeof里面，所以表示的为整个数组，大小就是7（末尾还有‘ \0 ’）

2. sizeof( arr + 0 ), arr + 0表示首元素地址，是地址就是4/8个字节

3. sizeof( *arr ), arr表示数组首元素，*arr就是首元素，所以就是1个字节

4. sizeof( arr[ 1 ] ), arr[ 1 ]等价于 *(arr + 1),就是数组第二个元素，1个字节

5. sizeof( &arr ), &arr表示取出一整个数组的大小，是数组就是4/8个字节

6. sizeof( &arr + 1), &arr + 1表示跳过一整个数组取出的地址，是地址就是4/8个字节

7. sizeof( &arr[ 0 ] + 1), &arr[ 0 ] +1表示数组第二个元素的地址，是地址就是4/8个字节

答案如下：

strlen

1. strlen( arr ), 这里的arr为数组首元素地址，从数组首元素开始找‘ \0 ’，所以为6

2. strlen( arr + 0), 同上，为6

3. strlen( *arr ), 意为strlen( ‘ a ’ ),就是strlen( 97 ), 非法访问

4. strlen( arr[ 1 ]), 同上，非法访问

5. strlen( &arr ), arr虽然是数组的地址，但也是从首元素开始找‘ \0 ’，所以为6

6. strlen( &arr + 1), 跳过整个数组开始找，随机值

7. strlen( &arr[ 0 ] + 1), 跳过数组首元素开始找‘ \0 ’，所以为6

答案如下：

2.2.3 指针型

sizeof

1. sizeof( p ), 这里指针p指向的是字符串的首个字符的地址，所以sizeof( p )就是第一个字符的地址的大小，是地址就是4/8个字节

2. sizeof( p + 1 ), 就是指向第二个字符的地址的大小，是地址就是4/8个字节

3. sizeof( *p ), 就是‘ a ’的大小，为1个字节

4. sizeof( p[ 0 ]), p[ 0 ]就是*( p + 0 )，和上一个一样，大小为1个字节

5. sizeof( &p ), &p就是取出p的地址,是二级指针，是地址就是4/8个字节

6. sizeof( &p +1 ), &p + 1，和上一个类似，跳过指针p取下一个地址，是地址就是4/8个字节

7. sizeof( &p[ 0 ] + 1), &p[ 0 ]是‘ a ’的地址，+1就是‘ b ’的地址，是地址就是4/8个字节

答案如下：

strlen

1. strlen( p ) ,就是从第一个字符‘ a ’开始找‘ \0 ’，所以为6

2. strlen( p + 1 ), 跳过‘ a ’，从‘ b ’ 开始找‘ \0 ’ ,所以为5

3. strlen( *p ), 非法访问

4. strlen( p[ 0 ]), p[ 0 ]和*( p + 0 )一样，所以也是非法访问

5.strlen( &p ), 从p的地址开始找‘ \0 ’ ，为随机值

6. strlen( &p + 1 ), 跳过p的地址开始找‘ \0 ’，为随机值

7. strlen( &p[ 0 ] + 1), &p[ 0 ]为‘ a ’的地址，所以+1就是‘ b ’的地址，所以为5

答案如下：

2.3 二维数组

上强度咯~

1. sizeof( a ), 这里数组名a单独存放在sizeof中，因此表示整个数组，所以他的大小为48个字节

2. sizeof( a[ 0 ][ 0 ] ), 为数组中第一个元素的大小，就是4个字节

3. sizeof( a[ 0 ] ), 是第一行的数组名，单独放在sizeof中，为数组第一行的元素大小，就是16个字节

4. sizeof( a[ 0 ] + 1 ), a[ 0 ]没有单独放在sizeof中，所以表示a[ 0 ]数组中的首元素地址，也就是a[ 0 ][ 0 ]的地址，+1就是a[ 0 ][ 1 ]的地址，是地址就是4/8个字节

5.sizeof( *( a[ 0 ] + 1)), 表示a[ 0 ][ 1 ]的大小，就是4个字节

6.sizeof( a + 1), a没有单独存放在sizeof中，所以这里表示数组a的首元素地址，就是数组a[ 0 ]的地址，是地址就是4/8个字节

7. sizeof( *( a+ 1)), 就是数组a[ 0 ]的大小，就是16个字节

8.sizeof( &a[ 0 ] + 1), &a[ 0 ]表示取出数组a[ 0 ]的地址，+1就是a[ 1 ]的地址，是地址就是4/8个字节

9. sizeof( *( &a[ 0 ] + 1)), 就是数组a[ 1 ]的大小，就是16个字节

10. sizeof( *a ), a没有单独存放在sizeof中，所以表示首元素地址，就是a[ 0 ]，所以是16个字节

11. sizeof( a[ 3 ] ), a[ 3 ]等价于*( a + 3)，越界访问了，但是大小依然是16个字节

答案如下：

三、指针笔试题

#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 main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s\n", *pa);
	return 0;
}

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;
}

上面代码结果是什么？

答案评论666我私信给你

给我三连的都是帅哥美女~