1. 函数介绍
1.1 strlen(计算字符串长度)
size_t strlen ( const char * str );
int main()
{
char ch[] = "abcde";
int len = strlen(ch);
printf("%d\n", len);
return 0;
}
字符串已经 '\0' 作为结束标志,strlen函数返回的是在字符串中 '\0' 前面出现的字符个数(不包含 '\0' )。
参数指向的字符串必须要以 '\0' 结束。
注意函数的返回值为size_t,是无符号的。
strlen函数的模拟实现
int my_strlen(const char *arr)
{
int len = 0;
while (*arr != '\0')
{
arr++;
len++;
}
return len;
}
int main()
{
char arr[] = "abcdef";
int ret = my_strlen(arr);
printf("%d\n", ret);
return 0;
}
1.2 strcpy
char* strcpy(char * destination, const char * source );
int main()
{
char arr1[20] = { 0 };
char arr2[] = "abcdef";
strcpy(arr1, arr2);//把arr2的内容覆盖到arr1上
printf("%s", arr1);
}
源字符串必须以 '\0' 结束。
会将源字符串中的 '\0' 拷贝到目标空间。
目标空间必须足够大,以确保能存放源字符串。 目标空间必须可变。
模拟实现。
#include<assert.h>
char* my_strcpy(char* str1, const char* str2)
{
assert(str1 && str2);//断言判断两个指针不能为空,是空就报错了
char *ret=str1;
while (*str1++ = *str2++)
{
;
}
return str1;
}
int main()
{
char arr1[20] = { 0 };
char arr2[] = "abcde";
my_strcpy(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
//strcpy函数返回的是目标空间的起始地址
1.3 strcat(字符串追加)
int main()
{
char arr1[20] = "hello";
char arr2[] = "world";
strcat(arr1, arr2);
printf("%s", arr1);
return 0;
}
char * strcat ( char * destination, const char * source );
源字符串必须以 '\0' 结束。
目标空间必须有足够的大,能容纳下源字符串的内容。
目标空间必须可修改。
strcat在使用的时候原字符串必须要有\0,目标字符串也要有\0,从目标字符串的\0处开始追加
自己实现
char* my_strcat(char* str1, char* str2)
{
char* ret = str1;
assert(str1 && str2);
while (*str1 != '\0')
{
str1++;
}
while (*str1++ = *str2++)
{
;
}
return ret;
//先把str1调试到arr1的\0处,之后再跟之前的拷贝一样,将arr2拷贝到arr1上
}
int main()
{
char arr1[20] = "hello";
char arr2[] = "bit";
my_strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
我们自己设计的这个是无法自己给自己追加的,但是库函数可以。
1.4 strcmp
int strcmp ( const char * str1, const char * str2 );
This function starts comparing the first character of each string. If they are equal to each other, it continues with the following pairs until the characters differ or until a terminating null-character is reached.
标准规定:
第一个字符串大于第二个字符串,则返回大于0的数字
第一个字符串等于第二个字符串,则返回0
第一个字符串小于第二个字符串,则返回小于0的数字
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abcq";
int ret=strcmp(arr1, arr2);
//strcmp比较的不是字符串的长度,而且比较字符串中对应位置的字符的大小,如果相同就比较下一对,直到不同或者都遇到\0;
//比较的是不同位置上的ASCII码值
printf("%d\n", ret);
return 0;
}
之后自己可以实现整个函数
#include<assert.h>
int my_strcmp(const char *arr1,const char *arr2)
{
assert(arr1 && arr2);
while (*arr1 == *arr2)
{
if (*arr1 == '\0')
{
return 0;
}
arr1++;
arr2++;
}
if(*arr1 > *arr2)
{
return 1;
}
else
{
return -1;
}
}
int main()
{
char arr1[] = "abce";
char arr2[] = "abcf";
int ret=my_strcmp(arr1, arr2);
printf("%d\n", ret);
return 0;
}
strcpy
strcat
strcmp
//长度不受限制的字符串函数
strncpy
strncat
strncmp
//长度受限制的字符串函数
1.5 strncpy
char * strncpy ( char * destination, const char * source, size_t num );
Copies the first num characters of source to destination. If the end of the source C string (which is signaled by a null-character) is found before num characters have been copied, destination is padded with zeros until a total of num characters have been written to it.
拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num,则拷贝完源字符串之后,在目标的后边追加0,直到num个。
int main()
{
char arr1[] = "abce";
char arr2[] = "bcdeff";
strncpy(arr1, arr2, 4);
printf("%s\n", arr1);
return 0;
}
比起strcpy多了一个参数,参数是看将arr2中的几个字符拷贝进去,有了限制。因为arr1的空间不一定够用。这样的灵活性也高了。
1.6 strncat
char * strncat ( char * destination, const char * source, size_t num );
Appends the first num characters of source to destination, plus a terminating null-character. If the length of the C string in source is less than num, only the content up to the terminating null-character is copied.
int main()
{
char arr1[10] = "abce";
char arr2[] = "bcdeff";
strncat(arr1, arr2, 4);//把arr2中的4个字符追加到arr1中
printf("%s\n", arr1);
return 0;
}
追加不仅从arr1的\0处开始覆盖追加,arr2后还补一个\0不算在内个字符串追加个数中去。
1.7 strncmp
int strncmp ( const char * str1, const char * str2, size_t num );
比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
int main()
{
char arr1[10] = "abce";
char arr2[] = "bcdeff";
int ret=strncmp(arr1, arr2, 4);//前4个跟前4个想比较
printf("%d\n", ret);
return 0;
}
如果硬要比较两个字符串数组,其实比较的是两个字符串数组的地址。数组名表示首元素地址。
1.8 strstr
char * strstr ( const char *str1, const char * str2);
Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1.
在一个字符串中找另外一个字符串,看这个字符串是不是另外一个的子串(str2有没有在str1中)
如果在,会返回str2在str1中第一次出现的位置。如果没有出现会返回一个空指针。
int main()
{
char arr1[] = "abcedfcedf";
char arr2[] = "cedf";
char *ret=strstr(arr1, arr2);
if (ret == NULL)
{
printf("找不到\n");
}
else
{
printf("%s", ret);
}
return 0;
}
模拟实现strstr
char* my_strstr(const char* arr1,const char* arr2)
{
assert(arr1 && arr2);
char* s1 = arr1;
char* s2 = arr2;
char* cur = arr1;
while (*cur)
{
s1 = cur;
s2 = arr2;
while (*s1 && *s2 &&(*s1 == *s2))
{
s1++;
s2++;
}
if (*s2 == '\0')
{
return cur;
}
cur++;
}
return NULL;
}
int main()
{
char arr1[] = "abcedfcedf";
char arr2[] = "bce";
char* ret = my_strstr(arr1, arr2);
if (ret == NULL)
{
printf("找不到\n");
}
else
{
printf("%s\n", ret);
}
return 0;
}
1.9 strtok(将字符串按符号分割开)
char * strtok ( char * str, const char * sep );
sep参数是个字符串,定义了用作分隔符的字符集合
第一个参数指定一个字符串,它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标 记。
strtok函数找到str中的下一个标记,并将其用 \0 结尾,返回一个指向这个标记的指针。(注: strtok函数会改变被操作的字符串,所以在使用strtok函数切分的字符串一般都是临时拷贝的内容 并且可修改。)
strtok函数的第一个参数不为 NULL ,函数将找到str中第一个标记,strtok函数将保存它在字符串 中的位置。
strtok函数的第一个参数为 NULL ,函数将在同一个字符串中被保存的位置开始,查找下一个标 记。
如果字符串中不存在更多的标记,则返回 NULL 指针。
int main()
{
char arr1[] = "**********@qq.com";
char arr2[20] = { 0 };
strcpy(arr2, arr1);
const char* sep = "@.";
//strtok(buf, sep);//只找第一个标记
//strtok(NULL, sep);//是从保存好的位置继续找
//strtok(NULL, sep);//是从保存好的位置开始继续往后找
char* str = NULL;
for (str = strtok(arr2, sep); str != NULL;str=strtok(NULL,sep))
{
printf("%s\n",str);
}
return 0;
}
1.10 strerror
char * strerror ( int errnum );
返回错误码,所对应的错误信息。
在我们库函数调用的时候调用失败了会返回一个全局变量:errno(错误码)就比如访问网址的时候出现404,这也是一个错误码,但是我们并不知道这是什么意思。
把错误码转换为错误信息。
perror更简单一些,只需要传入一个字符串即可。随意输入字符串就行。它会追加:和错误信息。两个各有各自的好处,第一个是需要返回错误信息的时候用,它不主动打印。第二个如果要打印错误信息就一定会打印的。
字符分类函数:
iscntrl 任何控制字符
isspace 空白字符:空格‘ ’,换页‘\f’,换行'\n',回车‘\r’,制表符'\t'或者垂直制表符'\v'
isdigit 十进制数字 0~9
isxdigit 十六进制数字,包括所有十进制数字,小写字母a~f,大写字母A~F
islower 小写字母a~z
isupper 大写字母A~Z
isalpha 字母a~z或A~Z
isalnum 字母或者数字,a~z, A~Z, 0~9
ispunct 标点符号,任何不属于数字或者字母的图形字符(可打印)
isgraph 任何图形字符
isprint 任何可打印字符,包括图形字符和空白字符
使用的时候引函数的头文件<ctype.h>
例如判断一个数是不是十进制 isdigit(int c)int c指的是这个字符的ASCII码值
如果是就返回非0,如果不是就返回0;
字符转换:
int tolower ( int c );
int toupper ( int c );
字符串操作函数
strlen
strcpy
strcat
strcmp
strncpy
strncat
strstr
strtok
内存操作函数
memcpy
memmove
memcmp
memset
1.11 memcpy
void * memcpy ( void * destination, const void * source, size_t num );//num的单位是字节
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[5] = { 0 };
memcpy(arr2, arr1, 20);
return 0;
}
memcpy自己实现
void* my_memcpy(void* str1, const void* str2, size_t num)
{
assert(str1 && str2);
void* ret = str1;
while (num--)
{
*(char*)str1 = *(char*)str2;
str1 = (char*)str1 + 1;
str2 = (char*)str2 + 1;
}
return ret;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[5] = { 0 };
my_memcpy(arr2, arr1, 20);
return 0;
}
如果想把12345从3开始覆盖,memcpy无法实现
这时就要用到我们的memmove
1.12 memmove
void * memmove ( void*destination, const void * source, size_t num );
和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠,就得使用memmove函数处理。
自己设计memmove
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--)
{
*((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+2, arr1, 20);
int sz = sizeof(arr1) / sizeof(arr1[0]);
for (int i = 0; i < sz; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
1.13 memcmp
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,2,3,4,0x11223305 };
int ret=memcmp(arr1, arr2, 16);//是一个字节一个字节进行比较 ,这里17个字节也是返回0
printf("%d\n", ret);
return 0;
}
memset---内存设置(设置内存中的一个值)
int main()
{
int arr[] = { 1,2,3,4,5 };
memset(arr, 0, 20);//把arr(首元素地址)全设置成0,设置长度为20个字节
//以字节为单位初始化内存单元
return 0;
}