模拟String类

#include<string.h>
#include<iostream>
using namespace std;

//普通版
class String
{
public:
    String()
        :_str(new char[1])
    {
        _str = '\0';
    }

    String(char* str = "")
        :_str(new char[strlen(str) + 1])
    {
        strcpy(_str, str);// \0 也拷贝了  
    }
    String(const String& s)//必须自己写，否则会  浅拷贝  
        :_str(new char[strlen(s._str) + 1])
    {

        strcpy(_str, s._str);

    }
    String& operator=(const String& s)
    {
        if (this != &s)
        {
            char *tmp = new char[strlen(s._str) + 1];
            delete[]  _str;
            strcpy(tmp, s._str);
            _str = tmp;
        }
        return *this;
    }
    \
        ~String()
    {
            if (_str != NULL)
                delete[] _str;  //free可以 free(NULL)  
        }

    char* C_str()
    {
        return _str;
    }
private:
    char* _str;
};





//简洁版 String  
class String
{
public:
    String(char * str = "")// 给缺省参数 ‘\0'  
        :_str(new char[strlen(str) + 1])
    {
        strcpy(_str, str);
    }
    String(const String& s)
        :_str(NULL)    //保证tmp能正确析构  
    {
        String tmp(s._str);   
        std::swap(_str, tmp._str);
    }
    String& operator=(const String & s)
    {
        if (this != &s)
        {
            String tmp(s._str);
            std::swap(_str, tmp._str);
        }
        return  *this;
    }

    /*赋值 运算符更简洁版
    String& operator=( String s)
    {
    std::swap(this->_str, s._str);
    return  *this;
    }
    */
    ~String()
    {
        delete[] _str;
    }
    char *Cstr()
    {
        return _str;
    }
    char& operator[](size_t index)//  重载[]  
    {  
        return _str[index];
    }

public:
    void PushBack(char ch)
    {

    }
private:
    char *_str;
};


//引用计数版String
class String
{
public:
    String(char* str = "")
        :_str(new char[strlen(str) + 1])
        , _prefCount(new int(1))
    {
        strcpy(_str, str);
    }

    String(String& s)  //没加 const  
        :_str(s._str)
        , _prefCount(s._prefCount)
    {
        ++*_prefCount;
        //++(*s._prefCount)  
    }

    String& operator=(String& s)
    {

        if (this != &s)
        {
            delete[] _str;
            _str = NULL;
            strcpy(_str, s._str);
            *_prefCount = ++*(s._prefCount);
        }
        return *this;
    }

    ~String()
    {
        if (!(-- *_prefCount))  //前置--  
        {
            delete[] _str;
            delete _prefCount;  //也要释放  
        }
    }

private:
    char *_str;
    int* _prefCount;  //引用计数  
};