字符串操作类

//字符串的拷贝

char* Strcpy(char* strDest, const char* strSrc) {

    if(strDest== NULL || strSrc == NULL) {

        returnNULL;

    }

    if(strDest== strSrc) {

        returnstrDest;

    }

    char*strTemp = strDest;

   while((*strDest++ = *strSrc++) != '\0');

    returnstrTemp;

}

//内存拷贝

void* Memcpy(void* dest, void* src, size_t count)

{

   if(dest ==NULL || src == NULL) {

       returnNULL;

   }

   if(dest ==src) {

       returndest;

   }

   char* cdest =(char*)dest;

   char* csrc =(char*)src;

//关键，防止拷贝覆盖

   if((csrc <cdest) && (csrc+count > cdest)) {

      while(count--)

          cdest[count] = csrc[count];

   } else {

      while(count--)

          *cdest++ = *csrc++;

   }

   return dest;

}

 

//字符串反转

char* reverse_self(char* str, int n) {

    if(str ==NULL)

        returnNULL;

    int low = 0;

    int high =n-1;

    char ch;

    while(low< high) {

        ch =str[low];

        str[low]= str[high];

       str[high] = ch;

        ++low;

        --high;

    }

    return str;

}

 

//按单词逆序

char* reverse_by_word(char* str, int n) {

    if(str ==NULL)

        returnNULL;

    str =reverse_self(str, n);

    char* p =str;

    int cnt = 0;

    while(*p) {

        if(*p !=' ')

           ++cnt;

        ++p;

       if((*p == ' ' || *p ==NULL) && cnt > 1) {

           reverse_self(p-cnt, cnt);

            cnt= 0;

        }

    }

    return str;

}

 

 

 

//整数转化成字符串

char* num_to_str(int num, char* str, int size) {

    int cnt = 1;

    int temp =num/10;

    while(temp){

        temp /=10;

        ++cnt;

    }

    if(num <0) {

        temp =-num;

        ++cnt;

    }

    if(size <cnt+1) {

        returnNULL;

    }

    if(num <0) {

        num =-num;

        str[0] ='-';

    }

    str[cnt] ='\0';

    while(num) {

       str[--cnt] = '0' + num%10;

        num /=10;

    }

    return str;

}

 

 

//String构造函数

String::String(const char *str)

{

if(str == NULL)//strlen在参数为NULL时会抛异常才会有这步判断

{

m_data = new char[1];

m_data[0] = '\0' ;

} else {

m_data = newchar[strlen(str) + 1];

strcpy(m_data,str);

}

}

//拷贝构造函数

String::String(const String &another)

{

m_data = newchar[strlen(another.m_data) + 1];

strcpy(m_data,other.m_data);

}

//赋值操作符

String& String::operator =(const String &rhs)

{

if ( this ==&rhs)//判断自我赋值

return *this ;

delete []m_data; //删除原来的数据，新开一块内存

m_data = newchar[strlen(rhs.m_data) + 1];

strcpy(m_data,rhs.m_data);

return *this ;

}

 

 

/* 在母串中查找子串出现次数的代码。*str：母字符串；*s：子字符串*/

int count(char*str,char* s)

{

char* s1;

char* s2;

int count = 0;

while( *str !='\0' )

{

s1 = str;

s2 = s;

while( ( *s2 ==*s1 ) && ( *s2 != '\0' ) && ( *s1 != '\0' ) )

{

s2++;

s1++;

}

if( *s2 == '\0')

count++;

str++;

}

return count;

}

给定字符串A和B,输出A和B中的最大公共子串。
比如A=”aocdfe” B=”pmcdfa” 则输出”cdf”
*/
//Author: azhen
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char *commanstring(char shortstring[], char longstring[])
{
int i, j;
char *substring=malloc(256);
if(strstr(longstring, shortstring)!=NULL)              //如果……，那么返回shortstring
return shortstring;
for(i=strlen(shortstring)-1;i>0; i–)                 //否则，开始循环计算
{
for(j=0; j<=strlen(shortstring)-i; j++){
memcpy(substring, &shortstring[j], i);
substring[i]=’\0′;
if(strstr(longstring, substring)!=NULL)
return substring;
}
}
return NULL;
}

main()
{
char *str1=malloc(256);
char *str2=malloc(256);
char *comman=NULL;
gets(str1);
gets(str2);
if(strlen(str1)>strlen(str2))                         //将短的字符串放前面
comman=commanstring(str2, str1);
else
comman=commanstring(str1, str2);
printf(“the longest comman string is: %s\n”, comman);
}