【C语言】str类与men库函数的实现（如：strcpy,strcmp,strstr,strcat,memmove,memcpy)

https://blog.csdn.net/hanjing_1995/article/details/51539583

1. strcpy

拷贝源字符串到子字符串，包括‘\0’。

代码实现：

[cpp]  view plain  copy

1. char* strcpy(char* dst,const char* src)  
2. {  
3.     assert(src);  
4.     char* ret = dst;  
5.     while (*src)  
6.     {  
7.         *dst = *src;  
8.         src++;  
9.         dst++;  
10.     }  
11.     *dst = '\0';  
12.     return ret;  
13. }  

2.strncpy:

strncpy与strcpy之间差别在于，strcpy将源字符串全部拷贝到新的字符串中，而strncpy拷贝长度由自己确定。

代码实现：

[cpp]  view plain  copy

1. char* strncpy(char* dst, const char* src, int count)  
2. {  
3.     assert(dst);  
4.     assert(src);  
5.     char* ret = dst;  
6.     while (count--)  
7.     {  
8.         *dst = *src;  
9.         dst++;  
10.         src++;  
11.     }  
12.     *dst = '\0';  
13.     return ret;  
14. }  

3.strcat:

strcat作用是链接字符串，即：

str1: hel    str2:lo    则链接后为hello。

代码实现：

[cpp]  view plain  copy

1. char* strcat(char* dst, char* src)  
2. {  
3.     assert(dst);  
4.     assert(src);  
5.     char* ret = src;  
6.     while (*src)  
7.     {  
8.         src++;  
9.     }  
10.     while (*dst)  
11.     {  
12.         *src = *dst;  
13.         dst++;  
14.         src++;  
15.     }  
16.     *dst = '\0';  
17.     return ret;  
18. }  

4.strcmp:

strcmp用来比较字符串长度。

对两个字符串自左至右逐个字符相比（按ASCII码值大小比较），直到出现不同的字符或遇到‘\0’为止。如果全部字符相同，则认为相等；若出现不相同的字符，则以第一个不相同的字符的比较结果为准。
如果两个字符串都由英文字母组成，则有一个简单的规律：在英文字典中位置在后面的为“大”，还要特别注意：小写字母比大写字母“大”。
返回值：
（1）字符串1=字符串2，返回0
（2）字符串1>字符串2，返回一个正整数
（3）字符串1<字符串2，返回一个负整数。

代码实现：

[cpp]  view plain  copy

1. int strcmp(const char* dst, const char* src)  
2. {  
3.     assert(dst);  
4.     assert(src);  
5.     while (*src&&*dst)  
6.     {  
7.         if (*src == *dst)  
8.         {  
9.             src++;  
10.             dst++;  
11.         }  
12.         else  
13.         {  
14.             return *src - *dst - '\0';  
15.         }  
16.     }  
17.     return *src - *dst - '\0';  
18. }  

5.strncmp:

与strcmp区别在于：strcmp是针对整个字符串而言，而strncmp针对指定长度。

但是要注意，如果count比两者字符串长度都短的话，则要跳出循环结束。当长度大于两者字符串长度时，仍然可以比较出是否相等。

代码实现：

[cpp]  view plain  copy

1. int strncmp(const char* dst, const char* src,size_t count)  
2. {  
3.     assert(dst);  
4.     assert(src);  
5.     while (count--&&*src&&*dst)  
6.     {  
7.         if (*src == *dst)  
8.         {  
9.             src++;  
10.             dst++;  
11.         }  
12.         else  
13.         {  
14.             return *src - *dst - '\0';  
15.         }  
16.     }  
17.     return *src - *dst - '\0';  
18. }  

6.strstr:

寻找子字符串，我们在源字符串设置一个指针，用做来当此时确实满足是子串标志原串的位置，如下面的p。而s1,s2分别用作来遍历。

代码实现：

[cpp]  view plain  copy

1. char* strstr(const char* dst, const char* src)  
2. {  
3.     assert(dst);  
4.     assert(src);  
5.     char* s1 = dst;  
6.   
7.     char* p = src;  
8.     char* s2 = p;  
9.   
10.     while (*s2)  
11.     {  
12.         s1 = dst;  
13.         s2 = p;  
14.         while (*s2 && *s1)  
15.         {  
16.             if (*s2 == *s1)  
17.             {  
18.                 s1++;  
19.                 s2++;  
20.             }  
21.             else  
22.             {  
23.                 p++;   
24.                 break;  
25.             }  
26.         }  
27.         if (*s1 == '\0')  
28.         {  
29.             return p;  
30.         }  
31.     }  
32.     return NULL;  
33. }  

7.memcpy:

strcpy完成字符串的拷贝，而对于非字符串类的，却要用memcpy完成内存拷贝。

代码实现：

[cpp]  view plain  copy

1. void* memcpy(void* dst, const void* src, size_t count)  
2. {  
3.     assert(dst);  
4.     assert(src);  
5.     char* dst_ = (char*)dst;  
6.     char* src_ = (char*)src;  
7.     while (count--)  
8.     {  
9.         *dst_++ = *src_++;  
10.     }  
11.     //即使此时count不为0，但是当我们将原数拷贝到新的数据结束，那也要结束程序。  
12.     *dst_ = '\0';//必须加上结束标志，否则会乱码  
13.     return dst;  
14. }  

8.memmove:

memmove在于它可解决内存重叠问题。

如：将1，2，3，4，5，6，7，8中的1，2，3，4移动到3，4，5，6位置。那么则仍然按照memcpy则会，将1移动到3处，2移动到4处，再准备移动3时发现此时的3已经由于被移动到此处的1覆盖而丢失。4同理。这就是memmove的优势所在。我们分情况即可解决。

代码实现：

[cpp]  view plain  copy

1. void memmove(void* dst, const void* src, size_t count)  
2. {  
3.     assert(dst);  
4.     assert(src);  
5.     char* dst_ = (char*)dst;  
6.     char* src_ = (char*)src;  
7.     if (dst_ > src_&&dst < dst_ + count)  
8.     {  
9.         while (count--)  
10.         {  
11.             *(dst_+count) = *(src_+count);  
12.             dst_++;  
13.             src_++;  
14.         }  
15.     }  
16.     else  
17.     {  
18.         while (count--)  
19.         {  
20.             *dst_ = *src_;  
21.             dst_++;  
22.             src_++;  
23.         }  
24.     }  
25.     *dst_ = '\0';  
26.     return dst;  
27. }  

本文出自 “Han Jing's Blog” 博客，请务必保留此出处http://10740184.blog.51cto.com/10730184/1765040

个人分类：  C语言