目录
1.求字符串长度函数
?1.1 strlen
size_t strlen ( const char * str );
用来求字符串的长度。
字符串以?'\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包
含 '\0' )。
参数指向的字符串必须要以 '\0' 结束。
函数的返回值为size_t，是字符串的个数，是无符号整型。
使用样例：
#include<stdio.h>
#include<string.h>
int main()
{
char str[] = "duachebdbvla";
int sz = sizeof(str);
printf("%d", sz);
return 0;
}strlen的模拟实现：
int my_strlen(const char* str)
{
assert(str);
int i = 0;
while (*str++)
{
i++;
}
return i;
}
2.长度不受限制的字符串函数
?2.1 strcpy
char* strcpy(char * destination, const char * source );
用来拷贝字符串。
源字符串必须以 '\0' 结束。
会将源字符串中的 '\0' 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。
使用样例：
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "duachebdbv";
char str2[20] = "0";
strcpy(str2, str1);
printf(str2);
return 0;
}strcpy的模拟实现：
char* my_strcpy(char*des,const char*src)
{
char* tmp = des;
assert(des && src);
while (*des++ = *src++;)
{
;
}
return tmp;
}?2.2 strcmp
int strcmp ( const char * str1, const char * str2 );
用来比较字符串的大小。
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
?
使用样例：
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "asdfghj";
char str2[20] = "awsdefghjjjk";
int ret=strcmp(str1, str2);
if (ret > 0)
{
printf("str1>str2");
}
else if (ret == 0)
{
printf("str1=str2");
}
else
{
printf("str1<str2");
}
return 0;
}注：因为strcmp不是比较字符串长度，而是比较相同下标对应的字符的ascii码值，若字符相同，则比较下一个，直到二者不同为止。此代码因str1[0]和str2[0]都是a,因此比较下一个字符，str1[1]是‘s’，str2[1]是‘w’，而s的ascii码值小于w的ascii值，因此返回一个小于0的整型。
模拟实现：
int my_strcmp(const char* str1, const char* str2)
{
assert(*str1 && *str2);
while (*str1 || *str2)
{
if (*str1 == *str2)
{
str1++;
str2++;
}
else
{
return *str1 - *str2;
}
}
return 0;
}
?2.3?strcat
char * strcat ( char * destination, const char * source );
拷贝一个字符串到另一个字符串的末尾。
源字符串必须以 '\0' 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
使用样例：
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "kajhcjeef";
char str2[40] = "jdsafbkw";
strcat(str2, str1);
printf(str2);
return 0;
}
模拟实现：
char* my_strcat(char* des, const char* scr)
{
char* tmp = des;
assert(des && scr);
while (*des)
{
des++;
}
while (*des++=*scr++)
{
;
}
return tmp;
}以上的strcoy,strcmp,strcat这三个函数的实现无非就是遇到‘\0’停止或者比较两个字符的大小，与字符串的长度无关，因此我们可以认为这三种函数是长度不受限制的。而接下来的strncoy,strncmp,strncat就与长度有关了。
3.长度受限制的字符串函数
?3.1 strncoy
char * strncpy ( char * destination, const char * source, size_t num );
?拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
使用样例：
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "kajhcjeef";
char str2[40] = "jdsafbkw";
strncpy(str2, str1,3);
printf(str2);
return 0;
}
?模拟实现：
char* my_strncpy(char* des, const char* scr, int num)
{
char* ret = des;
assert(des && scr);
while (num--&&*scr&&*des)
{
*des++ = *scr++;
}
return ret;
}?3.2 strncmp
int strncmp ( const char * str1, const char * str2, size_t num );
用来比较两个字符串前num个字符的大小。
?比较到两个字符不同停止或者一个字符串结束停止或者比较字符个数为num个之后停止。当str1的前num个字符组成的字符串大于str2的前num个字符组成的字符串时返回一个大于0的整型，等于时返回0，小于时返回一个小于0的整型。
使用样例：
#include<string.h>
#include<stdio.h>
int main()
{
char str1[20] = "jajhcjeef";
char str2[40] = "jasafbkwn";
int ret=strncmp(str1, str2, 3);
printf("%d", ret);
return 0;
}
模拟实现：
int my_strncmp(const char* str1, const char* str2, int num)
{
assert(str1 && str2);
while (num--&&(*str1||*str2))
{
if (*str1 != *str2)
{
return *str1- *str2;
}
else
{
str1++;
str2++;
}
}
return 0;
}
?3.3 strncat
char * strncat ( char * destination, const char * source, size_t num );
?用来追加字符串。
将字符串source的前num个字符拷贝至字符串destination的末尾（从‘\0’开始）。
使用样例：
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "jajhcjeef";
char str2[40] = "ja";
strncat(str2, str1, 6);
printf(str2);
return 0;
}
模拟实现：
#include<stdio.h>
#include<assert.h>
char* my_strncat(char* des, const char* scr, int num)
{
char* ret = des;
assert(des && scr);
while (*des)
{
des++;
}
while (num && ((*des++ = *scr++) != '\0'))
{
num--;
}
if (num == 0)
*des = '\0';
return ret;
}?4.字符串查找
?4.1 strstr
char * strstr ( const char *str1, const char * str2);
在字符串str1中查找字符串str2，若找到，则返回字符串str1中与字符串str2相同的片段字符串的起始地址?。
使用样例：
#include<stdio.h>
#include<string.h>
int main()
{
char str1[20] = "jajhcjeef";
char str2[40] = "cj";
char* tmp = strstr(str1, str2);
printf("%s",tmp);
return 0;
}
模拟实现：
#include<stdio.h>
//#include<string.h>
#include<assert.h>
char* my_strstr(const char* str, const char* substr)
{
const char* s1 = str;
const char* s2 = substr;
const char* cur = str;
assert(str && substr);
if (*substr == '\0')
{
return (char*)str;
}
while (*cur)
{
s1 = cur;
s2 = substr;
while (*s1 && *s2 && *s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
return (char*)cur;
cur++;
}
return NULL;
}?4.2 strtok
char * strtok ( char * str, const char * sep );
用来将字符串根据用户指定的分隔符进行分割。
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标
记。第二个参数sep是个字符串，定义了用作分隔符的字符集合。
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：
strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容
并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串
中的位置。
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标
记。
如果字符串中不存在更多的标记，则返回 NULL 指针。
使用样例：
#include<stdio.h>
#include<string.h>
int main()
{
char str1[50] = "zhouling#123.b@uo";
const char sep[10] = "#.@";
char arr[50];
char* ch = NULL;
strcpy(arr, str1);
for (ch = strtok(arr, sep);ch != NULL; ch = strtok(NULL, sep))
{
printf("%s\n", ch);
}
return 0;
}
5.内存操作函数
?5.1 memcpy
void *memcpy( void *dest, const void *src, size_t count );
函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 '\0' 的时候并不会停下来。此函数与strcmp有点相似，但此函数可以拷贝整型或其他类型的数据。
如果source和destination有任何的重叠，复制的结果都是未定义的。
使用样例1：
#include<stdio.h>
int main()
{
char str1[] = "zhouling";
char str2[] = "mlanvkml";
int arr1[4] = { 1,2,3,4 };
int arr2[4] = { 5,6,7,8 };
int i = 0;
char*str = memcpy(str2, str1, sizeof(str1[0]) * 2 );
int* arr = memcpy(arr1, arr2, sizeof(arr1[0]) * 2);
for (i = 0; i < 4; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
printf("%s", str);
return 0;
}
?使用样例2：
#include<stdio.h>
#include<string.h>
struct PeoPle
{
char name[20];
int age;
}People1,People2;
int main()
{
char myname[] = "zhouling";
People1.age = 18;
memcpy(People1.name, myname, sizeof(myname)+1);
memcpy(&People2, &People1, sizeof(People1));
printf("People2:%s %d", People2.name, People2.age);
return 0;
}
?
?
模拟实现：
void* my_memcpy(void* dst, const void* src, size_t count)
{
void* ret = dst;
assert(dst&&src);
while (count--)
{
*(char*)dst = *(char*)src;
dst = (char*)dst + 1;
src = (char*)src + 1;
}
return ret;
}?5.2 memmove
void * memmove ( void * destination, const void * source, size_t num );
功能与memcpy基本一样，但和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就最好使用memmove函数处理。
使用样例：
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "I don't love you and you like.......me";
memmove(str + 25, str + 2,11);
puts(str);
return 0;
}
?模拟实现：
void * my_memmove(void* des, const void* scr, int num)
{
void* ret = des;
assert(des && scr);
while (num--)
{
if (des < scr)
{
*((char*)des)++ = *((char*)scr)++;
}
else
{
*((char*)(des)+num) = *((char*)(scr)+num);
}
}
return ret;
}?5.3 memcpy
int memcmp( const void *buf1, const void *buf2, size_t count );
比较从ptr1和ptr2指针开始的num个字节，前者大于后者大于返回一个大于0的整型，反之则返回一个小于0的整型，相等就返回0。
?使用样例：
#include <stdio.h>
#include <string.h>
int main()
{
char buffer1[] = "zhouzhou";
char buffer2[] = "zhdhZhou";
int n;
n = memcmp(buffer1, buffer2, 2);
if (n > 0) printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
else if (n < 0) printf("'%s' is less than '%s'.\n", buffer1, buffer2);
else printf("'%s' is the same as '%s'.\n", buffer1, buffer2);
return 0;
}
模拟实现：
int my_memcmp(const void* buf1, const void* buf2, size_t count)
{
void* tmp1 = buf1;
void* tmp2 = buf2;
assert(buf1 && buf2);
while (count--)
{
if (*((char*)tmp1) != *((char*)tmp2))
{
return *((char*)tmp1) - *((char*)tmp2);
}
((char*)tmp1)++;
((char*)tmp2)++;
}
}好了，今天的学习笔记分享就到此结束啦，看到这里的友友们给个赞吧
?