常用的字符函数和字符串函数
strlen----------求字符串长度
strcpy-----------复制字符串
strcat-----------追加字符串
strcmp-----------比较字符串大小
长度受限制的字符串函数介绍
strncpy---------自定义需要拷贝多少个字符
strncat---------自定义需要插入多少个字符
strncmp---------自定义需要比较的字符串长度
字符串查找
strstr----------查找一个字符串在另一个字符串中 是否存在
strtok---------分割字符串
错误信息报告
strerror
字符操作
内存操作函数
memcpy------复制源头空间的数据到目的地空间(当空间出现重叠,复制的结果不确定)
memmove-----复制源头空间的数据到目的地空间(当空间出现重叠,依然可以使用)
memset------对一段内存空间进行自定义的初始化
memcmp------比较两个字符串从第一个元素开始后到第n个字符串的大小
strlen
size_t strlen ( const char * str );
strlen是用来求字符串str长度的函数,单位字节。从字符首位置开始遍历字符串,当遇到’\0’便停止。
然后将字符串的长度返回。
size_t类型表示返回的是一个unsigned int,是一个无符号数,因为长度没有负数。
const
用来定义常量,当一个变量被const
修饰,那么将不能被更改。
而strlen只用计算字符串的长度,防止改变str,所以用const修饰。
strlen的模拟实现
`int my_strlen(const char * str)
{
int count = 0;
while(*str)
{
count++;
str++;
}
return count;
}`
strcpy
char * strcpy ( char * destination, const char * source );
将源空间字符串source
拷贝到目标空间destination
返回值char*
:返回destination首地址
要求
1.源空间字符串以\0"结束
2.目标空间足够存储拷贝的字符串加原来的字符串
3.目标空间可改变
模拟实现
char *my_strcpy(char *dest, const char*src)
{
char *ret = dest;
assert(dest != NULL);
assert(src != NULL);
while((*dest++ = *src++))
{
;
}
return ret;
}
char* ret 记录dest首地址返回使用
assert 断言源空间和目标空间不为0;
`*dest++=*src++`将源空间的字符*后赋给目标空间,后++,当src把'\0'赋给dest后,整个表达式为0,结束循环。
strcat
char * strcat ( char * destination, const char * source );
将源空间的字符串追加到目标空间字符串之后(源字符串第一个字符放到目标目标空间字符串’\0’处)
返回值char*
:返回destination首地址
要求
1.目标空间足够大且以’\0’结束
2.源空间字符串以’\0’结束
模拟实现
```c
char *my_strcat(char *dest, const char*src)
{
char *ret = dest;
assert(dest != NULL);
assert(src != NULL);
while(*dest)
{ dest++;
}
while((*dest++ = *src++))
{
;
}
return ret;`
`}
模拟思想:先找到目标空间的’\0’,从’\0’开始追加字符串
strlcmp
int strcmp ( const char * str1, const char * str2 );
将 C 字符串 str1 与 C 字符串 str2 进行比较。此函数开始比较每个字符串的第一个字符。如果它们彼此相等,则继续执行以下对操作,直到字符不同或达到终止空字符。
返回值int
:当str1大于str2返回大于0的数;当str1小于str2返回小于0的数;当str1等于str2返回0;
模拟实现
int* my_strcmp(const char* dest, const char* src)
{
assert(dest && src);
int a = 0;
int b = 0;
while (*dest++)
{
a++;
}
while (*src++)
{
b++;
}
return a - b;
}
模拟思想:定义两个变量计数,遍历两个字符串,返回差值
strcpy
char * strncpy ( char * destination, const char * source, size_t num );
从字符串中复制字符
将源的前 num 个字符复制到目标。如果在复制数字字符之前找到源 C 字符串(由空字符表示)的末尾,则目标将用零填充,直到总共写入数字字符为止。
如果源大于 num,则不会在目标末尾隐式追加空字符。因此,在这种情况下,不应将目标视为空终止的 C 字符串(这样读取它会使溢出)。
目标和源不得重叠(有关重叠时更安全的替代方案,请参见 memmove)。
返回值char*
:返回目标空间首地址
要求
1.目标空间足够大且以’\0’结束
2.源空间字符串以’\0’结束
模拟实现
char* my_strncpy(char* dest, const char* src, int num)
{
assert(dest&&src);
char* ret = dest;
int i = 0;
for (i = 0; i < num; i++)
{
dest[i] = src[i];
}
return ret;
}
模拟思想:以num作为循环的停止条件,循环停止,说明num个字符已经拷贝完
strncat
char * strncat ( char * destination, const char * source, size_t num );
将源的前 num 个字符追加到目标,外加一个终止空字符。
如果源中 C 字符串的长度小于 num,则仅复制到终止空字符之前的内容。
返回值char*
:返回destination首地址
要求
1.目标空间足够大且以’\0’结束
2.源空间字符串以’\0’结束
模拟实现
char* my_strncat(char* str, const char* str1, char num)
{
assert(str&&str1);
while (*str)
{
str++;
}
for (int i = 1; i <= num; i++)
{
*str++=*str1++;
}
}
模拟思想:先找到目标空间的’\0’,再循环num次将源空间的字符赋进目标空间
strncmp
int strncmp ( const char * str1, const char * str2, size_t num );
比较两个字符串的字符
将 C 字符串 str1 的最多数字字符与 C 字符串 str2 的字符进行比较。
此函数开始比较每个字符串的第一个字符。如果它们彼此相等,则继续执行以下对操作,直到字符不同,直到达到终止空字符,或者直到两个字符串中的数字字符匹配,以先发生者为准。
返回值int
:当str1大于str2返回大于0的数;当str1小于str2返回小于0的数;当str1等于str2返回0;
要求
1.只比较大小,不改变字符串的内容
2.两个字符串不为NULL
模拟实现
int my_strncmp(const* str1, const* str2, size_t num)
{
char i = 0;
char* ptr1 = str1;
char* ptr2 = str2;
for (i = 1; i <= num; i++)
{
if (*ptr1!=*ptr2)
{
return (*ptr1 - *ptr2);
}
ptr1 = ptr1 + 1;
ptr2 = ptr2 + 1;
}
return 0;
}
strstr
char * strstr ( const char * str1, const char * str2 );
在一个字符串中查找另一个字符串是否存在
返回值char*
:返回指向 str1 中第一次出现的 str2 的指针,如果 str2 不是 str1 的一部分,则返回空指针。
要求
1.只比较大小,不改变字符串的内容
2.两个字符串不为NULL
char* my_strstr(const char* str1, const char* str2)
{
const char* s1 = str1;
const char* s2 = str2;
const char* p = str1;
if (*str1 == '\0')
{
return NULL;
}
while (*p)
{
s1 = p;
s2 = str2;
while (*s1!='\0' && *s2 != '\0' && *s1 == *s2)
{
s1++;
s2++;
if ('\0' == *s2)
{
return str1;
}
}
p++;
}
return NULL;
}
strtok
char * strtok ( char * str, const char * delimiters );
sep参数是个字符串,定义了用作分隔符的字符集合
第一个参数指定一个字符串,它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标
记。
strtok函数找到str中的下一个标记,并将其用 \0 结尾,返回一个指向这个标记的指针。(注:
strtok函数会改变被操作的字符串,所以在使用strtok函数切分的字符串一般都是临时拷贝的内容
并且可修改。)
strtok函数的第一个参数不为 NULL ,函数将找到str中第一个标记,strtok函数将保存它在字符串
中的位置。
strtok函数的第一个参数为 NULL ,函数将在同一个字符串中被保存的位置开始,查找下一个标
记。
如果字符串中不存在更多的标记,则返回 NULL 指针。
#include <stdio.h>
#include <string.h>
int main()
{
char *p = "zhangsan@baidu.tech";
const char* sep = ".@";
char arr[30];
char *str = NULL;
strcpy(arr, p);//将数据拷贝一份,处理arr数组的内容
for(str=strtok(arr, sep); str != NULL; str=strtok(NULL, sep))
{
printf("%s\n", str);
}
}
strerror
char * strerror ( int errnum );
获取指向错误消息字符串的指针
解释 errnum 的值,生成一个字符串,其中包含一条消息,该消息描述错误条件,就好像库的函数设置为 errno 一样。
返回的指针指向静态分配的字符串,程序不得修改该字符串。对此函数的进一步调用可能会覆盖其内容(不需要特定的库实现来避免数据争用)。
strerror 产生的错误字符串可能特定于每个系统和库实现。
#include <stdio.h>
#include <string.h>
#include <errno.h>/
int main ()
{
FILE * pFile;
pFile = fopen ("unexist.ent","r");
if (pFile == NULL)
printf ("Error opening file unexist.ent: %s\n",strerror(errno));
//errno: Last error number
return 0;
}
memcpy
void * memcpy ( void * destination, const void * source, size_t num );
复制内存块
将数字字节的值从源指向的位置直接复制到目标所指向的内存块。
源指针和目标指针所指向的对象的基础类型与此函数无关;结果是数据的二进制副本。
该函数不检查源代码中的任何终止空字符 - 它始终精确复制数字字节。
为避免溢出,目标和源参数所指向的数组大小应至少为数字字节,并且不应重叠(对于重叠的内存块,memmove 是一种更安全的方法)。
模拟实现
void* my_memcpy(void* dest, const void* src, size_t num)
{
assert(src);
void* ret = dest;
while (num--)
{
*((char*)dest)++ = *((char*)src)++;
}
return ret;
}
smemmove
void * memmove ( void * destination, const void * source, size_t num );
移动内存块
将数字字节的值从源指向的位置复制到目标所指向的内存块。复制就像使用了中间缓冲区一样进行,从而允许目标和源重叠。
源指针和目标指针所指向的对象的基础类型与此函数无关;结果是数据的二进制副本。
该函数不检查源代码中的任何终止空字符 - 它始终精确复制数字字节。
为避免溢出,目标和源参数所指向的数组大小应至少为数字字节。
void* my_move(void* dest, const void* src, size_t num)
{
assert(src);
void* ret = dest;
if (dest < src)
{
while (num--)
{
//*((char*)dest)++ = *((char*)src)++;
//某些编译器跑不了
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else
{
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
}
}
return ret;
}
memset
void * memset ( void * ptr, int value, size_t num );
填充内存块
自定义初始化
将 ptr 所指向的内存块的前 num(自定义) 个字节设置为指定的值(解释为无符号字符)。
示例
int main()
{
int arr[10];
int i = 0;
memset(arr, 0, sizeof(int) * 10);
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
memcmp
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
比较两个内存块
将 ptr1 所指向的内存块的前 num 个字节与 ptr2 所指向的前 num 个字节数进行比较,如果它们全部匹配,则返回零,或者返回一个不同于零的值,表示如果它们不匹配,则返回更大的数字字节。
请注意,与 strcmp 不同,该函数在找到空字符后不会停止比较。
size_t num 比较的单位是字节
返回值int
:当ptr1大于ptr2返回大于0的数;当ptr1小于ptr2返回小于0的数;当ptr1等于ptr2返回0;
示例
int main()
{
int arr[] = { 1,2,3,4,5 };
int arr1[] = { 1,2,2 };
int ret = memcmp(arr, arr1, sizeof(int)*2);
printf("%d",ret);
return 0;
}
模拟实现
int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{
char i = 0;
char* str1 = (char*)ptr1;
char* str2 = (char*)ptr2;
for (i = 1; i <= num; i++)
{
if (*(char*)str1 != *(char*)str2)
{
return (*(char*)str1 - *(char*)str2);
}
str1 = (char*)str1 + 1;
str2 = (char*)str2 + 1;
}
return 0;
}
int main()
{
char arr1[] = "abca";
char arr2[] = "accd";
int ret = my_memcmp(arr1, arr2, sizeof(char) * 2);
printf("%d",ret);
return 0;
}