实现一些常用字符串处理函数
1、字符串copy函数strcpy，实现如下:
|
1
2
3
4
5
6
7
8
9
10
11
12
|
#include <assert.h>
char
*mystrcpy(
char
*dest,
const
char
*sor)
//将源字符sor串拷到目的字符串dest
{
assert
(dest);
assert
(sor);
char
*ret = dest;
while
(*dest++ = *sor++)
{
;
}
return
ret;
}
|
2、判断一个字符串中的子字符串strstr，实现如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
#include <assert.h>
#include <stdio.h>
char
*mystrstr(
char
*str_one,
char
*str_two)
//判断str_two字符串是不是str_one字符串的子字符 //串
{
char
*pstr_one = NULL;
char
*pstr_two = NULL;
while
(*str_one)
{
pstr_one = str_one;
pstr_two = str_two;
while
((*pstr_one)&&(*pstr_one == *pstr_two))
{
pstr_one++;
pstr_two++;
if
(*pstr_two ==
'\0'
)
{
return
str_one;
}
}
str_one++;
}
return
NULL;
}
|
3、三种方法实现求取字符串长度strlen：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
#include <assert.h>
//计数器实现strlen
//int mystrlen(const char *dest)
//{
// assert(dest);
// int count = 0;
// while(*dest)
// {
// count++;
// dest++;
// }
// return count;
//}
//指针实现strlen
//int mystrlen(const char *dest)
//{
// assert(dest);
// int ret = 0;
// const char *buff = dest;
// while(*dest)
// {
// dest++;
// }
// ret = dest - buff;
// return ret;
//}
//递归实现strlen
int
mystrlen(
const
char
*dest)
{
assert
(dest);
if
(*dest ==
'\0'
)
{
return
0;
}
dest++;
return
1+mystrlen(dest);
}
|
4、字符串的比较strcmp，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#include <assert.h>
int
mystrcmp(
const
char
*cmp1,
const
char
*cmp2)
{
assert
(cmp1);
assert
(cmp2);
int
ret = 0;
while
(!(ret = (*(unsigned
char
*)cmp1 - *(unsigned
char
*)cmp2))&&*cmp2)
{
cmp1++;
cmp2++;
}
if
(ret>0)
return
1;
else
if
(ret<0)
return
-1;
return
0;
}
|
5、字符串链接函数strcat，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#include <assert.h>
char
*mystrcat(
char
*dest,
const
char
*sor)
{
assert
(dest);
assert
(sor);
char
*ret = dest;
while
(*dest)
{
dest++;
}
while
(*dest++ =*sor++)
{
;
}
return
ret;
}
|
注意：对于一些特别的符号字符串处理函数就不能很好的解决了，比如要复制或链接两个内容都是'\0'，这样就不能很好解决问题。因此就引入了内存的复制和移动函数。
6、拷贝函数，memcpy函数，有三个参数，两个空类型指针（也叫做句柄）（表示可以接受任何类型的指针），一个count字符串大小。代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#include <assert.h>
void
*mymemcpy(
void
*dest,
const
void
*sor,
int
count)
{
assert
(dest);
assert
(sor);
char
*pdest = (
char
*)dest;
char
*psor = (
char
*)sor;
void
*ret = dest;
while
(count--)
{
*pdest++ = *psor++;
}
return
ret;
}
|
注意这个函数的的缺点：导致内容被覆盖：
| a | b | c | d | e | f | g | h | i | j |
比如：如果不abcd拷贝到cdef，则会导致cd被ab覆盖，输出的结果为：abababghij而不是：ababcdghij
因此引入，memmove函数。
7、memmove函数，拷贝内存函数，很好的解决的memcpy的不足，代码如下:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
#include <assert.h>
void
*mymemmove(
void
*dest,
const
void
*sor,
int
count)
{
assert
(dest);
assert
(sor);
char
*pdest = (
char
*)dest;
char
*psor = (
char
*)sor;
void
*ret = dest;
if
(pdest>psor&&pdest<psor+count)
//从后向前复制，这样就很好解决了memcpy的覆盖问题
{
while
(count--)
{
*(pdest+count) = *(psor+count);
}
}
else
{
while
(count--)
{
*pdest++ = *psor++;
}
}
return
ret;
}
|
本文转自 8yi少女的夢 51CTO博客，原文链接：http://blog.51cto.com/zhaoxiaohu/1719395，如需转载请自行联系原作者