C语言字符、内存函数功能及实现
strlen函数
函数原型：size_t strlen ( const char * str );
功能：求字符串长度，只使用于：字符串，字符数组，求长度的时候，只关注’\0’.
注意事项：
1.属于<string.h>中.
2.返回类型是无符号整形（size_t)，特别要注意下面代码的情况.
#include<stdio.h>
#include<string.h>
int main()
{
if (strlen("abc") - strlen("abcdef"))
{
printf(">");
}
else
{
printf("<");
}
return 0;
}
大部分人正常思路肯定认为是输出小于(<),但不要忘记了它的返回值是个无符号整形，不管怎么加减都不会变为负数，所以其输出结果为大于(>)。
3.结束标志位’\0’.
模拟实现
方法一：计数器法
通过创建临时变量来计数
//计数器方式
int my_strlen(const char * str)
{
int count = 0;
while(*str)
{
count++;
str++;
}
return count;
}
方法二：递归法
//不能创建临时变量计数器
int my_strlen(const char * str)
{
if(*str == '\0')
{
return 0;
}
else
{
return 1+my_strlen(str+1);
}
}
方法三：指针减指针法
//指针-指针的方式
int my_strlen(char *s)
{
char *p = s;
while(*p != ‘\0’ )
{
p++;
}
return p-s;
}
strcpy函数
函数原型：char* strcpy(char * destination, const char * source )；
功能：含有’\0’结束符的字符串复制到另一个地址空间
注意事项：
1.属于<string.h>中.
2.必须保证目标空间（dest）足够容纳你要拷贝的字符大小，并且会把源字符串中的 ‘\0’ 拷贝到目标空间。
3.源字符串（src）必须以 ‘\0’ 结束
4.返回类型是char *
模拟实现
//str1---是目标空间（dest） str2----是源空间（src）
char* my_strcpy(char *str1,const char*str2)
{
assert(str1!=NULL&&str2 != NULL);
char* str = str1;
while (*str1++ = *str2++)
{
;
}
return str;
}
strcat函数
函数原型：char * strcat ( char * destination, const char * source );
功能：将源字符串的副本附加到目标字符串。目标中的终止空字符被源的第一个字符覆盖，并且在源的末尾包含一个空字符，由目标中的两个字符串串联而成的新字符串。
注意事项：
1.目标空间必须要能容纳下源字符串加上自身
2.不可以自己连接自己，会没有中止条件’\0’
3.目标空间（dest)、源空间（source）必须都要有’\0’
4.返回值char*
模拟实现
//str1---是目标空间（dest） str2----是源空间（src）
char* my_strcat(char *str1,const char *str2)
{
//防止str1与str2是空指针,如果是会报错
assert(str1 != NULL && str2 != NULL);
char* str = str1;
while (*str1 != '\0')
{
str1++;
}
while (*str1++ = *str2++)
{
;
}
return str;
}
strcmp函数
函数原型：int strcmp (const char * str1, const char * str2 );
功能：比较字符串s1和s2的大小
注意事项：
1.返回值:
当s1<s2时，返回为负数；
当s1=s2时，返回值= 0；
当s1>s2时，返回正数;
2.字符串比较的是俩个对应位字符串的ASCII码值
模拟实现
//str1---是目标空间（dest） str2----是源空间（src）
int my_strcmp(const char* str1,const char*str2)
{
assert(str1!=NULL&&str2 != NULL);
while (*str1==*str2)
{
if (*str1 == '\0')
{
return 0;
}
str1++;
str2++;
}
if (*str1 > * str2)
{
return 1;
}
return -1;
}
strncpy函数
函数原型：char * strncpy ( char * destination, const char * source, size_t num );
功能：拷贝num个字符从源字符串到目标空间。如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
注意事项：
1.目标空间必须足够大
2.返回类型是char *
模拟实现
char*my_strncpy(char *str1,const char *str2,size_t count)
{
//str1---是目标空间（dest） str2----是源空间（src）
assert(str1 != NULL && str2 != NULL);
char* str = str1;
while (count && (*str1++=*str2++)!='\0')
{
count--;
}
if (count)
{
while (count--)
{
*str1++ = '\0';
}
}
return str;
}
strncat函数
函数原型：char * strncat ( char * destination, const char * source, size_t num );
功能：将源的前num个字符附加到目标，再加上一个终止的空字符。如果source中的C字符串长度小于num，则只复制到终止空字符之前的内容
模拟实现：
char*my_strncat(char* str1, const char* str2, size_t count)
{
//str1---是目标空间（dest） str2----是源空间（src）
assert(str1!=NULL && str2!=NULL);
char* str = str1;
while (*str1 != '\0')
{
str1++;
}
while (count--)
{
if ((*str1++ = *str2++) == 0)
{
return str;
}
}
*str1 = '\0';
return str;
}
strstr函数
函数原型：char * strstr ( const char *, const char * );
功能：字符串中找子字符串
注意事项：
1.返回指向str1中第一个出现的str2的指针，如果str2不是str1的一部分，则返回空指针。
模拟实现
方法一：BF法
char* my_strstr(const char* str1, const char* str2)
{
assert(str1 != NULL && str2 != NULL);
if (str2 == '\0')
{
return (char*)str1;
}
const char* cp = str1;
while (*cp)
{
const char* p1 = cp;
const char* p2 = str2;
while ((*p1 == *p2) && (*p1 !='\0') && (*p2 !='\0'))
{
p1++;
p2++;
}
if (*p2 == '\0')
{
return (char*)cp;
}
cp++;
}
return NULL;
}
方法二：KMP法
请看我的另外一篇博客。
strtok函数
功能：分解字符串为一组字符串
函数原型：char * strtok ( char * str, const char * sep );
sep参数是个字符串，定义了用作分隔符的字符集合
运用
int main()
{
char arr[]="123456@email.com";
char arr2[100]={0};//因为strtok函数会修改源数组，通常复制后处理
char sep[]="@.";//这里面的字符顺序不会影响结果
strcpy(arr2,arr);
printf("%s\n",strtok(arr2,sep));
printf("%s\n",strtok(NULL,sep));
printf("%s\n",strtok(NULL,sep));
return 0;
}
结果如下图所示：
strerror函数
函数原型：char * strerror (int errnum);
功能：返回错误码，所对应的错误信息。
运用
int main()
{
//printf("hehe\n");
//判断文件是否打开成功
FILE* pf = fopen("test.txt", "r");//file open
if (pf == NULL)
{
printf("fopen: %s\n", strerror(errno));
perror("fopen");
}
return 0;
}
iscntrl函数
功能：检查所传的字符是否是控制字符。
头文件：#include<ctype.h>
运用
void test()
{
char arr[20] = "avcdde\0 avc";
int i = 0;
/* 输出字符串直到控制字符 \0 */
while (!iscntrl(arr[i]))
{
putchar(arr[i]);
i++;
}
}
int main()
{
test();
return 0;
}
tolower函数
功能：大写字符转小写
头文件：#include<ctype.h>
运用
int main()
{
char arr[20] = { 0 };
gets(arr);//Hello Bit!
int i = 0;
while (arr[i])
{
if (isupper(arr[i])) //islower-----判断是不是小写字母a~z
{
arr[i] = tolower(arr[i]); //tolower------大写字符转小写
}
printf("%c", arr[i]);
i++;
}
return 0;
}
touppe函数
功能：小写字符转大写
头文件：#include<ctype.h>
运用
int main()
{
char arr[20] = {0};
gets(arr);
int i = 0;
while (arr[i])
{
if (islower(arr[i])) //isupper----判断是不是大写字母A~Z
{
arr[i] = toupper(arr[i]);
}
printf("%c", arr[i]);
i++;
}
return 0;
}
memcpy函数
函数原型：void * memcpy ( void * destination, const void * source, size_t num );
功能：函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
注意事项：
1.这个函数在遇到 ‘\0’ 的时候并不会停下来。
2.如果source和destination有任何的重叠，复制的结果都是未定义的。
3.返回值是void *
运用
//运用memcpy()函数
#include<stdio.h>
#include<string.h>
int main()
{
int arr1[] = { 1,2,3,4,5,6,7 };
int arr2[10];
//参数1----目的地 参数2----源头 参数三----拷贝的字节大小
//memcpy---函数是用来拷贝这种不相关的内存块的~
memcpy(arr2, arr1, 16);
return 0;
}
模拟实现
//模拟实现memcpy()
//参数1----目的地 参数2----源头 参数三----拷贝的字节大小
#include<assert.h>
#include<stdio.h>
void* my_memcpy(void *dest,const void*src,size_t size)
{
assert(dest != NULL && src != NULL);
void* temp = dest;
while (size--)
{
*(char*)dest = *(char*)src;
++(char*)dest;
++(char*)src;
}
return temp;
}
memmove函数
函数原型：void * memmove ( void * destination, const void * source, size_t num );
功能：由src所指内存区域复制num个字节到dest所指内存区域。
注意事项：
1.和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
2.如果源空间和目标空间出现重叠，就得使用memmove函数处理。
运用
#include<stdio.h>
#include<string.h>
int main()
{
//把1、2、3、4拷贝到3、4、5、6上
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
/*参数1----目的地 参数2----源头 参数三----拷贝的字节大小*/
memmove(arr + 2, arr, 16);
模拟实现
//模拟实现memmove()
#include<stdio.h>
#include<assert.h>
/*参数1----目的地 参数2----源头 参数三----拷贝的字节大小*/
void* my_memmove(void* dest, const void* src, size_t size)
{
assert(dest != NULL && src != NULL);
void* temp = dest;
if (dest<src)
{
/*从前向后拷贝*/
while (size--)
{
//当目标位置在源位置后，我们要从前向后拷贝
*(char*)dest = *(char*)src;
(char*)dest+1;
(char*)src+1;
}
}
else
{
/*从后向前拷贝*/
while (size--)
{
//当目标位置在源位置前，我们要从后向前拷贝
*((char*)dest + size) = *((char*)src+size);
}
}
return temp;
}
memset函数
功能：初始化字符数组
注意事项：
1.只能初始化字符
2.该函数是一个字节一个字节初始化
函数原型：memset(void *s,int ch,size_t n);
运用
#include<stdio.h>
#include<string.h>
int main()
{
char arr[20] = { 0 };
//只适用于初始化-----字符
memset(arr, '*', 20);
return 0;
}
扫一扫
2220
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
