字符串处理函数（不使用库函数实现）
时间：2010-06-23 来源：chengbin_liu
int strlen1(const char *str);
char *del_char(char *str,char c);
char *delete_string(char *str,int pos,int len);
const char *strstr1(const char *src,const char *sub);
char *strchr1( char *str, char ch );
int chrcnt1(const char *src,char ch);
char *strpbk(char const *s,char const *accpet);
char *strcpy1(char *Dest,const char *source);
char *strncpy1(char *Dest,const char *source,int len);
void *memcpy1(void* dst,const void* src,size_t count);
void *memmove1(void* dst,const void* src,size_t count);
char *strcat1(char *dest,const char *src);
char *strncat1(char *dest, const char* src,int num);
void sort1(char *src,int num);
char *strrv1(const char *str);
char *strrv2(const char *str);
char *strrv3(char *str,int len);
void revstr(char *src);
int isRevstr(char *str);//判断是否为回文level
void loopMove(char *src,int n);
char *loopmove(char *str, int num);
//////////////////////////////////////////////////////////////////////////////////
//计算字符串的长度
int strlen1(const char *str)
{
int len=0;
while (*str++!='\0')
len++;
return len; /*字符串长度较长时该方法比上面（自增两次）的效率要高
**const char *temp=str;//保存src的首地址
**while(*src++!='\0');//自增一次
**return (src-temp-1);//返回尾部指针与头部指针之差，即长度
*/
}
////////////////////////////////////////////////////////////////////////////////
//删除字符串中所有指定的字符
//定义两个指针，head指针做记录使用，p做字符串遍历使用；
char *del_char(char *str,char c)
{
char *head=NULL;
char *p=NULL;
if (str==NULL)
{
return NULL;
}
head=p=str;
while(*p)
{
if(*p!=c)
{
*str++=*p;
}
p++;
}
*str='\0';
return head;
}
//////////////////////////////////////////////////////////////////////////////
//从字符串指定位置开始，删除其指定长度的字符
//首先检查pos和len的合法性，然后找到pos位置，删除len个字符
char *delete_string(char *str,int pos,int len)
{
char *p=str+pos-1;//指向pos位置的字符
int strlen=strlen1(str);//自定义方法
//int str_len=strlen(str);//字符长度库函数 if ((pos<1)||(p-str)>strlen)//检查pos是否不大于1，或pos超出字符串长度
{
return str;
}
if ((p+len-str)>strlen)//len大于pos后剩余的字符个数的话，只需对pos位置赋'\0'
{
*p='\0';
return str;
}
while (*p && *(p+len))//len小于或等于pos后剩余的字符个数删除len个字符
{
*p=*(p+len);
p++;
}
*p='\0';
return str;
}
///////////////////////////////////////////////////////////////////////////////
//字符串中字串的查找strstr库函数的实现
const char *strstr1(const char *src,const char *sub)
{
const char *bp;
const char *sp;
if (src==NULL || sub==NULL)//检查src和sub的有效性
{
return src;
}
while (*src)
{
bp=src;
sp=sub;
do
{ //遍历sub字符串
if(!*sp) //如果到了sub字符串结束位置，退出
return src;
} while (*bp++==*sp++);
src+=1;
} return NULL;
}
/////////////////////////////////////////////////////////////////////////////
//strchr()函数返回一个指向str中ch首次出现的位置，当没有在str中找ch时返回NULL。
char *strchr1(char *src, char ch )
{ while((*src!=ch)&&(*src))
src++; return (src); }
////////////////////////////////////////////////////////////////////////////////
//chrcnt(), 计算某个字符在字符串中出现的次数.
int chrcnt1(const char *src,char ch)
{
int count=0;
while(*src)
if(*src==ch)
count++;
return count;
}
/////////////////////////////////////////////////////////////////////////
//该函数返回一个指向str中第一个匹配的group中任何一个字符的字符位置.若无则返回空(NULL).
char *strpbk(char const *s,char const *accpet)
{
while(*s != '\0')
{
while(*accpet != '\0')
if(*accpet++ == *s)
return (char *)s;
++s;
}
return NULL;
}
////////////////////////////////////////////////////////////////////////////////
//字符串复制
char *strcpy1(char *Dest,const char *source)
{
char *srcDest=Dest;//保存目标字符串的首地址
/*
while( *source !='\0')
*Dest++ = *source++;
*Dest = '\0'; //写法1
*/
while((*Dest++=*source++)!='\0');
return srcDest;
}
/////////////////////////////////////////////////////////////////////////
//指定长度的字符串复制
char *strncpy1(char *Dest,const char *source,int len)
{
char *srcDest=Dest;//保存目标字符串的首地址
while( *source !='\0' && len--)
*Dest++ = *source++;
*Dest = '\0'; return srcDest;
}
////////////////////////////////////////////////////////////////////////////
//内存复制的实现拷贝不重叠的内存块 void* memcpy1(void* dst,const void* src,size_t count)
{
char* pbTo = (char*)dst;
char* pbFrom = (char*)src;
assert(dst!= NULL && src != NULL);//不能存在空指针
assert(pbTo >= pbFrom+count || pbFrom >= pbTo + count);//防止内存重叠(overlap)
while (count-- > 0)
{
*pbTo++ = *pbFrom++;
}
return dst;
} //////////////////////////////////////////////////////////////////////////
//memmove实现移动一块字节，src源数据可以不保留
void* memmove1(void* dst,const void* src,size_t count)
{
char* pbTo = (char*)dst;
char* pbFrom = (char*)src;
assert(dst != NULL && src != NULL);//不能存在空指针
if (dst <= src || pbTo >= pbFrom + count)//没有overlap的情况，直接拷贝
{
while (count-- > 0)
{
*pbTo++ = *pbFrom++;
}
}
else
{
pbTo = pbTo + count -1;//overlap的情况，从高位地址向低位拷贝
pbFrom = pbFrom + count -1;
while (count-- > 0)
{
*pbTo-- = *pbFrom--;
}
}
return dst;
}
/////////////////////////////////////////////////////////////////
//memset:把buffer所指内存区域的前count个字节设置成字符c
void * Memset(void* buffer, int c, int count)
{
char* pvTo=(char*)buffer;
assert(buffer != NULL);
while(count-->0)
*pvTo++=(char)c;
return buffer;
}
/////////////////////////////////////////////////////////////////////////////
//字符串比较strcmp库函数的实现
int strcmp1(const char *src,const char *dst)
{
int ret;
while (!(ret=*(unsigned char *)src-*(unsigned char *)dst)&& *dst)//循环比较两个字符是否相等
{
++src;
++dst;
}
if(ret<0) ret=-1;
else
if(ret>0) ret=1;
return (ret);
}
/////////////////////////////////////////////////////////////////////////
//连接两个字符串strcat库函数的实现
char *strcat1(char *dest,const char *src)
{
char *temp = dest;
while (*dest != '\0')
dest++;
while((*dest++ = *src++) != '\0');
return temp;
}
////////////////////////////////////////////////////////////////////////////
////连接两个字符串的指定个数strncat库函数的实现
char *strncat1(char *dest, const char* src,int num)
{
char *temp = dest;
while (*dest != '\0')
dest++;
while((*dest++ = *src++) != '\0' && num--);
return temp;
}
////////////////////////////////////////////////////////////////////////////
//字符串的排序与交换 冒泡。。
void sort1(char *src,int num)
{
int i,j;
int tmp=0;
for (i=0;i<num;i++)
{
for (j=i+1;j<num;j++)
{
tmp=src[i];
src[i]=src[j];
src[j]=tmp;
}
}
}
//////////////////////////////////////////////////////////////////////////
//字符串的反转
char *strrv1(const char *str)
{
int i;
int len=strlen(str);
char c;
char *tmp=new char[len+1]; strcpy(tmp,str);
for(i=0;i<len/2;++i)
{
c=tmp[i];
tmp[i]=tmp[len-i-1];
tmp[len-i-1]=c;
}
return tmp;
}
//指针实现
char *strrv2(const char *str)
{
char c;
char *tmp=new char[strlen(str)+1];
strcpy(tmp,str); char *ret=tmp;
char *p=tmp+strlen(str)-1;
while (p>tmp)
{
c=*tmp;
*tmp=*p;
*p=c;
--p;
++tmp;
}
return ret;
}
//递归实现
char *strrv3(char *str,int len)
{
if (len<=1)
return str;
char t=*str;
*str=*(str+len-1);
*(str+len-1)=t; return (strrv3(str+1,len-2)-1); }
///////////////////////////////////////////////////////////////////////
//反转abcdefgh 但不改变单词的内部结构
void revstr(char *src)
{
char *start=src,*end=src,*ptr=src;
while (*ptr++ !='\0')
{
if (*ptr==' '|| *ptr=='\0')
{
end=ptr-1;//end指向单词末尾
while(start<end)
swap(*start++,*end--);//把单词的字母逆置
start=end=ptr+1;//指向下一个单词的开头
}
} start=src,end=ptr-2;//start指向开头，end指向末尾
while (start<end)
{
swap(*start++,*end--);//把整个字符串逆置
} }
//////////////////////////////////////////////////////////////////////
//判断是否为回文level
int isRevstr(char *str)
{
int i,len;
int found=1;
if (str==NULL)
{
return -1;
}
len=strlen(str);
for (i=0;i<len/2;i++)
{
if(*(str+i)!=*(str+len-i-1))
{
found=0;
break;
}
}
return found;
}
/////////////////////////////////////////////////////////////////////////
//字符串循环右移
void loopMove(char *src,int n)
{
int i=0;
char *tmp=NULL;
int strlen=0;
char *head=src;
while (*src++)
strlen=src-head-1;
n=n%strlen;
tmp=(char*)malloc(n);
for (i=strlen-1;i<n;i++)
{
tmp[i]=head[strlen-n+i];
}
for (i=strlen-1;i>=n;i--)
{
head[i]=hean[i-n];
}
for (i=0;i<n;i++)
{
head[i]=tmp[i];
}
free(tmp);
}
////////////////////////////////////////////////////////////////////////
//字符串右移 （不使用库函数实现）
char *loopmove(char *str, int num)
{
char temp[100]="";
int i = 0;
int len = 0;
//求长度
for(i=0;str[i]!=0;i++)
len++;
//保存最后num个字符
for(i=0;i<num;i++)
{
temp[i] = str[len-num+i];
}
//将前 len-num个字符向后移动num个字节
for(i=0;i<len-num;i++)
{
str[len-1-i] = str[len-1-i-num] ;
}
//将保存的后num个字符放在str最前面
for(i=0;i<num;i++)
{
str[i] = temp[i];
}
return str;
}
char *delete_string(char *str,int pos,int len);
const char *strstr1(const char *src,const char *sub);
char *strchr1( char *str, char ch );
int chrcnt1(const char *src,char ch);
char *strpbk(char const *s,char const *accpet);
char *strcpy1(char *Dest,const char *source);
char *strncpy1(char *Dest,const char *source,int len);
void *memcpy1(void* dst,const void* src,size_t count);
void *memmove1(void* dst,const void* src,size_t count);
char *strcat1(char *dest,const char *src);
char *strncat1(char *dest, const char* src,int num);
void sort1(char *src,int num);
char *strrv1(const char *str);
char *strrv2(const char *str);
char *strrv3(char *str,int len);
void revstr(char *src);
int isRevstr(char *str);//判断是否为回文level
void loopMove(char *src,int n);
char *loopmove(char *str, int num);
//////////////////////////////////////////////////////////////////////////////////
//计算字符串的长度
int strlen1(const char *str)
{
int len=0;
while (*str++!='\0')
len++;
return len; /*字符串长度较长时该方法比上面（自增两次）的效率要高
**const char *temp=str;//保存src的首地址
**while(*src++!='\0');//自增一次
**return (src-temp-1);//返回尾部指针与头部指针之差，即长度
*/
}
////////////////////////////////////////////////////////////////////////////////
//删除字符串中所有指定的字符
//定义两个指针，head指针做记录使用，p做字符串遍历使用；
char *del_char(char *str,char c)
{
char *head=NULL;
char *p=NULL;
if (str==NULL)
{
return NULL;
}
head=p=str;
while(*p)
{
if(*p!=c)
{
*str++=*p;
}
p++;
}
*str='\0';
return head;
}
//////////////////////////////////////////////////////////////////////////////
//从字符串指定位置开始，删除其指定长度的字符
//首先检查pos和len的合法性，然后找到pos位置，删除len个字符
char *delete_string(char *str,int pos,int len)
{
char *p=str+pos-1;//指向pos位置的字符
int strlen=strlen1(str);//自定义方法
//int str_len=strlen(str);//字符长度库函数 if ((pos<1)||(p-str)>strlen)//检查pos是否不大于1，或pos超出字符串长度
{
return str;
}
if ((p+len-str)>strlen)//len大于pos后剩余的字符个数的话，只需对pos位置赋'\0'
{
*p='\0';
return str;
}
while (*p && *(p+len))//len小于或等于pos后剩余的字符个数删除len个字符
{
*p=*(p+len);
p++;
}
*p='\0';
return str;
}
///////////////////////////////////////////////////////////////////////////////
//字符串中字串的查找strstr库函数的实现
const char *strstr1(const char *src,const char *sub)
{
const char *bp;
const char *sp;
if (src==NULL || sub==NULL)//检查src和sub的有效性
{
return src;
}
while (*src)
{
bp=src;
sp=sub;
do
{ //遍历sub字符串
if(!*sp) //如果到了sub字符串结束位置，退出
return src;
} while (*bp++==*sp++);
src+=1;
} return NULL;
}
/////////////////////////////////////////////////////////////////////////////
//strchr()函数返回一个指向str中ch首次出现的位置，当没有在str中找ch时返回NULL。
char *strchr1(char *src, char ch )
{ while((*src!=ch)&&(*src))
src++; return (src); }
////////////////////////////////////////////////////////////////////////////////
//chrcnt(), 计算某个字符在字符串中出现的次数.
int chrcnt1(const char *src,char ch)
{
int count=0;
while(*src)
if(*src==ch)
count++;
return count;
}
/////////////////////////////////////////////////////////////////////////
//该函数返回一个指向str中第一个匹配的group中任何一个字符的字符位置.若无则返回空(NULL).
char *strpbk(char const *s,char const *accpet)
{
while(*s != '\0')
{
while(*accpet != '\0')
if(*accpet++ == *s)
return (char *)s;
++s;
}
return NULL;
}
////////////////////////////////////////////////////////////////////////////////
//字符串复制
char *strcpy1(char *Dest,const char *source)
{
char *srcDest=Dest;//保存目标字符串的首地址
/*
while( *source !='\0')
*Dest++ = *source++;
*Dest = '\0'; //写法1
*/
while((*Dest++=*source++)!='\0');
return srcDest;
}
/////////////////////////////////////////////////////////////////////////
//指定长度的字符串复制
char *strncpy1(char *Dest,const char *source,int len)
{
char *srcDest=Dest;//保存目标字符串的首地址
while( *source !='\0' && len--)
*Dest++ = *source++;
*Dest = '\0'; return srcDest;
}
////////////////////////////////////////////////////////////////////////////
//内存复制的实现拷贝不重叠的内存块 void* memcpy1(void* dst,const void* src,size_t count)
{
char* pbTo = (char*)dst;
char* pbFrom = (char*)src;
assert(dst!= NULL && src != NULL);//不能存在空指针
assert(pbTo >= pbFrom+count || pbFrom >= pbTo + count);//防止内存重叠(overlap)
while (count-- > 0)
{
*pbTo++ = *pbFrom++;
}
return dst;
} //////////////////////////////////////////////////////////////////////////
//memmove实现移动一块字节，src源数据可以不保留
void* memmove1(void* dst,const void* src,size_t count)
{
char* pbTo = (char*)dst;
char* pbFrom = (char*)src;
assert(dst != NULL && src != NULL);//不能存在空指针
if (dst <= src || pbTo >= pbFrom + count)//没有overlap的情况，直接拷贝
{
while (count-- > 0)
{
*pbTo++ = *pbFrom++;
}
}
else
{
pbTo = pbTo + count -1;//overlap的情况，从高位地址向低位拷贝
pbFrom = pbFrom + count -1;
while (count-- > 0)
{
*pbTo-- = *pbFrom--;
}
}
return dst;
}
/////////////////////////////////////////////////////////////////
//memset:把buffer所指内存区域的前count个字节设置成字符c
void * Memset(void* buffer, int c, int count)
{
char* pvTo=(char*)buffer;
assert(buffer != NULL);
while(count-->0)
*pvTo++=(char)c;
return buffer;
}
/////////////////////////////////////////////////////////////////////////////
//字符串比较strcmp库函数的实现
int strcmp1(const char *src,const char *dst)
{
int ret;
while (!(ret=*(unsigned char *)src-*(unsigned char *)dst)&& *dst)//循环比较两个字符是否相等
{
++src;
++dst;
}
if(ret<0) ret=-1;
else
if(ret>0) ret=1;
return (ret);
}
/////////////////////////////////////////////////////////////////////////
//连接两个字符串strcat库函数的实现
char *strcat1(char *dest,const char *src)
{
char *temp = dest;
while (*dest != '\0')
dest++;
while((*dest++ = *src++) != '\0');
return temp;
}
////////////////////////////////////////////////////////////////////////////
////连接两个字符串的指定个数strncat库函数的实现
char *strncat1(char *dest, const char* src,int num)
{
char *temp = dest;
while (*dest != '\0')
dest++;
while((*dest++ = *src++) != '\0' && num--);
return temp;
}
////////////////////////////////////////////////////////////////////////////
//字符串的排序与交换 冒泡。。
void sort1(char *src,int num)
{
int i,j;
int tmp=0;
for (i=0;i<num;i++)
{
for (j=i+1;j<num;j++)
{
tmp=src[i];
src[i]=src[j];
src[j]=tmp;
}
}
}
//////////////////////////////////////////////////////////////////////////
//字符串的反转
char *strrv1(const char *str)
{
int i;
int len=strlen(str);
char c;
char *tmp=new char[len+1]; strcpy(tmp,str);
for(i=0;i<len/2;++i)
{
c=tmp[i];
tmp[i]=tmp[len-i-1];
tmp[len-i-1]=c;
}
return tmp;
}
//指针实现
char *strrv2(const char *str)
{
char c;
char *tmp=new char[strlen(str)+1];
strcpy(tmp,str); char *ret=tmp;
char *p=tmp+strlen(str)-1;
while (p>tmp)
{
c=*tmp;
*tmp=*p;
*p=c;
--p;
++tmp;
}
return ret;
}
//递归实现
char *strrv3(char *str,int len)
{
if (len<=1)
return str;
char t=*str;
*str=*(str+len-1);
*(str+len-1)=t; return (strrv3(str+1,len-2)-1); }
///////////////////////////////////////////////////////////////////////
//反转abcdefgh 但不改变单词的内部结构
void revstr(char *src)
{
char *start=src,*end=src,*ptr=src;
while (*ptr++ !='\0')
{
if (*ptr==' '|| *ptr=='\0')
{
end=ptr-1;//end指向单词末尾
while(start<end)
swap(*start++,*end--);//把单词的字母逆置
start=end=ptr+1;//指向下一个单词的开头
}
} start=src,end=ptr-2;//start指向开头，end指向末尾
while (start<end)
{
swap(*start++,*end--);//把整个字符串逆置
} }
//////////////////////////////////////////////////////////////////////
//判断是否为回文level
int isRevstr(char *str)
{
int i,len;
int found=1;
if (str==NULL)
{
return -1;
}
len=strlen(str);
for (i=0;i<len/2;i++)
{
if(*(str+i)!=*(str+len-i-1))
{
found=0;
break;
}
}
return found;
}
/////////////////////////////////////////////////////////////////////////
//字符串循环右移
void loopMove(char *src,int n)
{
int i=0;
char *tmp=NULL;
int strlen=0;
char *head=src;
while (*src++)
strlen=src-head-1;
n=n%strlen;
tmp=(char*)malloc(n);
for (i=strlen-1;i<n;i++)
{
tmp[i]=head[strlen-n+i];
}
for (i=strlen-1;i>=n;i--)
{
head[i]=hean[i-n];
}
for (i=0;i<n;i++)
{
head[i]=tmp[i];
}
free(tmp);
}
////////////////////////////////////////////////////////////////////////
//字符串右移 （不使用库函数实现）
char *loopmove(char *str, int num)
{
char temp[100]="";
int i = 0;
int len = 0;
//求长度
for(i=0;str[i]!=0;i++)
len++;
//保存最后num个字符
for(i=0;i<num;i++)
{
temp[i] = str[len-num+i];
}
//将前 len-num个字符向后移动num个字节
for(i=0;i<len-num;i++)
{
str[len-1-i] = str[len-1-i-num] ;
}
//将保存的后num个字符放在str最前面
for(i=0;i<num;i++)
{
str[i] = temp[i];
}
return str;
}
相关阅读 更多 +
