strcpy实现之 辛昕版

辛昕

strcpy实现之 辛昕版 [复制链接]

 

这件事告诉我们，没有测试就随手写，还以为木有问题，是一定会被打脸的。
而且现世报来的特别快。
这种态度是不对的，一定要改。

骚瑞骚瑞，把这事忘了，我果然是没啥责任心啊，诶~~
好吧，先上代码

1. char *xx_strcpy(char *s1,char *s2)
   
2. {
   
3.        char *temp;
   
4.        uint32_t s2_len = 0,i;
   
5.       
   
6.        if( (s1 == NULL) || (s2 == NULL) )
   
7.             return NULL;
   
8.   
   
9.        temp = s2;
   
10.       
    
11.        while(*temp != 0)
    
12.        {
    
13.              temp++;
    
14.              s2_len++;
    
15.        }
    
16. 
    
17.        for(i = s2_len;i > 0;i-- )
    
18.              *(s1+i) = *(s2+i);
    
19. 
    
20.        return s1;
    
21. }

复制代码

ljj3166

看完楼主造的轮子，不由得感叹一句，面向对象真TM好用……

辛昕

ljj3166 发表于 2018-6-6 10:46
看完楼主造的轮子，不由得感叹一句，面向对象真TM好用……

你说的是C++ string吧

辛昕

恕我蠢，不理解什么叫 一个方向的重叠@lcofjp
        // 没啥毛病，至于那个  少copy了一个字节 和 加0的毛病，认。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <stdint.h>
   
4. #include <string.h>
   
5. 
   
6. char *xx_strcpy(char *s1,char *s2)
   
7. {
   
8.        char *temp;
   
9.        uint32_t s2_len = 0;
   
10.            int i;
    
11.       
    
12.        if( (s1 == NULL) || (s2 == NULL) )
    
13.             return NULL;
    
14.   
    
15.        temp = s2;
    
16.       
    
17.        while(*temp != 0)
    
18.        {
    
19.              temp++;
    
20.              s2_len++;
    
21.        }
    
22. 
    
23.        for(i = s2_len;i >= 0;i-- )
    
24.              *(s1+i) = *(s2+i);
    
25.                
    
26.            *(s1 + s2_len + 1) = 0;
    
27. 
    
28.        return s1;
    
29. }
    
30. 
    
31. 
    
32. 
    
33. #define TEST_STRING "IDOYOULOVE"
    
34. 
    
35. int main(void)
    
36. {
    
37.         char s[12];
    
38.        
    
39.        
    
40.         strcpy(s,TEST_STRING);
    
41.        
    
42.         printf("strcpy:%s\n",s);
    
43.        
    
44.         xx_strcpy(s,(char *)(TEST_STRING + 4));
    
45.        
    
46.         printf("XX:%s\n",s);
    
47. 
    
48.         // 我也试过反过来，，先 strcpy(TEST_STRING + 4) 再 xx_strcpy(TEST_STRING)的；
    
49.         // 没啥毛病，至于那个  少copy了一个字节 和 加0的毛病，认。
    
50.        
    
51. }

复制代码

辛昕

https://c.runoob.com/compile/12
公司电脑加密了，太多毛病，我直接在线跑的。

bobde163

while循环后面的for循环有些多余，我之前回帖写的除了没有判断参数的合法性和返回值不一样，基本思路跟版主的差不多

辛昕

按照 lcoftp 说的，试试非字面量，而是一个 可读可写的 字符串数组
依然没啥发现

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <stdint.h>
   
4. #include <string.h>
   
5. 
   
6. char *xx_strcpy(char *s1,char *s2)
   
7. {
   
8.        char *temp;
   
9.        uint32_t s2_len = 0;
   
10.            int i;
    
11.       
    
12.        if( (s1 == NULL) || (s2 == NULL) )
    
13.             return NULL;
    
14.   
    
15.        temp = s2;
    
16.       
    
17.        while(*temp != 0)
    
18.        {
    
19.              temp++;
    
20.              s2_len++;
    
21.        }
    
22. 
    
23.        for(i = s2_len;i >= 0;i-- )
    
24.              *(s1+i) = *(s2+i);
    
25.                
    
26.            *(s1 + s2_len + 1) = 0;
    
27. 
    
28.        return s1;
    
29. }
    
30. 
    
31. 
    
32. 
    
33. #define TEST_STRING "IDOYOULOVE"
    
34. 
    
