[已解决]s1++ == *s2++和*dst++ = *src++ 指针移动问题

是小利同学

求助鱼友答疑

【先欣赏张美图，静静心！】

3

在自定义字符串处理函数时遇到一些困难！！

【话不多说先上代码】

【1.自定义比较字符串函数 mycmp()】

1. #include<stdio.h>
   
2. #include<string.h>
   
3. 
   
4. int mycmp1(const char* s1,const char* s2);
   
5. int mycmp2(const char* s1,const char* s2);
   
6. 
   
7. int main(int argc,char const *argv[]){
   
8.          char s1[] = "abc";
   
9.          char s2[] = "Abc";
   
10.         
    
11.         printf("mycmp1(s1,s2) = %d\n",mycmp1(s1,s2));
    
12.         printf("mycmp2(s1,s2) = %d\n",mycmp2(s1,s2));
    
13.         return 0;
    
14.         
    
15. }
    
16. /*
    
17.         @@自定义比较字符串函数 mycmp()
    
18.                 mycmp1()  数组的方式实现
    
19.                 mycmp2() 指针的方式实现
    
20.         @比较两个字符串大小
    
21.                 1.若s1等于s2,若字符串长度相等，且每一个字符都对应相等，则返回0
    
22.                 2.若s1大于s2,依次比较s1s2的每个字符，若存在s1的字符>s2的字符，且是第一次出现，返回这两个字符的差值（正数 ） ，结束比较
    
23.                 3若s1小于s2,依次比较s1s2的每个字符，若存在s1的字符<s2的字符，且是第一次出现，返回这两个字符的差值（负数） ，结束比较
    
24.         
    
25. */
    
26. int mycmp1(const char* s1,const char* s2){
    
27.         int index = 0;
    
28.         while(s1[index] == s2[index] && s1[index] != '\0'){
    
29.                 index++;
    
30.         }
    
31.         return s1[index] - s2[index];
    
32. }
    
33. 
    
34. int mycmp2(const char* s1,const char* s2){
    
35.         while(*s1 == *s2 && *s1 != '\0'){
    
36.                 s1++;
    
37.                 s2++;
    
38.         }
    
39.         return *s1 - *s2;
    
40. }
    
41. /**
    
42.         @为什么循环不能写成while(*s1++ == *s2++ && *s1 != '\0'); 为什么呢？
    
43.         ->我的猜想如下：
    
44.          1.首先，s1++ == *s2++是一个判断语句，因为这时s1++、s2++只是做判断使用,没有赋值给新的指针保存，并没有真正的移动指针，
    
45.            所以无论s1,s2如何自增自减，s1,s2还是指向原来的地址
    
46.         （ps:我感觉这时的s1++或者s1--;和s1+1,s1-1效果一样(而不是s1 = s1 + 1;)，只是借助s1,读了s1的下一位，并没有移动s1的指向）
    
47. */

复制代码

【问题1】
   1.上述代码中，为什么while循环不能写成while(*s1++ == *s2++ && *s1 != '\0'); 为什么呢？（ps:代码中有我的猜测，请指出错误）


【2.自定函数mycpy()复制字符串】

1. #include<stdio.h>
   
2. #include<string.h>
   
3. #include<stdlib.h>
   
4. 
   
5. char *mycpy1(char* dst,const char* src);
   
6. char *mycpy2(char* dst,const char* src);
   
7. 
   
8. int main(int argc,char const *argv[]){
   
9.         char src[] = "Hello world!";
   
10.         char *dst = (char*)malloc(strlen(src)+1);//sizeof(char)*sizeof(src)
    
11. 
    
12.         printf("mycpy1(dst,src) = %s\n",mycpy1(dst,src));
    
13.         printf("mycpy2(dst,src) = %s\n",mycpy2(dst,src));
    
14.          
    
15.         return 0;
    
16. }
    
17. /**
    
18.         @自定函数
    
19.                 mycpy(),复制字符串
    
20.                 mycpy1()  数组的方式实现
    
21.                 mycpy2() 指针的方式实现
    
22. */
    
23. char *mycpy1(char* dst,const char* src){
    
24.         int inx = 0 ;
    
25.         while(src[inx]){//src[inx] != '\0'
    
26.                  dst[inx] = src[inx];
    
27.                  inx++;
    
28.         }
    
29.         dst[inx] = '\0';//dst[inx] = src[inx];
    
30.         
    
31.         return dst;
    
32. }
    
33. char *mycpy2(char* dst,const char* src){
    
34.         char * ret = dst;
    
35.         
    
36.         while(*dst++ = *src++);
    
37.         *dst = '\0';//*dst = *src
    
38.         
    
39.         return ret;
    
40. }
    
41. /**
    
42.         @这里 *dst++ = *src++ 指针为什么又可以通过 自增自减 来移动指针？
    
43.          我的猜想如下：
    
44.          1、 首先，*dst++ = *src++ 这是一个赋值运算，先看指针src自增并取值后，赋值给了*dst，正是因为赋值运算，使得指针src可以移动
    
45.          2、而*dst++，显然这一个可以运算的式子，但同时它也是一个左值，是一个变量，正因为如此，使得指dst的自增运算可以被变量保存
    
46.         （ps:我感觉这时的指针dst或着指针src可以自增，关键在于有了个左值，以及赋值运算符，保存了指针的自增）
    
47. */
    
