C字符串处理函数的实现
2013-10-20 18:08
309 查看
C字符串处理函数的实现
C字符串处理函数的实现（Linux）#include <stddef.h>
char * ___strtok = NULL;
char * strcpy(char * dest,const char *src)
{
char *tmp = dest;
while ((*dest++ = *src++) != '/0')
/* nothing */;
return tmp;
}
char * strncpy(char * dest,const char *src,size_t count)
{
char *tmp = dest;
while (count-- && (*dest++ = *src++) != '/0')
/* nothing */;
return tmp;
}
char * strcat(char * dest, const char * src)
{
char *tmp = dest;
while (*dest)
dest++;
while ((*dest++ = *src++) != '/0')
;
return tmp;
}
char * strncat(char *dest, const char *src, size_t count)
{
char *tmp = dest;
if (count) {
while (*dest)
dest++;
while ((*dest++ = *src++)) {
if (--count == 0)
break;
}
}
return tmp;
}
int strcmp(const char * cs,const char * ct)
{
register signed char __res;
while (1) {
if ((__res = *cs - *ct++) != 0 || !*cs++) /*is !*cs++ necessary? incase more cmp*/
break;
}
return __res;
}
int strncmp(const char * cs,const char * ct,size_t count)
{
register signed char __res = 0;
while (count) {
if ((__res = *cs - *ct++) != 0 || !*cs++)
break;
count--;
}
return __res;
}
char * strchr(const char * s,char c)
{
for(; *s != c; ++s)
if (*s == '/0')
return NULL;
return (char *) s;
}
size_t strlen(const char * s)
{
const char *sc;
for (sc = s; *sc != '/0'; ++sc)
/* nothing */;
return sc - s;
}
size_t strnlen(const char * s, size_t count)
{
const char *sc;
for (sc = s; *sc != '/0' && count--; ++sc)
/* nothing */;
return sc - s;
}
size_t strspn(const char *s, const char *accept)
{
const char *p;
const char *a;
size_t count = 0;
for (p = s; *p != '/0'; ++p) {
for (a = accept; *a != '/0'; ++a) {
if (*p == *a)
break;
}
if (*a == '/0')
return count;
++count;
}
return count;
}
char * strpbrk(const char * cs,const char * ct)
{
const char *sc1,*sc2;
for( sc1 = cs; *sc1 != '/0'; ++sc1) {
for( sc2 = ct; *sc2 != '/0'; ++sc2) {
if (*sc1 == *sc2)
return (char *) sc1;
}
}
return NULL;
}
char * strtok(char * s,const char * ct)
{
char *sbegin, *send;
sbegin = s ? s : ___strtok;
if (!sbegin) {
return NULL;
}
sbegin += strspn(sbegin,ct);
if (*sbegin == '/0') {
___strtok = NULL;
return( NULL );
}
send = strpbrk( sbegin, ct);
if (send && *send != '/0')
*send++ = '/0';
___strtok = send;
return (sbegin);
}
void * memset(void * s,char c,size_t count)
{
char *xs = (char *) s;
while (count--)
*xs++ = c;
return s;
}
char * bcopy(const char * src, char * dest, int count)
{
char *tmp = dest;
while (count--)
*tmp++ = *src++;
return dest;
}
void * memcpy(void * dest,const void *src,size_t count)
{
char *tmp = (char *) dest, *s = (char *) src;
while (count--)
*tmp++ = *s++;
return dest;
}
void * memmove(void * dest,const void *src,size_t count)
{
char *tmp, *s;
if (dest <= src) {
tmp = (char *) dest;
s = (char *) src;
while (count--)
*tmp++ = *s++;
}
else {
tmp = (char *) dest + count;
s = (char *) src + count;
while (count--)
*--tmp = *--s; /*12345678*/
} /*12345678*/
return dest;
}
int memcmp(const void * cs,const void * ct,size_t count)
{
const unsigned char *su1, *su2;
signed char res = 0;
for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
if ((res = *su1 - *su2) != 0)
break;
return res;
}
/*
* find the first occurrence of byte 'c', or 1 past the area if none
*/
void * memscan(void * addr, unsigned char c, size_t size)
{
unsigned char * p = (unsigned char *) addr;
while (size) {
if (*p == c)
return (void *) p;
p++;
size--;
}
return (void *) p;
}
void main(void)
{
return;
}
补充strstr
char *
strstr (const char *haystack, const char *needle)
{
char *result = (char *)NULL;
if ((haystack != (char *)NULL) && (needle != (char *)NULL))
{
register int i;
int hl = strlen (haystack);
int nl = strlen (needle);
for (i = 0; i < (hl - nl); i++)
if (strncmp (haystack + i, needle, nl) == 0)
{
result = haystack + i;
break;
}
}
return (result);
}还有 加州大学的：
char *strstr(const char *string, const char *substring)
{
const char *a, *b;
b = substring;
if (*b == 0)
{
return (char*)string;
}
for( ; *string != 0; string += 1)
{
if (*string != *b)
{
continue;
}
a = string;
while ((*a++ == *b++) && (*b != 0) );
if (*b == 0)
{
return (char*) string;
}
b = substring;
}
}最后是AT&T:
extern char*
strstr(register const char* s1, register const char* s2)
{
register int c1;
register int c2;
register const char* t1;
register const char* t2;
if (s2)
{
if (!*s2)
return (char*)s1;
c2 = *s2++;
while (c1 = *s1++)
if (c1 == c2)
{
t1 = s1;
t2 = s2;
do
{
if (!*t2)
return (char*)s1 - 1;
} while (*t1++ == *t2++);
}
}
return 0;
}--------------------------------------------------------------------------
http://blog.csdn.net/wzbob/archive/2006/11/10/1377600.aspx
c和汇编实现 一些基本字符串处理函数
1. 将一个字符串(src)拷贝到另一个字符串(dest)，直到遇到NULL 字符后停止。
char *strcpy (char *dest, const char *src)
{
_asm
{
pushf
mov esi,src
mov edi,dest
cld
l1: lodsb
stosb
test al,al
jne l1
popf
}
return dest;
}
2.拷贝源字符串count 个字节到目的字符串。
char *strncpy (char *dest, const char *src, int count)
{
_asm{
pushf
mov esi,src
mov edi,dest
mov ecx,count
cld
l1: dec ecx
js l2
lodsb
stosb
test al,al
jne l1
rep stosb
l2: popf
}
return dest;
}
3.将源字符串拷贝到目的字符串的末尾处。
char *strcat (char *dest, const char *src)
{
_asm {
pushf
mov esi,src
mov edi,dest
xor al,al
mov ecx,0xffffffff
cld // 清方向位。
repne scasb
dec edi
l1: lodsb
stosb
test al,al
jne l1
popf
}
return dest;
}
4.将源字符串的count 个字节复制到目的字符串的末尾处，最后添一空字符。
char *strncat (char *dest, const char *src, int count)
{
_asm {
pushf
mov esi,src
mov edi,dest
xor al,al
mov ecx,0xffffffff
cld
repne scasb
dec edi
mov ecx,count
l1: dec ecx
js l2
lodsb
stosb
test al,al
jne l1
l2: xor al,al
stosb
popf
}
return dest;
}
5. 将一个字符串与另一个字符串进行比较。
int strcmp (const char *csrc, const char *ct)
{
_asm{
pushf
mov edi,csrc
mov esi,ct
cld
l1: lodsb
scasb
jne l2
test al,al
jne l1
xor eax,eax
jmp l3
l2: mov eax,1
jl l3
neg eax
l3: popf
}
}
------------------------------------------------------------------------------------
1. strlen(),计算字符串长度
int strlen(const char string)
{
int i=0;
while(string[i]) i++;
return i;
}
2. strcpy(), 字符串拷贝.
char *strcpy(char *destination, const char *source)
{
while(*destinaton++=*source++);
return (destination-1);
}
3. strcat(), 字符串的连接.
char *strcat(char *target,const char *source)
{
char *original=target;
while(*target) target++; // Find the end of the string
while(*target++=*source++);
return(original);
}
4. streql(), 判断两个字符串是否相等.
int streql(char *str1,char *str2)
{
while((*str1==*str2)&&(*str1))
{
str1++;
str2++;
}
return((*str1==NULL)&&(*str2==NULL));
}
5. strchr(), 在字符串中查找某个字符.
char *strchr(const char *string,int letter)
{
while((*string!=letter)&(*string))
string++;
return (string);
}
6. chrcnt(), 计算某个字符在字符串中出现的次数.
int chrcnt(const char *string,int letter)
{
int count=0;
while(*string)
if(*string==letter)count++;
return count;
}
7. strcmp(), 判断两个字符串是否相等.
int strcmp(const char *str1,const char *str2)
{
while((*str1==*str2)&&(*str1))
{
str1++;
str2++;
}
if((*str1==*str2)&&(!*str1)) //Same strings
return o;
else if((*str1)&&(!*str2)) //Same but str1 longer
return -1;
else if((*str2)&&(!*str1)) //Same but str2 longer
else
return((*str1>*str2)?-1:1);
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 字符串处理函数的实现及注意事项
- 自己实现基本的C标准库字符串处理函数——基本问题（转载）
- C语言:使用链表实现的可变长度字符串处理函数
- C字符串处理函数的实现
- 自定义函数实现字符串处理函数strcat、 strcpy、strcmp、strlen和strlwr
- 巧用boost库实现字符串映射消息处理函数
- 浅谈字符串处理函数的实现（一）
- 常用的字符串处理库函数的C语言实现
- 自己实现的一些字符串处理的函数
- 方便又官方的字符串处理函数及内存函数的实现
- 字符串处理函数strlen、strcpy、strcat、strcmp和convert的C语言实现
- 浅谈字符串处理函数的实现（一）
- 巧用boost库实现字符串映射消息处理函数
- 字符串处理函数strchr和strstr的实现
- 巧用boost库实现字符串映射消息处理函数
- c 实现字符串处理函数
- strcat,strcpy,strcmp,strlen4个常用字符串处理函数的数组与指针简单实现方法~
- 几个常见字符串处理函数的实现原理
- 金山笔试题-字符串排序 :" 写一个函数，实现对给定的字符串（字符串里面包括：英文字母，数字，符号）的处理"
- 字符串处理函数的实现