C语言指针plus版练习

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

一、字符串左旋

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

        1.1 分析题目

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

        1.2 解题代码

void left_move(char arr[], int sz, int n)
{while (n % sz){//将第一个元素存入tmpchar 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我私信给你

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