字符函数和字符串函数
求字符串长度的函数
strlen
函数基本写法
size_t strlen(const char* str);
用法
读取字符串的长度
注意事项
1.strlen函数遇到’\0’时停止计数，以’\0’为结束标志，返回的是字符串’\0’前面出现的字符个数（不包含’\0’）
2.参数指向的字符串必须要含有’\0’，不然函数返回的为随机值
3.返回的值为size_t，是无符号数
模拟实现
#include<stdio.h>
#include<assert.h>//assert的头文件
size_t my_strlen(const char* str)
{
assert(str);//断言一下，判断指针是否为空指针
size_t count = 0;//计数器
while(*str++)//当str为非0时，计数器加一，str加一指向下一位置
{
count++;
}
return count;
}
int main( )
{
char arr[] = "skjlf";
printf("%d",my_strlen(arr));
return 0;
}
上述输出
长度不受限制的字符串函数
strcpy
函数基本写法
char* strcpy(char* destination,const char* source);
用法
将source指向的字符串拷贝到destination指向的字符串中，返回指向destination的字符指针
注意事项
1.目标空间（destination）必须足够大
2.源字符串必须以’\0’结束，拷贝到遇到源字符串的’\0’为止，并将源字符串的’\0’一并拷贝过去
3.目标空间必须可以改变
模拟实现
#include<stdio.h>
#include<assert.h>//assert的头文件
char* my_strcpy(char* dest,const char* sor)
{
assert(dest && sor);
char* ret = dest;
while(*dest++ = *sor++)//先将sor解引用的值赋给dest，再进行判断，如果非0则进行循环，同时dest和sor加一
{
;
}
return ret;
}
int main( )
{
char str[20] = "*********";
char arr[] = "abcd";
printf("%s",my_strcpy(str,arr));
return 0;
}
strcat
函数基本写法
char* strcat(char* destination,const char* source);
用法
将source指向的字符串接入到destination指向的字符串的’\0’之后，最后返回指向destination的指针
注意事项
1.源字符串和目标字符串都必须含有’\0’，源字符串的接入从目标字符串的’\0’开始，最后会将源字符串的’\0’放入目标空间之中
2.目标空间必须足够大
3.目标空间必须可改
4.字符串不可自己给自己追加
模拟实现
#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dist,const char* sor)
{
assert(dist && sor);
char* ret = dist;
while(*dist)//找到dist的'\0'
{
dist++;
}
while(*dist++ = *sor++)//将sor赋值给dist，直到sor为'\0'
{
;
}
return ret;
}
int main( )
{
char arr[20] = "hello ";
char str[] = "world";
printf("%s",my_strcat(arr,str));
return 0;
}
输出
strcmp
函数基本实现
int strcmp(const char* str1,const char* str2);
用法
1.比较两参数指向的字符串，如果str1 > str2，则返回 >0 的数；如果str1 = str2,则返回0；如果str1 < str2，则返回 <0 的数
2.比较的是字符串中对应位置的字符ASCII码值
模拟实现
#include<stdio.h>
#include<assert.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[] = "sjfslf";
char str2[] = "lslhfj";
int ret = my_strcmp(str1,str2);
if(ret > 0) printf("str1");
else if(ret == 0) printf("same");
else printf("str2");
return 0;
}
长度受限制的字符串函数
strncpy
函数基本实现
char* strncpy(char* distnation,const char* source,size_t num);
用法
与 strcpy函数基本相似，最后的num代表拷贝的字符数，将源代码的num个字符拷贝到目标空间
注意事项
1.如果源字符串的长度小于num，则在拷贝完源字符串后在目标空间补’\0’,直至拷贝的字符数量为num
具体应用
#include<stdio.h>
#include<string.h>
int main( )
{
char arr[20] = "##########";
char str[] = "abc";
printf("%s\n",strncpy(arr,str,3));
printf("%s\n",strncpy(arr,str,4));
printf("%s\n",strncpy(arr,str,5));
return 0;
}
三次arr数组的具体存放数据
strncat
函数基本实现
char* strncat(char* distnation,const char* source,size_t num)
用法
基本用法与strcat相似，最后的num代表追加的源字符串的字符个数
注意事项
1.追加时会在追加完num个字符后加入’\0’
代码实现
#include<stdio.h>
#include<string.h>
int main( )
{
char arr[20] = "hello \0###";
char str[] = "abccd";
printf("%s\n",strncat(arr,str,3));
return 0;
}
strncmp
基本函数实现
int strncmp(const char* str1,const char* str2,size_t num);
用法
基本用法与strcmp相似，num为比较的字符个数
字符串查找
strstr
基本函数实现
char* strstr(const char* distination ,const char* source);
用法
在目标字符串中查找源字符串第一次出现的位置
模拟实现
#include<stdio.h>
#include<assert.h>
char* my_strstr(char* dist,char* sor)
{
assert(dist && sor);
char* cp = dist;
if(! *sor)
{
return (char*)dist;
}
while(*cp)
{
char* p1 = cp;
char* p2 = sor;
while(*p1 == *p2 && (*p1) && (*p2))
{
p1++;
p2++;
}
if(*p2 == '\0')
{
return cp;
}
cp++;
}
return NULL;
}
int main( )
{
char arr1[] = "cahbdfke";
char arr2[] = "bdf";
printf("%s",my_strstr(arr1,arr2));
return 0;
}
strtok
基本函数实现
char* strtok(char* str,const char* sep);
用法
1.sep参数为一个字符串，定义了用作分隔符的字符集合
2.第一个参数是指定一个字符串，包含0个或多个由sep字符串中一个或多个分隔符分割的标记
3.strtok函数找到str的下一个标记，并将其用’\0’结尾，返回一个指向这个标记的指针
4.strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
5.strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
6.如果字符串中不存在更多的标记，则返回 NULL 指针。
代码举例
#include<stdio.h>
#include<string.h>
int main( )
{
char arr[] = "lsjfkls@sjfhk.shfk";
char arr2[30] = {0};
strcpy(arr2,arr);//将str拷贝到str2中，因为strtok函数会改变原字符串，因此要拷贝一份
char* p = ".@";
char* ret = NULL;
for(ret = strtok(arr2,p);ret != NULL;ret = strtok(NULL,p))
//最开始时第一个参数不为NULL，则从字符串开头开始寻找下一个标记
//第二个参数为NULL，将从上一个保存的标记位置开始寻找下一个标记
{
printf("%s\n",ret);
}
return 0;
}
错误信息报告
strerror
基本函数实现
char* strerror(int errnum);
用法
返回错误码对应的错误信息
代码示例
#include<stdio.h>
#include<string.h>
int main( )
{
printf("%s\n",strerror(0));
printf("%s\n",strerror(1));
printf("%s\n",strerror(2));
printf("%s\n",strerror(3));
return 0;
}
内存操作函数
memcpy
基本函数实现
void* mencpy(void* destination,const void* source,size_t num);
用法
1.从source位置开始复制num个字节到destination的内存位置
2.遇到’\0’不会停下
3.如果source和destination有任何重叠，复制的结果未知
4.memcpy函数在实现的时候，不知道未来会被用来拷贝什么类型
模拟实现
#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dist,const void* sor,size_t num)
{
assert(dist && sor);
void* ret = dist;
while(num--)
{
*(char*)dist = *(char*)sor;
dist = (char*)dist+1;
sor = (char*)sor+1;
}
return ret;
}
int mian( )
{
int arr[] = {1,2,3,4,5,6,7,8,9,10};
int arr2[20] = {0};
my_memcpy(arr2,arr,16);
for(int i = 0;i < 20;i++)
{
printf("%d ",arr2[i]);
}
return 0;
}
memmove
基本函数实现
void* memmove(void* destination,const void* source,size_t num);
用法
1.memmove和memcpy的区别就是memmove处理的源代码块与目标代码块可以重叠
模拟实现
#include<stdio.h>
#include<assert.h>
void* my_memmove(void* dest,const void* sor,size_t num)
{
assert(dest && sor);
void* ret = dest;
if(dest < sor)//如果dest指向的位置小于sor指向的位置，则从前向后拷贝
{
while(num--)
{
*(char*)dest = *(char*)sor;
dest = (char*)dest + 1;
sor = (char*)sor + 1;
}
}
else{//不然从后向前拷贝
while(num--)
{
*((char*)dest+num) = *((char*)sor+num);
}
}
return ret;
}
int main( )
{
int arr[] = {1,2,3,4,5,6,7,8,9,10};
my_memmove(&arr[0],&arr[6],16);
for(int i = 0;i < 10;i++)
{
printf("%d ",arr[i]);
}
return 0;
}
memcmp
基本函数实现
int memcmp(const void* str1,const void* str2,size_t num);
用法
比较从str1和str2开始的num个字节
返回值和strcmp函数同
memset
基本函数实现
void* memset(void* dest,int c,size_t num);
用法
将dest参数指向开始将num个字节改为c
扫一扫
4032
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