48. 
    
49. /**        
    
50.         @@mycpy2() 指针的方式实现，三种不同的循环写法
    
51.         @1
    
52.         while(*src != '\0'){
    
53.                  *dst = *src;
    
54.                  dst++;
    
55.                  src++;
    
56.         }
    
57.         @2
    
58.         while(*src){
    
59.                  *dst++ = *src++;
    
60.         }
    
61.         @3
    
62.         while(*dst++ = *src++);
    
63. */

复制代码

【问题2】
2.上述代码中，@这里 *dst++ = *src++ 指针为什么又可以通过 自增自减 来移动指针？ 为什么呢？（ps:代码中有我的猜测，请指出错误）

【3.@自定函数mycat()复制字符串】

1. #include<stdio.h>
   
2. #include<string.h>
   
3. 
   
4. char * mycat1(char *dst,const char *src);
   
5. char * mycat2(char *dst,const char *src);
   
6. 
   
7. int main(int argc,char const *argv[]){
   
8.         char dst[] = "Hello ";
   
9.         char src[] = "world!";
   
10.         
    
11. //        printf("mycat1(dst,src) = %s\n",mycat1(dst,src));
    
12.         printf("mycat2(dst,src) = %s\n",mycat2(dst,src));
    
13.         return 0;
    
14. }
    
15. /**
    
16.         @自定函数
    
17.                 mycat(),复制字符串
    
18.                 mycat1()  数组的方式实现
    
19.                 mycat2() 指针的方式实现
    
20. */
    
21. char * mycat1(char *dst,const char *src){
    
22.         int inx = 0;
    
23.         
    
24.         int dstlen = strlen(dst);
    
25.         while(src[inx] != '\0'){        
    
26.                 dst[dstlen+inx] = src[inx];
    
27.                 inx++;        
    
28.         }
    
29.         dst[dstlen+inx] = '\0';
    
30.         return dst;        
    
31. }
    
32. 
    
33. char * mycat2(char *dst,const char *src){
    
34.         char *ret = dst;
    
35.         dst = dst + strlen(dst);
    
36.         while(*dst++ = *src++);
    
37.         *dst = '\0';
    
38.         return ret;        
    
39. }

复制代码

【问题3】
3.上述几个程序中有相同的代码while(*dst++ = *src++); *dst = '\0';  这里想问该while(*dst++ = *src++);循环最后一次是否将*dst赋值 '\0' ?下面一行的*dst = '\0';是否多余？


期待各位鱼友和大佬们的解答，感谢！

最佳答案

月排行榜 / 总排行榜

歌者文明清理员

2023-6-4 23:29:03

是小利同学 发表于 2023-6-4 23:33
你为什么回答的这么快，是不是用了什么”高科技“

手动回答，chat2.jinshutuan.com

跳转到最佳答案楼层

是小利同学

1.为什么循环不能写成while(*s1++ == *s2++ && *s1 != '\0'); 为什么呢？

1. int mycmp2(const char* s1,const char* s2){
   
2.         while(*s1 == *s2 && *s1 != '\0'){
   
3.                 s1++;
   
4.                 s2++;
   
5.         }
   
6.         return *s1 - *s2;
   
7. }
   
8. int mycmp3(const char* s1,const char* s2){
   
9.         while(*s1++ == *s2++ && *(s1-1) != '\0');
   
10.         return *(s1-1) - *(s2-1);        //*--s1 - *--s2
    
11. }

复制代码

        1.当然可以写成这样，不过需要给动一下-> while(*s1++ == *s2++ && *(s1-1) != '\0');
                2.*s1++ == *s2++，每次比较结束后指针自增（指向后移），
                当判断到最后一位'\0'时，*(s1-1) != '\0'，这是s1指向的'\0'后面的字符,故要-1令其指向'\0'
                3.故当比较结束返回的时候，我们需要对s1，s2前移减一，让指针指向正确的值 如：mycmp3()        
                                                                                                        
2.这里 *dst++ = *src++ 指针为什么又可以通过 自增自减 来移动指针？ 为什么呢？

1. char *mycpy2(char* dst,const char* src){
   
2. char * ret = dst;
   
3. while(*dst++ = *src++);
   
4. return ret;
   
5. }

复制代码

         1.无论 *s1++ == *s2++ 还是 *dst++ = *src++ 都可以移动指针
        2.但要注意自增自减的指针是否指向了预想的地址。
        3.*dst++在while做循环条件时要特别注意：即使条件不满足也会进行自增，这是当我们还要用这个指针时做其他事情时就要判断指针的指向问题（一般需要自减）

3.while(*dst++ = *src++);循环结束指针的指向问题