35. int main(void)
    
36. {
    
37.         char s[12];
    
38.                 char src[12] = {'0','1','2','3','4','5','6','7','8','9','a'};
    
39.         // 但这种写法要注意一个问题，比如一个12元素的数组，你要留最后一个位置，它会自动
    
40.                 // 填充0，这是不初始化的默认值，假设没这个0，这个src事实上也不是一个字符串
    
41.                 // 因为没有0结尾，所以会出现错误。
    
42.                 // 这是我在写这个测试代码的过程中发现的。
    
43.         
    
44.         strcpy(s,src + 4);
    
45.         
    
46.         printf("strcpy:%s\n",s);
    
47.         
    
48.         xx_strcpy(s,src);
    
49.         
    
50.         printf("XX:%s\n",s);
    
51. 
    
52.                 // 还是没啥毛病
    
53.         
    
54. }

复制代码

辛昕

bobde163 发表于 2018-6-6 11:18
while循环后面的for循环有些多余，我之前回帖写的除了没有判断参数的合法性和返回值不一样，基本思路跟版主 ...

虾米，你的回复？
不不不，我好像没看到有考虑到地址重叠，然后反过来复制的人。

我反过来复制不是编码习惯，是真的要反过来复制才能防止地址重叠，把0给冲没了。

star_66666

大牛啊，学习了

辛昕

@lcoftp 收到，被打脸了，等等哈

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <stdint.h>
   
4. #include <string.h>
   
5. 
   
6. char *xx_strcpy(char *s1,char *s2)
   
7. {
   
8.        char *temp;
   
9.        uint32_t s2_len = 0;
   
10.            int i;
    
11.       
    
12.        if( (s1 == NULL) || (s2 == NULL) )
    
13.             return NULL;
    
14.   
    
15.        temp = s2;
    
16.       
    
17.        while(*temp != 0)
    
18.        {
    
19.              temp++;
    
20.              s2_len++;
    
21.        }
    
22. 
    
23.        for(i = s2_len;i >= 0;i-- )
    
24.              *(s1+i) = *(s2+i);
    
25.                
    
26.            *(s1 + s2_len + 1) = 0;
    
27. 
    
28.        return s1;
    
29. }
    
30. 
    
31. 
    
32. 
    
33. int main()
    
34. {
    
35.         char test1[20] = "hello world!\n";
    
36.         char test2[20] = "hello world!\n";
    
37. 
    
38.         printf(" --- 1 -----\n");
    
39.         puts(xx_strcpy(test1, test1 + 2));
    
40.         puts(xx_strcpy(test2 + 2, test2));
    
41. 
    
42.         char test3[20] = "hello world!\n";
    
43.         char test4[20] = "hello world!\n";
    
44. 
    
45.         printf(" --- 2 ----\n");
    
46.         puts((char*)memmove(test3, test3 + 2, 10));
    
47.         puts((char*)memmove(test4 + 2, test4, 10));
    
48.     return 0;
    
49. }

复制代码

1. // 运行结果
   
2. --- 1 -----
   
3. 
   
4. 
   
5. hello world!
   
6. 
   
7. --- 2 ----
   
8. llo world!d!
   
9. 
   
10. hello worl

复制代码

bobde163

辛昕 发表于 2018-6-6 11:37
虾米，你的回复？
不不不，我好像没看到有考虑到地址重叠，然后反过来复制的人。

我反过来复制不是编 ...

防止地址重叠，这是什么原理？

辛昕

bobde163 发表于 2018-6-6 13:50
防止地址重叠，这是什么原理？

你只要画个图就明白了。
比方说
有一个数组
char s[20]; 它里面存的内容是 “0123456789012345” s[16] = 0;
好了，现在你要执行以下操作
strcpy(s + 12，s);
当你在copy的时候，s[16]早早就被填成了非0；
所以你永远找不到s结束的地方。

反过来复制，相当于我从一开始，就记录了本来结束的地方。

bobde163

辛昕 发表于 2018-6-6 14:22
你只要画个图就明白了。
比方说
有一个数组
char s[20]; 它里面存的内容是 “0123456789012345” s[16 ...

这种情况下从头开始确实是会出现被填0的情况，但是这种用法本身有潜在的危险，会对原字符串进行破坏，还有可能会出现溢出错误，如果原字符串是字符串常量，你这样就会出问题。如果是相当有把握，保证原字符串之后的内存空间可以使用，不溢出，也是可以用。