笔试算法题（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[];
                 *m_data=" ";
         } else {
                 int length=strlen(str);
                 m_data=new char[length+];//需要为\0预留空间
                 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+];
         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!=-;i--) {
                         pdest[i]=psrc[i];//逆序拷贝
                 }
         } else {
                 for(size_t i=;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++)!='\0')
         return address;
 }
 . 正确的strcmp的实现
 int strcmp(const char *str1,const char *str2)
 {
         assert(str1!=NULL && str2!=NULL);
         int ret=;
         while(!(ret=*(unsigned char *)str1 - *(unsigned char *)str2) &&
                 *str2)
         {
                 str1++;
                 str2++;
         }
         return ret;
 }

出题：正确的strlen的实现；

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

解题：

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