文章目录
1.1 strlen 字符串长度
size_t strlen(const char* str);
有的编译器用int接受strlen的返回值会报错,因为size_t是无符号整形。
size_t sz=strlen(arr);
printf("%u",arr);
- str指向的字符串必须包含’\0’,否则无法计算字符串长度。
- -strlen函数返回无符号整形的问题:
int main()
{
if(strlen("abc")-strlen("abcedf")>0)
{
printf("hehe\n");
}
else
{
printf("haha\n");
}
//由于strlen函数返回的是无符号整形,所以3-6=-3但是会被理解成一个无符号整形数,所以还是大于0。
return 0;
}
strlen的三种模拟实现
1. 递归(不需要临时变量求字符串长度)
size_t mystrlen(const char* arr)
{
assert(arr);
if (*arr == '\0')
{
return 0;
}
else
{
arr++;
return 1 + mystrlen(arr);
}
}
2.地址相减
size_t mystrlen(const char* arr)
{
assert(arr);
char* p = arr;
while (*arr != '\0')
{
arr++;
}
return arr - p;
}
3.计数器
size_t mystrlen(const char* arr)
{
assert(arr);
int count = 0;
while (*arr != '\0')
{
count++;
arr++;
}
return count;
}
1.2 strcpy 字符串拷贝
char* strcpy(char * destination, const char * source );
-
把source指向的字符串拷贝到destination所指向的空间,并且返回指向这个空间首元素地址。
-
源字符串必须以 ‘\0’ 结束。 会将源字符串中的 ‘\0’ 拷贝到目标空间。
-
目标空间必须足够大,以确保能存放源字符串。
-
目标空间必须可变。const char* p=“xxxxxxx”;
-
这个函数不安全,不管是否越界访问内存就硬拷。
-
strcpy实现
char* mystrcpy(char* des, const char* source)
{
assert(des && source);
char* p = des;
while (*des++ = *source++;)
//当*source='\0'的时候 表达式值为\0,
//而\0的ASCII码值是0会停下while循环。
{
;
}
return p;
}
1.3 strcat 字符串链接
char * strcat ( char * destination, const char * source );
- 源字符串必须以 ‘\0’ 结束。
- 目标空间必须有足够的大,能容纳下源字符串的内容。
- 目标空间必须可修改。
strcat模拟实现
char* mystrcat(char* dest,const char* src)
{
assert(dest && src);
char* ret = dest;
while (*dest)
{
dest++;
}
while (*dest++ = *src++);
return ret;
}
1.4 strcmp 字符串比较
比较的大小是字符串的内容(对应字符的ASCII码值大小),而不是字符串的长度。
int strcmp ( const char * str1, const char * str2 );
标准规定:
- 第一个字符串大于第二个字符串,则返回大于0的数字
- 第一个字符串等于第二个字符串,则返回0
- 第一个字符串小于第二个字符串,则返回小于0的数字
int mystrcmp(const char* s1, const char* s2)
{
assert(s1 && s2);
while (*s1 == *s2)
{
if (*s1 == '\0')
{
return 0;//说明到尾了且这俩相等。
}
s1++;
s2++;
}
return *s1 - *s2;
}
以上3个函数都是长度不受限制的字符串函数,可能会出现越界访问内存,不够安全。
因此有strncpy strncat strncmp这三种长度受限制的字符串函数,相对安全。
1.5 strncpy
char * strncpy ( char * destination, const char * source, size_t num );
//num拷贝字符的个数。
-
拷贝num个字符从源字符串到目标空间。
-
如果源字符串的长度小于num,则拷贝完源字符串之后,在目标的后边追加0,直到num个。
strncpy模拟实现
char* mystrncpy(char* des, const char* src, size_t num)
{
assert(des && src);
int sz = strlen(src);
char* p = des;
if (num <= sz)
{
for (int i = 0; i < num; i++)
{
des[i] = src[i];
}
return p;
}
else
{
for (int i = 0; i < sz; i++)
{
des[i] = src[i];
}
for (int j = sz; j < num; j++)
{
des[j] = '\0';
}
return p;
}
}
1.6 strncat
char * strncat ( char * destination, const char * source, size_t num );
//num 追加的字符数。
- 追加的时候是先找到第一个\0然后替换上第一个字符,依次追加后续字符,最后补一个\0,所以住过要追加num个字符后面至少还得有num+1个位置。
- 如果追加字符串长度小于num,那么它只会追加追加字符串长度个字符。
strncat模拟实现
char* mystrncat(char* des, const char* src, size_t num)
{
assert(des && src);
int len = strlen(src);
char* p = des;
while (*des != '\0')
{
des++;
}
if (num <= len)
{
int i = 0;
for (i = 0; i < num; i++)
{
des[i] = src[i];
}
des[num] = '\0';
}
else
{
while (*des++ = *src++);
}
return p;
}
1.7 strncmp
int strncmp ( const char * str1, const char * str2, size_t num );
//num比较的字符串个数
比较两个字符串的前num个字符。
strncmp模拟实现
int mystrncmp(const char* s1, const char* s2, size_t num)
{
assert(s1 && s2);
int count = 0;
while (count < num && *s1 == *s2)
{
if (*s1 =='\0')
{
return 0;
}
s1++;
s2++;
count++;
}
return *s1 - *s2;
}
1.8 strstr 字符串查找函数
char * strstr ( const char *str2, const char * str1);
返回一个指针指向str2在str1第一次出现的首字母地址,若没有出现则返回NULL。
strstr模拟实现
char* mystrstr(const char* str1, const char* str2)
{
//思路 用str1保存串1首元素地址 用str2保存串2的首元素地址
//cp表示从str1串的哪个位置开始比较
//s1是串1用来比较时的指针
//s2是串2用来比较时的指针
char* cp = str1;
char* s1 = str1;
char* s2 = str2;
if (*s2 == '\0')//如果是空字符,直接返回就好了。
{
return str1;
}
while (*cp != '\0')//还没走到尾比较还没结束
{
s1 = cp;
s2 = str2;
//while (*s1!='\0' && *s2!='\0' && *s1 == *s2)
while (*s1 && *s2 && *s1 == *s2)
//比较有三种可能跳出循环,
//如果s1s2前面一直相等,s2走到尾巴了==\0,这说明匹配成功,跳出;
//如果s1和s2前面一直相等,但是s1走到尾巴了s2还没走到尾巴,也不能够再匹配了跳出;
//如果不相等了,也跳出
//我们要控制他们不要比到\0的情况,要不然可能会越界访问。
{
s1++;
s2++;
}
if (*s2 == '\0')
//只有这种是匹配成功的情况
{
return cp;
}
cp++;
}
return NULL;//如果一次返回都没有走到这里了,说明寻找失败了
}
//以上为BF算法,库里也是这么实现的
在字符串查找中,有一个算法叫KMP算法。
1.9 strtok 字符串分割函数
char * strtok ( char * str, const char * sep );
- sep参数是一个字符串,它是分割符的集合,比如2587966900@qq.com,想割出2587966900和qq和com,seq这个参数就得等于"@.".
- 关于第一个参数str,其用法是
- 第一次传非空指针str,当第一个参数不是NULL时,会找到字符串str中的第一个标记,并且会将这个标记符改为\0,然后strtok函数会记住这个位置(这个记忆的特性说明strtok函数内部使用了静态变量或者全局变量),并且返回一个指向首元素的指针。
- 后续调用都传空指针,当第一个参数是NULL时,strtok函数将从第一个被保存的位置开始往后找标记符,找到后更新保存位置,返回一个指向被保存的位置的后一个位置的指针。
- 当字符串中不存在更多的标记时,strtok函数会返回NULL;
基于strtok函数的特性,我们可以这样设计程序:
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = "2587966900@qq.com";
char arr1[100] = { 0 };
strcpy(arr1, arr);
char* cunfang[3] = { 0 };
char* ret = NULL;
char seq[] = "@.";
int i = 0;
for (ret = strtok(arr1, seq); ret != NULL; ret = strtok(NULL, seq))
{
cunfang[i] = ret;
i++;
}
for (int j = 0; j < 3; j++)
{
printf("%s\n", cunfang[j]);
}
return 0;
}
1.10 strerror 错误信息报告函数
char * strerror ( int errnum );
必须包含的头文件<string.h> <errno.h>
返回错误码所对应的错误信息。
C语言库函数调用失败的时候,会把错误码存储到errno变量中。
还有个更直接的库函数perror,等价于打印错误码对应的错误信息。
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
FILE* pf = fopen("text.txt", "r");
if (pf == NULL)
{
printf("%s", strerror(errno));
perror("测试");
//就会输出测试: 错误信息。
return -1;
}
else
{
printf("打开成功");
}
fclose(pf);
pf = NULL;
return 0;
}
1.11 memcpy 不重复情况下的内存拷贝
void * memcpy ( void * destination, const void * source, size_t num );
//num 拷贝的字节数
//可以直接以内存的方式拷贝,不止拷贝字符串,整型,结构体,数组等等都可以。
- 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
- 如果source和destination有任何的重叠,复制的结果都是未定义的。
- 如果有重叠的拷贝,考虑memmove函数。
//模拟实现
//思路1 for循环
void* mymemcpy(void* des,const void* src, size_t num)
{
assert(des && src);
char* p1 = (char*)des;
char* p2 = (char*)src;
for (int i = 0; i < num; i++)
{
p1[i] = p2[i];
}
return des;
}
//思路2 while循环
void* mymemcpy(void* des, const void* src, size_t num)
{
assert(des && src);
void* p = des;
while (num--)
{
*(char*)des = *(char*)src;
des = (char*)des + 1;
src = (char*)src + 1;
}
return p;
}
虽然vs环境下memcpy也能实现内存重叠情况下的拷贝,但是C语言标准中对memcpy函数的要求仅仅是完成内存不重叠情况下的拷贝,你不要知网memcpy能完成内存重叠情况下的拷贝。
1.12 memmove 可以处理重复情况下的内存拷贝
void * memmove ( void * destination, const void * source, size_t num );
作用:可以实现内存重复情况下的内存拷贝
//实现思路1:利用动态内存分配
void* mymemmove(void* des, const void* src, size_t num)
{
assert(des && src);
char* p1 = (char*)des;
char* p2 = (char*)src;
char* p = (char*)malloc(num);
for (int i = 0; i < num; i++)
{
p[i] = p2[i];
}
for (int i = 0; i < num; i++)
{
p1[i] = p[i];
}
free(p);
p = NULL;
return des;
}
//不用动态内存分配的实现思路:发现如果des在src的前面,那么就从前往后拷贝不会出现问题;如果des在src的后面,那么从后向前拷贝就可以了
void* my_memmove(void* des, const void* src, size_t count)
{
void* p = des;
if (des < src)
{
while (count--)
{
*(char*)des = *(char*)src;
des = (char*)des + 1;
src = (char*)src + 1;
}
}
else
{
while (count--)
{
*((char*)des + count) = *((char*)src + count);
//count进来就已经减1了,des强转为char*后加count正好是最后一个元素地址,同理src。
}
}
return p;
}
1.13 memcmp 内存比较
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
- 比较两块内存的前num个字节,如果都相等返回0;
- 否则对比第一个不相等的两个字节,
- 如果ptr1的小,则返回一个小于0的数,
- 如果ptr2的小,则返回一个大于0的数。
memcpy模拟实现
int mymemcmp(const void* s1, const void* s2, size_t num)
{
char* p1 = (char*)s1;
char* p2 = (char*)s2;
int i = 0;
while (*p1 == *p2 && i<num)
{
p1++;
p2++;
i++;
}
if (i == num)
{
return 0;
}
else
{
return *p1 - *p2;
}
}
1.14 memset 内存设置
void *memset( void *dest, int c, size_t count );
把目标空间的count的字节都设置成一个数a,这个数a是一个0~255范围内的unsigned char,是对int c进行截断得到的,返回目标空间起始地址。
一般用在初始化一些结构体之类的。
memset模拟实现
void* mymemset(void* dest, int c, size_t num)
{
char* p = (char*)dest;
size_t b = (size_t)c;
for (int i = 0; i < num; i++)
{
p[i] = b;
}
return dest;
}
1.15 递归实现reverse字符串逆序函数
#include <stdio.h>
int my_strlen(char* str)
{
if (*str == '\0')
{
return 0;
}
return 1 + my_strlen(str + 1);
}
void reverse_string(char* str)
{
int len = my_strlen(str);
//这个递归可以这样完成
//先把头字符串拿出来放到temp里头
//然后把尾字符串放到头上
//然后把尾字符串改成\0这样 这样在str前进一步以后的视角下 str字符串是中间的串
//逆序str+1
//头字符放回尾字符中
//什么条件终止递归呢 当这个串的长度小于2的时候 就不必逆序了
char temp = str[0];
str[0] = str[len - 1];
str[len - 1] = '\0';
if (my_strlen(str+1) >= 2)
{
reverse_string(str + 1);
}
str[len - 1] = temp;
}
int main()
{
char str[] = "hello bit";
reverse_string(str);
printf("%s", str);
return 0;
}