前言
C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。 字符串常量适用于那些对它不做修改的字符串函数。
字符函数和内存函数介绍
- 求字符串长度
strlen - 长度不受限制的字符串函数
strcpy strcat strcmp - 长度受限制的字符串函数介绍
strncpy strncat strncmp - 字符串查找
strstr strtok - 错误信息报告
strerror - 内存操作函数
memcpy memmove memset memcm - 字符操作
库函数的模拟实现
strlen （求字符串长度）
size_t strlen ( const char * str );
-
字符串以 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
-
参数指向的字符串必须要以 ‘\0’ 结束。
-
注意函数的返回值为size_t，是无符号的（易错）
显然输出的结果是hehe,这就是因为strlen函数的返回值是size_t，是无符号的.两个无符号数相减还是无符号数，这里把-3的补码当做无符号数来处理，是一个很大的整数，因此输出的是hehe. -
strlen函数的模拟实现
//方法三，指针-指针的方式
int my_strlen(const char* str)
{
assert(str);
char *end = str;
while (*end)
{
++end;
}
return end - str;
}
//方法二，不能创建临时变量计数器（递归实现）
int my_strlen(const char* str)
{
assert(str);
if (*str == '\0')
{
return 0;
}
else
{
return 1 + my_strlen(str + 1);
}
}
//方法一，计数器方式
int my_strlen(const char* str)
{
assert(str);
int count = 0;
//while(*str!='\0')
while (*str)
{
++count;
++str;
}
return count;
}
int main()
{
char* p = "hello0\0world";
printf("%d\n", strlen(p));
int ret=my_strlen(p);
printf("%d\n", ret);
return 0;
}
strcpy (字符串复制)
char* strcpy(char * destination, const char * source );
- 把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间。
- src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。 返回指向dest的指针。
- strcpy函数的模拟实现
char* my_strcpy(char* dest, const char* src)
{
assert(dest);
assert(src);
char* ret = dest;
while ((*dest++ = *src++))
{
;
}
return ret;
}
int main()
{
char* p1 = "hello";
char p2[20];
strcpy(p2, p1);
printf("%s\n", p2);
my_strcpy(p2, p1);
printf("%s\n", p2);
return 0;
}
strcat (字符串拼接)
char * strcat ( char * destination, const char * source );
- 把src所指向的字符串（包括“\0”）复制到dest所指向的字符串后面（删除*dest原来末尾的“\0”）。
- 要保证dest足够长，以容纳被复制进来的src。*src中原有的字符不变。
- src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。 返回指向dest的指针。
- strcat函数的模拟实现
char* my_strcat(char* dest, const char* src)
{
assert(dest);
assert(src);
char* ret = dest;
while (*dest)
{
++dest;
}
while (*dest++ = *src++);
return ret;
}
int main()
{
char* p1 = "hello";
char p2[20];
strcpy(p2, p1);
my_strcat(p2, " world");
printf("%s\n", p2);
return 0;
}
strcmp (字符串比较)
int strcmp ( const char * str1, const char * str2 );
- 两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇’\0’为止。比较结果返回整数。
- 只能比较字符串，即可用于比较两个字符串常量，或比较数组和字符串常量，不能比较数字等其他形式的参数。
- 当两个字符串不相等时，C标准没有规定返回值会是1 或 -1，只规定了正数和负数。
- strcmp函数的模拟实现
int my_strcmp(const char* str1, const char* str2)
{
assert(str1 && str2);
while (*str1 && *str2)
{
if (*str1 > *str2)
{
return 1;
}
else if (*str1 < *str2)
{
return -1;
}
else
{
++str1;
++str2;
}
}
// "aaaa" "aaaa" 0
// "aaaa" "aaaaa" -1
// "aaaaa" "aaaa" 1
if (*str1 == '\0' && *str2 == '\0')
{
return 0;
}
else if (*str1 == '\0')
{
return -1;
}
else
{
return 1;
}
}
int main()
{
char* p1 = "helloo";
char* p2 = "hello";
printf("%d\n", strcmp(p1, p2));
printf("%d\n", my_strcmp(p1, p2));
return 0;
}
strncpy (将指定长度的字符串复制到字符数组中)
char *strncpy(char *dest, const char *src, int n);
- 表示把src所指向的字符串中以src地址开始的前n个字节复制到dest所指的数组中，并返回被复制后的dest。
- 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
- strncpy函数的模拟实现
char* my_strncpy(char *dest, const char *src, size_t num)
{
assert(dest&&src);
char *start = dest;
while (num && (*dest++ = *src++))//拷贝字符串
{
num--;
}
if (num)//用'\0'填充
{
while (--num)
{
*dest++ = '\0';
}
}
return(start);
}
int main()
{
char *src = "one world one dream\0hehe";
char dest[100];
//strncpy(dest, src, 30);
my_strncpy(dest, src, 30);
printf("%s\n", dest);
return 0;
}
strncat (在字符串的结尾追加n个字符)
char * strncat ( char * destination, const char * source, size_t num );
- 把src所指字符串的前n个字符添加到dest所指字符串的结尾处，并覆盖dest所指字符串结尾的’\0’，从而实现字符串的连接。
- src和dest所指内存区域不可以重叠，并且dest必须有足够的空间来容纳src的字符串，返回指向dest的指针。
- strncat函数的模拟实现
char* my_strncat(char *dest, const char *src, size_t num)
{
assert(dest&&src);
char *ret = dest;
while (*dest++)//先找到目标空间的结尾
{
;
}
dest--;//将'\0'留出来
while (num--)
{
if (!(*dest++ = *src++))
{
return(ret);
}
*dest = '\0';
}
return(ret);
}
int main()
{
char str1[20] = "best ";
char str2[] = "wishes!";
char* p=my_strncat(str1, str2, 6);
printf("%s\n", p);
return 0;
}
strncmp (指定比较size个字符)
int strncmp ( const char * str1, const char * str2, size_t num );
- 比较指定个数字符的大小。/比较字符串中任一小段的大小。
- 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
- 字符串大小的比较是以ASCII 码表上的顺序来决定，此顺序亦为字符的值。
- strncmp函数的模拟实现
int my_strncmp(const char *str1, const char * str2, size_t count)
{
assert(str1&&str2);
while (count && (*str1 == *str2))
{
if (*str1 == '\0')
{
return 0;
}
str1++;
str2++;
count--;
}
return *str1 - *str2;
}
int main()
{
char* str1 = "aabbcde";
char* str2 = "aabbccd";
int ret = my_strncmp(str1, str2, 6);
printf("%d\n", ret);
return 0;
}
strstr (字符串查找)
char* strstr (const char*,const char*);
- 用于判断字符串str2是否是str1的子串。如果是，则该函数返回 str1字符串从 str2第一次出现的位置开始到 str1结尾的字符串；否则，返回NULL。
- strstr函数的模拟实现
const char* my_strstr(const char* str1, const char* str2)
{
assert(str1 && str2);
const char* src = str1;
const char* sub = str2;
// 依次跟原串进行比较
while (*src)
{
// sub跟src的一部分进行匹配
const char* start = src;
while (*src == *sub && *sub != '\0')
{
++src;
++sub;
}
if (*sub == '\0')
{ // 匹配成功
return start;
}
else
{// 没有匹配，往回退
src = start + 1;
sub = str2;
}
}
return NULL;
}
int main()
{
char* p1 = "hello world";
char* p2 = "wor";
const char* match1 = my_strstr(p1, p2);
printf("%s\n", match1);
p2 = "word";
const char* match2 = my_strstr(p1, p2);
printf("%s\n", match2);
p1 = "aaabbc";
p2 = "aab";
const char* match3 = my_strstr(p1, p2);
printf("%s\n", match3);
return 0;
}
strtok (分割字符串)
char* strtok(char* str, const char* sep);
- sep参数是个字符串，定义了用作分隔符的字符集合。
- 第一个参数指定一个字符串，它包含了0个或多个有sep字符串中一个或多个分割符分割的标记。
- strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改 变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
- strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
- strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
- 如果字符串中不存在更多的标记，则返回 NULL 指针。
strerror (查询错误对应的错误描述)
char* strerror (int errnum)
- 通过标准错误的标号，获得错误的描述字符串 ，将单纯的错误标号转为字符串描述，方便用户查找错误。
- errnum：错误标号，通常用errno(标准错误号，定义在errno.h中)
memcpy (内存拷贝函数)
void* memcpy (void* destination, const void* source, size_t num);
- 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
- 这个函数在遇到 ‘\0’ 的时候并不会停下来。
- 如果source和destination有任何的重叠，复制的结果都是未定义的
- memcpy函数的模拟实现
void* my_memcpy(void* dst, const void* src, size_t num)
{
assert(src && dst);
const char* byte_src = (char*)src;
char* byte_dst = (char*)dst;
/*for (size_t i = 0; i < num; ++i)
{
byte_dst[i] = byte_src[i];
}*/
while (num--)
{
*byte_dst++ = *byte_src++;
}
return dst;
}
int main()
{
int a1[5] = { 1, 2, 3, 4, 5 };
int a2[5];
my_memcpy(a2, a1, sizeof(int)* 5);
double a3[5] = { 1.1, 2.2, 3.3, 4.4, 5.5 };
double a4[5];
my_memcpy(a4, a3, sizeof(double)* 5);
return 0;
}
memmove (内存拷贝函数)
void * memmove ( void * destination, const void * source, size_t num );
- 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
- 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
- memmove函数的模拟实现
void* my_memmove(void* dst, const void* src, size_t num)
{
assert(src && dst);
const char* byte_src = (char*)src;
char* byte_dst = (char*)dst;
if (byte_dst > byte_src && byte_src < byte_src + num)
{
// 从后往前拷贝
for (int i = num - 1; i >= 0; --i)
{
byte_dst[i] = byte_src[i];
}
}
else
{
// 从前往后拷贝
for (int i = 0; i < num; ++i)
{
byte_dst[i] = byte_src[i];
}
}
return dst;
}
memcmp (按字节比较)
int memcmp (const void * ptr1, const void * ptr2, size_t num );
- 比较从ptr1和ptr2指针开始的num个字节,其结果为按字节进行对比。
- 如果返回值 < 0，则表示 str1 小于 str2。
如果返回值 > 0，则表示 str2 小于 str1。
如果返回值 = 0，则表示 str1 等于 str2。 - memcmp函数的模拟实现
int my_memcmp(char *str1, char *str2, int len)
{
assert(str1);
assert(str2);
while (len--)
{
while (*str1 == *str2)
{
if (*str1 == '\0')
return 0;
str1++;
str2++;
}
}
if (*str1>*str2)
return 1;
if (*str1<*str2)
return -1;
}
int main()
{
char *p = "adcc";
char *q = "bac";
printf("%d\n", my_memcmp(p, q, 1));
return 0;
}
字符分类函数
函数 如果他的参数符合下列条件就返回真
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 任何可打印字符，包括图形字符和空白字符
3281
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