1. char * mycat2(char *dst,const char *src){
   
2.         char *ret = dst;
   
3.         dst = dst + strlen(dst);    //det->'\0'
   
4.         while(*dst++ = *src++);
   
5.         return ret;        
   
6. }

复制代码

        1.首先声明++的优先级高于*，虽然是是dst++，但取值*是++之前的地址
        2.循环条件一次执行的顺序：src自增，dst自增 -> 然后把src自增之前指向的位置取值*,赋值给dst自增之前指向的位置
            -> 判断dst自增之前的向的位置的值是否为 '\0'
         3.显然，易知src代表的那个字符串最后一位'\0'一定会赋值在dst代表那个字符串最后一位，为什么？因为当while判断'\0'循环才会退出
         4.这时当循环退出时，src，dst都已经自增， src指向src那个字符串'\0'的后面一位，dst指向dst那个字符串'\0'的后面一位
          5.这时我们发现 src，dst 这两个字符串的指针都已经越界访问了，所以*dst = '\0';时是多余的，或着说是不必要的

歌者文明清理员

是小利同学 发表于 2023-6-4 23:33
你为什么回答的这么快，是不是用了什么”高科技“

手动回答，chat2.jinshutuan.com

歌者文明清理员

【问题1】
循环不能写成 while(*s1++ == *s2++ && *s1 != '\0')，因为这个循环会导致指针 s1 和 s2 在判断完毕之后，再分别自增一次，这就导致了 s1 和 s2 指向了下一个字符，但根据逻辑，在只判断字符是否相同时，指针不应该向后移动，否则有可能错过比较。因此，正确的循环写法是 while (*s1 == *s2 && *s1 != '\0') { s1++; s2++; }。

【问题2】
在语句 *dst++ = *src++ 中，先执行取 src 指针所指向的值 *src，赋值给 dst 指针所指向的地址 *dst，然后再让指针 dst 和 src 分别自增一次。因此，整个语句的作用是把 src 所指向的字符串中的每一个字符依次复制到 dst 所指向的字符串中，并通过指针操作完成字符串的移动。

【问题3】
循环 while (*dst++ = *src++) 最后一次执行时，仍然会把 src 指针所指向的值复制到 dst 指针所指向的地址，但此时已经是字符串结束符 '\0'，因此会把 '\0' 复制到 dst 所指向的字符串的最后一位，从而保证 dst 所指向的字符串以 '\0' 结尾。因此，*dst = '\0' 是多余的。

是小利同学

歌者文明清理员 发表于 2023-6-4 23:30
【问题1】
循环不能写成 while(*s1++ == *s2++ && *s1 != '\0')，因为这个循环会导致指针 s1 和 s2 在判断 ...

你为什么回答的这么快，是不是用了什么”高科技“

isdkz

【问题1】
   上述代码中，为什么while循环不能写成while(*s1++ == *s2++ && *s1 != '\0'); 为什么呢？

你的理解是正确的。 s1++  和  s2++  这两个操作并不仅仅是比较，它们同时会改变指针的位置。因此， *s1++ == *s2++  会比较两个字符，并将指针向后移动。之后的  *s1 != '\0'  是在比较移动后的字符，而非原本要比较的字符，因此不会得到期望的结果。

【问题2】
2.上述代码中，@这里 *dst++ = *src++ 指针为什么又可以通过 自增自减 来移动指针？ 为什么呢？

在 C 中， *dst++ = *src++  语句的含义是先将  *src  的值赋给  *dst ，然后  dst  和  src  都向后移动一位。这里的  ++  操作符改变了指针的位置。所以在这种情况下， ++  是用于移动指针的。

你的猜想是正确的，这个操作中， *dst++ = *src++  既是一个赋值运算，又是一个移动指针的操作。

【问题3】
3.上述几个程序中有相同的代码while(*dst++ = *src++); *dst = '\0';  这里想问该while(*dst++ = *src++);循环最后一次是否将*dst赋值 '\0' ?下面一行的*dst = '\0';是否多余？

while(*dst++ = *src++)  这个循环将  src  字符串中的字符逐个复制到  dst  中，直到遇到  src  的末尾标志 '\0'，然后停止。当  src  遇到 '\0' 时， *src  为 '\0'，这个 '\0' 也会被赋值给  *dst ，但随后  dst  自增，使得  dst  指向了字符串的下一个位置，即原  dst  字符串的 '\0' 位置。所以  *dst = '\0'  这一行并不多余，它确保了  dst  字符串的结束标志。

总结，你的理解是基本准确的，继续学习C语言，你将对这些概念有更深入的理解。

不二如是

配图用的好

是小利同学

编辑测试帖

是小利同学

歌者文明清理员 发表于 2023-6-4 23:29
手动回答，chat2.jinshutuan.com

不错不错，不过回答不是我最想要的答案
不过问题我已经解决，看我顶置贴

是小利同学

isdkz 发表于 2023-6-4 23:39
【问题1】
   上述代码中，为什么while循环不能写成while(*s1++ == *s2++ && *s1 != '\0'); 为什么呢？

...

问题已经解决，感谢解答