笔试算法题（04）：实现 string & memcpy & strcpy & strlen

出题：请实现给定String的类定义；

分析：注意检查标准类构造注意事项；

解题：

#include <stdio.h>
#include <string.h>
/**
 * 检查是否需要构造函数
 * 检查是否需要无参构造函数
 * 检查是否需要成员变量（函数）私有
 * 检查是否需要在构造函数预初始化成员变量
 * 检查是否需要析构函数
 * 检查是否需要虚拟析构函数
 * 检查是否需要复制构造函数（参数为const）
 * 检查是否需要赋值重载函数（参数为const）
 *
 * */
class MyString {
public:
        MyString(const char *str=NULL);//普通和无参构造函数
        MyString(const MyString&);//拷贝构造函数
        ~MyString();//析构函数
        MyString& operator=(const MyString&);//重载操作符函数
private:
        char *m_data;
};
MyString::MyString(const char *str) {
        if(str==NULL) {
                m_data=new char[1];
                *m_data=" ";
        } else {
                int length=strlen(str);
                m_data=new char[length+1];//需要为预留空间
                strcpy(m_data, str);
        }
}
MyString::MyString(const MyString& other) {
        int length=strlen(other.m_data);
        strcpy(m_data, other.m_data);
}
MyString::~MyString() {
        delete [] m_data;
}
MyString& MyString::operator=(const MyString& other) {
        if(this==&other) {//需要判断是否为对象本身，否则可能double deletion
                return *this;
        }
        delete [] m_data;
        int length=strlen(other.m_data);
        m_data=new char[length+1];
        strcpy(m_data, other.m_data);
        return *this;
}

出题：写一个函数，完成内存之间的复制（注意完整性）；

分析：当dest的起始位置在src到src+count之间时，dest会覆盖掉src后面的内存，所以应该使用倒序复制；

解题：

/**
 * 内存中字符串有五种相对位置，两种重叠的情况需要考虑内存破坏问题
 * 1
 * ****
 *         ****
 * 2
 * ****
 *   ****
 * 3
 * ****
 * ****
 * 4
 *    ****
 * ****
 * 5
 *          ****
 * ****
 * */
void* MyMemoryCopy(void *dest, const void *src, size_t count) {
        if（dest==NULL && src==NULL） return NULL;

        char *pdest=static_cast(src);
        const char *psrc=static_cast(src);
        //字符串在内存中的存储方向是由低地址往高地址方向
        if(pdest>psrc && pdest<psrc+count) {
                for(size_t i=count;i!=-1;i--) {
                        pdest[i]=psrc[i];//逆序拷贝
                }
        } else {
                for(size_t i=0;i<count;i++) {
                        pdest[i]=psrc[i];//顺序拷贝
                }
        }
        return dest;
}

出题：正确的strcpy的实现；

分析：返回值为char *，为了形成链式表达式；

解题：

char *strcpy(char *strDest, const char *strSrc)
{
        assert((strDest!=NULL)&&(strSrc!=NULL));
        strSrc=const_cast<char *>(strScr);
        char *address=strDest;
        while((*strDest++=*strSrc++)!='')
        return address;
}
10. 正确的strcmp的实现
int strcmp(const char *str1,const char *str2)
{
        assert(str1!=NULL && str2!=NULL);
        int ret=0;
        while(!(ret=*(unsigned char *)str1 - *(unsigned char *)str2) &&
                *str2)
        {
                str1++;
                str2++;
        }
        return ret;
}

出题：正确的strlen的实现；

分析：Strlen可以计算以结尾的字符串的长度，长度包括除以外的所有字符，sizeof也能计算字符串的程度，但是它的结果包含了终止字符；

解题：

int strlen(const char *str)
{
        assert(str!=NULL);
        int len;
        while((*str++)!='')
        {
                len++;
        }
        return len;
}