实现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 = 0;
        while (*str++ != '')
        {
            ++len;
        }
        return len;
    }

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

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

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

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

    /************************************************************************/
    /* 实现标准库String类                                                   */
    /************************************************************************/
    class String
    {
        //重载==运算符
        friend bool operator==(const String &lhs, const String &rhs)
        {
            if (StrCmp(lhs.str, rhs.str) == 0)
            {
                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() + 1];
            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[1])
        {
            *str = '';
        }

        //C风格字符串作为参数的构造函数
        String(const char *cstr) : str(new char[StrLen(cstr) + 1])
        {
            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 >= 0 && 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