字符串处理函数（不使用库函数实现）

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 {
  for (j=i+1;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 {
  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    swap(*start++,*end--);//把单词的字母逆置
   start=end=ptr+1;//指向下一个单词的开头
  }
 }

 start=src,end=ptr-2;//start指向开头，end指向末尾
 while (start {
  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 {
  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 {
  tmp[i]=head[strlen-n+i];
 }
 for (i=strlen-1;i>=n;i--)
 {
  head[i]=hean[i-n];
 }
 for (i=0;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 {
  temp[i] = str[len-num+i];
 }
 
 //将前 len-num个字符向后移动num个字节
 for(i=0;i {
  str[len-1-i] = str[len-1-i-num] ;
 }
 //将保存的后num个字符放在str最前面
 for(i=0;i {
  str[i] = temp[i];
 }
 return str;
}