目录
求字符串长度 — strlen
size_t strlen( const char *string );1. strlen函数的返回值是size_t类型的，即无符号整型
2. srtlen函数在使用时只需传一个地址，因此这个函数需要创建一个char*类型的形参接收，它会从这个地址处开始计算字符个数，直至遇到' \0 '，结果便为字符串长度；若该字符串在初始化时没有 ' \0 '，则返回的是一个随机值。
模拟strlen函数
#include<stdio.h>
#include<assert.h>
#include<string.h>
int my_strlen1(const char* str)//计数器
{
assert(str);//断言此指针不为空
int count = 0;
while (*str++)
{
count++;
}
return count;
}
int my_strlen2(const char* str)//递归
{
assert(str);
if (*str != '\0')
{
return (1 + my_strlen2(str + 1));
}
else
{
return 0;
}
}
int my_strlen3(const char* str)//指针减指针求地址之间的元素个数
{
assert(str);
const char* temp = str;
while (*str)
{
str++;
}
return (str - temp);
}
int main()
{
char arr1[] = "LiuJiaQi1871031519";
printf("%d\n", strlen(arr1));//18
printf("%d\n", my_strlen1(arr1));//18
printf("%d\n", my_strlen2(arr1));//18
printf("%d\n", my_strlen3(arr1));//18
return 0;
}字符串拷贝 — strcpy
char *strcpy( char *strDestination, const char *strSource );1. strcpy是一个毛头小子，目标空间一定要足够大，否则strcpy不会管你空间大小，直接拷贝过去，出现越界行为。
2. strcpy返回的是目标字符串首元素地址，为char*，目的是为了实现链式访问。
3. 目标空间可修改，不能为常量字符串。
char* p = "abcdef";//不可修改
char p1[] = "KLG";//可修改4. 必须以' \0 ' 结尾，strcpy函数会将' \0 '也拷贝过去，也可理解为是拷贝结束的标志
模拟实现strcpy
#include<stdio.h>
#include<assert.h>
#include<string.h>
char* my_strcpy(char* str1, const char* str2)
{
assert(str1 && str2);
char* ret = str1;
while (*str1++ = *str2++)
{
;
}
return ret;
}
int main()
{
char arr1[50] = { 0 };
char arr2[] = "Congratulation";
printf("%s\n", my_strcpy(arr1, arr2));//链式访问
return 0;
} 运行结果：
追加字符串 — strcat
char *strcat( char *strDestination, const char *strSource );1. 源字符串必须含有' \0 '，作为结束标志；目标字符串则以' \0 '作为开始标志，从' \0 '处开始追加
2. 目标空间一定要足够大
3. 目标字符串可修改
4. 能否自己追加自己？（这个问题留给小伙伴自己探究）
模拟实现strcpy
#include<stdio.h>
#include<assert.h>
#include<string.h>
char* my_strcat(char* dest, const char* src)
{
char* copy = dest;
while (*dest)
{
dest++;
}
while (*dest++ = *src++)
{
;
}
return copy;
}
int main()
{
char arr1[100] = "GKL";
char arr2[] = "abc";
printf("%s\n", my_strcat(arr1, arr2));
return 0;
}字符串比较函数 — strcmp
int strcmp( const char *string1, const char *string2 );1. 返回值
| Value | Relationship of string1 to string2 |
| < 0 | string1 less than string2 |
| 0 | string1 identical to string2 |
| > 0 | string1 greater than string2 |
2. strcmp是如何判断的呢？
答：是根据字符的ASCII码值一对字符一对字符进行判断的。
模拟实现strcmp
#include<stdio.h>
#include<assert.h>
#include<string.h>
int my_strcmp(const char* str1, const char* str2)
{
assert(str1 && str2);
while (*str1 == *str2)
{
if (*str1 == '\0')
{
return 0;
}
str1++;
str2++;
}
return (*str1 - *str2);
}
int main()
{
char str1[] = "WASSUP";
char str2[] = "WUT";
int ret = my_strcmp(str1, str2);
if (ret >= 0)
{
printf(">=\n");
}
else
{
printf("<\n");
}
return 0;
}strncpy、strncmp 以及strncat
char *strncpy( char *strDest, const char *strSource, size_t count );
int strncmp( const char *string1, const char *string2, size_t count );
char *strncat( char *strDest, const char *strSource, size_t count );其中的n是对要操作字符的长度限制；也就是函数声明中的count。
strncpy
拷贝count个字符，如果源字符串不够count个，则补0。
strncmp
比较到出现另个字符不一样或者一个字符串结束或者count个字符全部比较完。
strncat
追加count个字符
判断是否为子字符串 — strstr
char *strstr( const char *string, const char *strCharSet );
返回值：
每个函数都返回一个指向strCharSet在string中首次出现的指针，如果strCharSet没有在string中出现，则返回NULL。如果strCharSet指向长度为0的字符串，则函数返回string。
模拟实现strstr
#include<stdio.h>
#include<assert.h>
#include<string.h>
char* my_strstr(const char* str1, const char* str2)
{
assert(str1 && str2);
const char* s1 = str1;
const char* s2 = str2;
const char* sign = str1;
while (*sign != '\0')
{
s1 = sign;
s2 = str2;
while (*s1 && *s2 && *s1 == *s2)//这里只用来比对字符是否相等
{
s1++;
s2++;
}
if (*s2 == '\0')//这必须为*s2 若此字符串查找到'\0'则代表找到了子串，若为s1就没有此效果，因为她后面可能还会有字符
{
return (char*)sign;
}
if (*sign != '\0')
{
sign++;
}
}
return NULL;
}
int main()
{
char arr1[] = "abbcdef";
char arr2[] = "bbc";
printf("%s\n", my_strstr(arr1, arr2));
return 0;
}strtok
char *strtok( char *strToken, const char *strDelimit );
返回值
所有这些函数都返回一个指向strToken中的下一个令牌的指针。当没有找到更多令牌时，它们返回NULL。每个调用通过为遇到的每个分隔符替换一个NULL字符来修改strToken。
这个函数就直接给大家上代码运行结果来解释他是干什么的吧。
我们可以看到，strstok函数可以将arr1中存储的字符串根据sign中存储的分隔符进行切割，并返回字符首地址，打印出来，以此出现该效果，但是注意我们只有首次使用需要传入arr1，以后使用我们需要传入空指针，这样他就可以根据之前保存的地址向后查找分隔符；当查找时没有找到分隔符时，会返回NULL。
细心的小伙伴儿们发现了我这里创建了一个arr2数组，这是为什么呢？因为strtok函数会将分隔符改为' \0 '，也就是会修改源字符串，而我们拷贝的字符串可以随意修改，这样就不会影响到源字符串了。
改写代码
我们知道strtok(arr2,sign)只运行一次，所以我们可以用循环来打印。
char arr1[] = "WUT@WASSUP.ANTA.LINING";
char arr2[100] = { 0 };
char sign[] = "@.";//存储分隔符
strcpy(arr2, arr1);
char* ret = 0;
for (ret = strtok(arr2, sign); ret != NULL; ret = strtok(NULL, sign))
{
printf("%s\n", ret);
} char arr1[] = "WUT@WASSUP.ANTA.LINING";
char arr2[100] = { 0 };
char sign[] = "@.";//存储分隔符
strcpy(arr2, arr1);
char* temp = strtok(arr2, sign);
while (temp != NULL)
{
printf("%s\n", temp);
temp = strtok(NULL, sign);
}
strerror
char *strerror( int errnum );
返回错误码所对应的错误信息
给大家举个例子：
当我们运行代码时，错误码会被存储在全局变量errno中。（头文件：#include <errno.h>）
内存函数
memcpy
void *memcpy( void *dest, const void *src, size_t count );//count以字节为单位
返回值
memcpy返回dest的值。
memcpy的函数声明中指针类型以及返回类型之所以为void*，是因为该函数的作者不知道我们将要复制哪些内容，这就和我们之前讲到的qsort函数所类似。
模拟实现 memcpy
void* my_memcpy(void* dest, const void* src, size_t count)
{
assert(dest && src);
void* ret = dest;
while (count--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
int main()
{
int arr[] = { 0,1,2,3,4,5,6 };
int copyarr[7] = { 0 };
my_memcpy(copyarr, arr, 28);
int i = 0;
int sz = sizeof(copyarr) / sizeof(copyarr[0]);
for (i = 0; i < sz; i++)
{
printf("%d ", copyarr[i]);
}
return 0;
}
memmove
void *memmove( void *dest, const void *src, size_t count );//count以字节为单位
返回值
memmove返回dest的值。
用运行图来解释：
我们可以看到：3，4，5，6，7替换了1，2，3，4，5
这就是这个函数的功能，那么让我们来模拟实现他吧！
模拟实现 memmove
我们以上图代码为例，将3 4 5 6 7拷贝到 1 2 3 4 5处，那么我们如何拷贝呢？
先将7赋给5的话，因为5需要赋给3，那么因为5被7覆盖了，就达不到我们所想要的结果了
所以我们先从3开始拷贝，我们可以发现，只要是dest < src，我们都可以这样拷贝；
反过来，src > dest时，我们从后向前拷贝。
总结：从重叠的地方开始拷贝。
顺序也相对应
从前向后时，3 -> 1开始（前前）
从前向后时，5 -> 7开始（后后）
void* my_memmove(void* dest, const void* src, size_t count)
{
assert(dest && src);
void* ret = dest;
if (dest < src)
{
//从前向后
while (count--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else
{
//从后向前
while (count--)//减减后为19正好对应
{
*((char*)dest + count) = *((char*)src + count);
}
}
return ret;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
my_memmove(arr1, arr1 + 2, 20);
int i = 0;
int sz = sizeof(arr1) / sizeof(arr1[0]);
for (i = 0; i < sz; i++)
{
printf("%d ", arr1[i]);
}
return 0;
} 
memset
void *memset( void *dest, int c, size_t count );//count以字节为单位
返回值
memset返回dest的值。
依然用运行结果来解释此函数：
519
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
