size_t strlen (const char*str);
ps:size_t类型就是unsigned int类型
字符串以' '作为结束标志，strlen函数返回的是在字符串中' '前面出现的字符个数
需要注意的是strlen返回的是一个 unsigned int类型的整数，所以不能用相减的方式判断两个字符串长度的大小
strlen("abc") - strlen("abcd")
模拟实现：
#include2、strcpy#include #include int my_strlen(const char* str) { int count = 0; assert(str); while (*str++) { count++; } return count; } int main() { char str[] = "abcdef"; printf("%dn", strlen(str)); printf("%dn", my_strlen(str)); return 0; }
char* strcpy(char* destination, const char* source)
将源字符串拷贝打目标空间,返回目标空间首元素地址
源字符串必须以' '结束
会将源字符串中的' '拷贝到目标空间
目标空间必须足够大
目标空间必须可变
模拟实现：
#define _CRT_SECURE_NO_WARNINGS #include3、strcat#include #include char* my_strcpy(char* dest, const char* scr) { char* ret = dest; assert(dest && scr); while (*dest++ = *scr++) { ; } return ret; } int main() { char arr1[] = "abcdef"; char arr2[20] = { 0 }; my_strcpy(arr2, arr1); printf("%s", arr2); return 0; }
char* strcat(char* destination,const char* source);
将源字符串的内容追加到目标字符串后面，返回目标字符串首元素地址
源字符串必须以' '结束
目标空间必须足够大
目标空间可修改
不能自己追加自己
模拟实现:
#define _CRT_SECURE_NO_WARNINGS #include4、strcmp#include #include char* my_strcat(char* dest, const char* scr) { char* ret = dest; assert(dest, scr); while (*dest)//找到目标字符串中的' ' { dest++; } while (*dest++ = *scr++) { ; } return ret; } int main() { char str1[20] = "holle "; char str2[] = "world!"; my_strcat(str1, str2); printf("%s", str1); return 0; }
int strcmp(const char* str1,const char* str2);
比较两个字符串的大小
如果第一个字符串大于第二个字符串，返回大于0的数字
如果第一个字符串等于第二个字符串，返回0
如果第三个字符串小于第二个字符串，返回小于1的数字
模拟实现：
#define _CRT_SECURE_NO_WARNINGS #include4、strncpy#include #include int my_strcmp(const char* str1, const char* str2) { assert(str1 && str2); while (*str1 == *str2) { if (*str1 == ' ') { return 0; } str1++; str2++; } return *str1 - *str2; } int main() { char str1[] = "abcd "; char str2[] = "abce "; printf("%d", my_strcmp(str1, str2)); return 0; }
char* strncpy( char* destination, const char* source,size_t num );
拷贝num个字符从源字符串到目标空间
如果源字符串的长度小于num，则拷贝完源字符串后，在目标的后面追加0，直到num个
模拟实现：
#define _CRT_SECURE_NO_WARNINGS #include5、strncat#include #include char* my_strncpy(char* dest, const char* src, int num) { char* ret = dest; while (num--) { if (!*src)//源字符串已经全部拷贝 { *dest++ = 0; } else { *dest++ = *src++; } } return ret; } int main() { char arr1[20] = "xxxxxxxxxxxxxxxxx"; char arr2[] = "abcdef"; my_strncpy(arr1, arr2,8); printf("%s", arr1); return 0; }
char* strncat( char* destination, const char* source,size_t num );
将源字符串中的num的字符追加到目标字符串后，追加后会在末尾追加' '
如果追加个数大于源字符串字符个数，则全部追加完即可
模拟实现：
#define _CRT_SECURE_NO_WARNINGS #include6、strncmp#include #include char* my_strncat(char* dest, const char* src, int num) { char* ret = dest; assert(dest && src); while (*dest) { dest++; } while (num--) { if (!*src) { break; } *dest++ = *src++; } return ret; } int main() { char str1[20] = "holle "; char str2[] = "world!"; my_strncat(str1, str2, 3); printf("%s", str1); return 0; }
int strcmp(const char* str1,const char* str2，int num);
比较前num个字符
模拟实现：
#define _CRT_SECURE_NO_WARNINGS #include#include #include int my_strncmp(const char* str1, const char* str2, int num) { while (num--) { if (*str1 == *str2) { if (!*str1) { return 0; } str1++; str2++; } else { return *str1 - *str2; } } return 0; } int main() { char str1[] = "abcd"; char str2[] = "abce"; printf("%d", my_strncmp(str1, str2, 3)); return 0; }
7、strstr
char* strstr( const char* string,const char* strCharSet);
查找一个字符串的子串，如果找到了返回子串首元素地址，如果没找到，返回NULL
模拟实现：
#define _CRT_SECURE_NO_WARNINGS #include#include #include char* my_strstr(const char* str, const char* substr) { char* current = str; char* s1 = str; char* s2 = substr; assert(str && substr); while (*current) { s1 = current; s2 = substr; while (*s1 && *s2 && *s1 == *s2) { s1++; s2++; } if (!*s2) { return current; } current++; } return NULL; } int main() { char str1[] = "abbccbcddef"; char str2[] = "bcd"; char* ret = my_strstr(str1, str2); if (ret == NULL) { printf("没找到n"); } else { printf("%s", ret); } return 0; }
字符串匹配中有一个效率更高的算法-KMP算法，将在数据结构讲解
8、strtokchar* strtok( char* str, const chat* sep);
sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，她包含了0个或者多个由sep字符串中一个或者多个分隔符的标记
strtok函数找到str中的下一个标记，并将其用 结尾，返回一个指向这个标记的指针
strtok函数的第一个不为NULL，函数将找到str中第一个标记，strtok函数将保存它再字符串中的位置
strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记
如果字符串中不存在更多的标记，则返回NULL指针
范例：
9、strerrorchar* strerror(int errnum);
返回错误码所对应的错误信息
范例：
#define _CRT_SECURE_NO_WARNINGS #include10、字符分类函数#include #include int main() { FILE* pf = fopen("sss.txt", "r");//在这个工程目录中，打开sss.txt这个文件，这个文件是不存在的,调用失败会返回NULL //在使用库函数的时候，发生错误时会把全家变量errno设置为本次的错误 if (!pf) { printf("%s", strerror(errno)); } else { fclose(pf); pf = NULL; } return 0;
| 函数 | 如果它的参数符合下列条件就返回真 |
| iscntrl | 任何控制字符 |
| isspace | 空白字符：' ' , 'f' , 'n , 't' , 'v' |
| isdigit | 十进制数字0-9 |
| isxdigit | 十六进制数字 |
| islower | 小写字母 |
| isupper | 大写字母 |
| isalpha | 字母 |
| isalnum | 数字或者字母 |
| ispunct | 标点符号 |
| isgraph | 任何图形字符 |
| isprint | 任何打印字符 |
void* memcpy(void* destination, const void* source,size_t num);
按字节拷贝,拷贝num个字节
范例：
#define _CRT_SECURE_NO_WARNINGS #include#include int main() { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int arr2[9] = { 0 }; int count = sizeof(arr1) / sizeof(arr1[0]); memcpy(arr2, arr1, count * sizeof(int)); for (int i = 0; i < count; i++) { printf("%d ", arr2[i]); } return 0; }
模拟实现：
#include#include #include void* my_memcpy(void* dest, const void* src, int num) { void* ret = dest; assert(dest && src); void* d = dest; void* s = src; //考虑自拷贝 if (dest>src)//从后往前拷贝 { while (num--) { d = (char*)dest + num; s = (char*)src + num; *(char*)d = *(char*)s; } return ret; } else//从前往后拷 { while (num--) { *(char*)dest = *(char*)src; dest = (char*)dest + 1; src = (char*)src + 1; } return ret; } } int main() { int arr1[] = { 1,2,3,4,5,6,7,8,9 }; int count = sizeof(arr1) / sizeof(arr1[0]); my_memcpy(arr1+2, arr1, 16); for (int i = 0; i < 9; i++) { printf("%d ", arr1[i]); } return 0; }
12、 memmove
在C语言中，memcpy的标准是不考虑自拷贝的，但是现在一般都支持自拷贝了，所以memmove功能与memcpy相同，memmove包含memcpy
13、memcmpint memcmp( const void* ptr1, const void* ptr2,size_t num );
比较从ptr1和ptr2指针开始的num个字节
范例：
#define _CRT_SECURE_NO_WARNINGS #include#include int main() { int arr1[] = { 1,2,3,4,5,6 }; int arr2[] = { 1,2,4,4,5,6 }; printf("%d",memcmp(arr1, arr2, 9)); return 0; }
模拟实现：
#define _CRT_SECURE_NO_WARNINGS #include14、memset#include #include int my_memcmp(const void* str1, const void* str2, int num) { assert(str1 && str2); while (num--) { if (*(char*)str1 == *(char*)str2) { str1 = (char*)str1 + 1; str2 = (char*)str2 + 1; } else { return (int)( * (char*)str1 - *(char*)str2); } } return 0; } int main() { int arr1[] = { 1,2,3,4,5,6 }; int arr2[] = { 1,2,4,4,5,6 }; printf("%d",my_memcmp(arr1, arr2, 9)); return 0; }
void* memset(void* dest,int c,size_t count);
将dest起的前num个字节设为c
范例：
#define _CRT_SECURE_NO_WARNINGS #include#include int main() { char str[10] = { 'y' ,'y' ,'y' ,'y' ,'y' ,'y' ,'y' ,'y' ,'y' ,'y' }; memset(str, 'x', 5); for (int i = 0; i < 10; i++) { printf("%c ", str[i]); } return 0; }
模拟实现：
#define _CRT_SECURE_NO_WARNINGS #include#include void* my_memset(void* str, int c, int num) { void* ret = str; while (num--) { *(char*)str = c; str = (char*)str + 1; } return ret; } int main() { char str[10] = { 'y' ,'y' ,'y' ,'y' ,'y' ,'y' ,'y' ,'y' ,'y' ,'y' }; my_memset(str, 'x', 5); for (int i = 0; i < 10; i++) { printf("%c ", str[i]); } return 0; }
