实现C++标准库string类的简单版本

　　代码如下：

 #ifndef STRING_H
 #define STRING_H

 #include <cassert>
 #include <utility>
 #include <iostream>

 namespace jz
 {

     /************************************************************************/
     /* 重新实现C风格字符串处理函数                                          */
     /************************************************************************/

     //求C风格字符串长度
     size_t StrLen(const char *str)
     {
         assert(str != nullptr);
         size_t len = ;
         while (*str++ != '\0')
         {
             ++len;
         }
         return len;
     }

     //复制C风格字符串
     char* StrCpy(char *dest, const char *src)
     {
         assert(dest != nullptr && src != nullptr);
         char *temp = dest;
         while ((*temp++ = *src++) != '\0');
         return dest;
     }

     //复制指定长度字符串
     char* StrNCpy(char *dest, const char *src, size_t n)
     {
         assert(dest != nullptr && src != nullptr);
         char *temp = dest;
         while (n-- && (*temp++ = *src++) != '\0');
         if (*temp != '\0')
         {
             *temp = '\0';
         }
         return dest;
     }

     //拼接字符串
     char* StrCat(char *dest, const char *src)
     {
         assert(dest != nullptr && src != nullptr);
         char *temp = dest;
         while (*temp != '\0')
         {
             ++temp;
         }
         while ((*temp++ = *src++) != '\0');
         return dest;
     }

     //比较字符串
     int StrCmp(const char *lhs, const char *rhs)
     {
         assert(lhs != nullptr && rhs != nullptr);
         int ret = ;
         while (!(ret = *lhs - *rhs) && *rhs)
         {
             ++lhs;
             ++rhs;
         }
         if (ret > )
         {
             return ;
         }
         else if (ret < )
         {
             return -;
         }
         else
         {
             return ;
         }
     }

     /************************************************************************/
     /* 实现标准库String类                                                   */
     /************************************************************************/
     class String
     {
         //重载==运算符
         friend bool operator==(const String &lhs, const String &rhs)
         {
             if (StrCmp(lhs.str, rhs.str) == )
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }

         //重载!=运算符
         friend bool operator!=(const String &lhs, const String &rhs)
         {
             return !(lhs == rhs);
         }

         //重载+运算符
         friend String operator+(const String &lhs, const String &rhs)
         {
             String temp;
             delete[] temp.str;
             temp.str = new char[lhs.Size() + rhs.Size() + ];
             StrCpy(temp.str, lhs.CStr());
             StrCat(temp.str, rhs.CStr());
             return temp;
         }

         //重载<<运算符
         friend std::ostream& operator<<(std::ostream &os, const String &rhs)
         {
             os << rhs.str;
             return os;
         }

     public:
         //默认构造函数
         String() : str(new char[])
         {
             *str = '\0';
         }

         //C风格字符串作为参数的构造函数
         String(const char *cstr) : str(new char[StrLen(cstr) + ])
         {
             StrCpy(str, cstr);
         }

         //拷贝构造函数(委托构造函数)
         String(const String &rhs) : String(rhs.str)
         {

         }

         //拷贝赋值运算符,使用传值参数,保证异常安全并可自我赋值
         String& operator=(String rhs)
         {
             Swap(rhs);
             return *this;
         }

         //析构函数
         ~String()
         {
             delete[] str;
         }

         //重载+=运算符
         String& operator+=(const String &rhs)
         {
             *this = *this + rhs;
             return *this;
         }

         //重载[]运算符
         char& operator[](size_t i)
         {
             assert(i >=  && i <= StrLen(str));
             return str[i];
         }

         //求字符串长度
         size_t Size() const
         {
             return StrLen(str);
         }

         //返回C风格字符串
         const char* CStr() const
         {
             return str;
         }

         //交换
         void Swap(String &rhs)
         {
             std::swap(str, rhs.str);
         }

     private:
         char *str;
     };

 }

 #endif