（1.2.3.1）字符串常见算法

已知strcpy函数的原型是：

char *strcpy(char *dst, const char *src);

1. 实现strcpy函数
2. 解释为什么要返回char *
3. 假如考虑dst和src内存重叠的情况，strcpy该怎么实现

 

1.strcpy的实现代码

char * strcpy(char *dst,const char *src)   //[1]
{
    assert(dst != NULL && src != NULL);    //[2]

    char *ret = dst;  //[3]

    while ((*dst++=*src++)!='\0'); //[4]

    return ret;
}

[1]const修饰

源字符串参数用const修饰，防止修改源字符串。

[2]空指针检查

(A)不检查指针的有效性，说明答题者不注重代码的健壮性。

(B)检查指针的有效性时使用assert(!dst && !src);

char *转换为bool即是类型隐式转换，这种功能虽然灵活，但更多的是导致出错概率增大和维护成本升高。

(C)检查指针的有效性时使用assert(dst != 0 && src != 0);

直接使用常量（如本例中的0）会减少程序的可维护性。而使用NULL代替0，如果出现拼写错误，编译器就会检查出来。

[3]返回目标地址

(A)忘记保存原始的strdstt值。

[4]'\0'

(A)循环写成while (*dst++=*src++);明显是错误的。

(B)循环写成while (*src!='\0') *dst++=*src++;

循环体结束后，dst字符串的末尾没有正确地加上'\0'。

 

2.为什么要返回char *？

返回dst的原始值使函数能够支持链式表达式。

链式表达式的形式如：

int l=strlen(strcpy(strA,strB));

又如：

char * strA=strcpy(new char[10],strB);

返回strSrc的原始值是错误的。

其一，源字符串肯定是已知的，返回它没有意义。

其二，不能支持形如第二例的表达式。

其三，把const char *作为char *返回，类型不符，编译报错。

 

3.假如考虑dst和src内存重叠的情况，strcpy该怎么实现

char s[10]="hello";

strcpy(s, s+1); //应返回ello，

//strcpy(s+1, s); //应返回hhello，但实际会报错，因为dst与src重叠了，把'\0'覆盖了

所谓重叠，就是src未处理的部分已经被dst给覆盖了，只有一种情况：src<=dst<=src+strlen(src)

C函数memcpy自带内存重叠检测功能，下面给出memcpy的实现my_memcpy。

char * strcpy(char *dst,const char *src)
{
    assert(dst != NULL && src != NULL);

    char *ret = dst;

    my_memcpy(dst, src, strlen(src)+1);

    return ret;
}

my_memcpy的实现如下

char *my_memcpy(char *dst, const char* src, int cnt)
{
    assert(dst != NULL && src != NULL);

    char *ret = dst; 

    if (dst >= src && dst <= src+cnt-1) //内存重叠，从高地址开始复制
    {
        dst = dst+cnt-1;
        src = src+cnt-1;
        while (cnt--)
            *dst-- = *src--;
    }
    else    //正常情况，从低地址开始复制
    {
        while (cnt--)
            *dst++ = *src++;
    }
    
    return ret;
}

4、字符串替换空格

题目：请实现一个函数，把字符串中的每个空格替换成“%20”。例如输入“We are happy.”，则输出“We%20are%20happy.”

4.1 重新重建一个数组地址，遍历旧地址拷贝过去。O(N)

4.2 原地替换

如果从前往后替换字符串，那么保存在空格后面的字符串肯定会被覆盖，那么我们就考虑从后往前进行替换。
   
   
首先遍历原字符串，找出字符串的长度以及其中的空格数量，
根据原字符串的长度和空格的数量我们可以求出最后新字符串的长度。
设置两个指针point1和point2分别指向原字符串和新字符串的末尾位置。
如果point1指向内容不为空格，那么将内容赋值给point2指向的位置，如果point1指向为空格，那么从point2开始赋值“02%”
直到point1==point2时表明字符串中的所有空格都已经替换完毕。

1.2代码实例
   
   

    
    

     
     

      
      
 
          

            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 
          
 
          
 
           
 
            #include<iostream> 
           
 
           
 
            #include<stdio.h> 
           
 
           
 
            using  
            namespace  
            std; 
           
 
           
 
            //length为字符串总容量 
           
 
           
 
            void  
            replacespace( 
            char  
            string[],  
            int  
            length) { 
           
 
           
 
                 
            int  
            blanknumber = 0; 
           
 
           
 
                 
            int  
            i; 
           
 
           
 
                 
            for  
            (i = 0; string[i] !=  
            '\0' 
            ; i++) { 
           
 
           
 
                     
            if  
            (string[i] ==  
            ' ' 
            ) { 
           
 
           
 
                         
            blanknumber++; 
           
 
           
 
                     
            } 
           
 
           
 
                 
            } 
           
 
           
 
                 
            int  
            k = i + 2 * blanknumber; 
           
 
           
 
                 
            if  
            (k > length) 
           
 
           
 
                     
            return 
            ; 
           
 
           
 
                 
            string[k]= 
            '\0' 
            ; 
            //此行必不可少 
           
 
           
 
                 
            int  
            point1 = i - 1, point2 = k-1; 
           
 
           
 
                 
            for  
            (; point1 >= 0 && point2 > point1; point1--) { 
           
 
           
 
                     
            if  
            (string[point1] ==  
            ' ' 
            ) { 
           
 
           
 
                         
            string[point2--] =  
            '0' 
            ; 
           
 
           
 
                         
            string[point2--] =  
            '2' 
            ; 
           
 
           
 
                         
            string[point2--] =  
            '%' 
            ; 
           
 
           
 
                     
            }  
            else 
           
 
           
 
                         
            string[point2--] = string[point1]; 
           
 
           
 
                 
            } 
           
 
           
 
            } 
           
 
           
 
            int  
            main() { 
           
 
           
 
                 
            char  
            *string= 
            new  
            char 
            [50]; 
           
 
           
 
                 
            while  
            ( 
            gets 
            (string)) { 
           
 
           
 
                     
            replacespace(string, 50); 
           
 
           
 
                     
            puts 
            (string); 
           
 
           
 
                 
            } 
           
 
           
 
                 
            return  
            0; 
           
 
           
 
            }