【C++】CMyString的实现

面向对象的编程，首先得设计出良好的类体结构和接口，然后是合理的实现．

如何自己设计并实现一个字符串类？这个问题看似简单，其实里面也有不少的玄机．

class CMyString
{
public:
    CMyString(char* pStr = NULL);
    CMyString(const CMyString& rhs);
    CMyString& operator=(const CMyString& rhs);
    ~CMyString();
    .....    
private:
    char* pData;
    int len;        //当前字符串长度，不包括'\0'
};

CMyString类中包含指向动态分配内存的指针，因而需要自定义copying函数．

CMyString类中字符串长度表示当前字符串长度，不包括'\0'，在构造字符串时，保证字符串以'\0'结尾．

CMyString::CMyString(char *pStr = NULL)
{
    if(pStr == NULL)
    {
        pData = NULL;
        len = 0;
    }
    else
    {
        len = strlen(pStr);
        pData = (char*)malloc(sizeof(char) * (len + 1));
        memset(pData,'/0',sizeof(char) * (len + 1));
        strcpy(pData,pStr);
    }
}

CMyString::~CMyString()
{
    if(pData != NULL)
    {
        free(pData);
        pData = NULL;
        len = 0;
    }
}

以C语言函数为基础完成构造函数与析构函数．

copying函数的实现如下：

CMyString::CMyString(const CMyString &rhs)
{
    memcpy(this,&rhs,sizeof(CMyString);
}

CMyString& CMyString::operator=(const CMyString &rhs)
{
    CMyString *pStr;
    pStr = new CMyString(rhs);        //调用copy constructor
    return *pStr;
}

上述代码实现存在以下几个问题：

1.copy constructor实现过程，参用的是浅拷贝方式，新建的CMyString对象中的pData指针和rhs对象中的pData指针指向同一块内存区域．

2.operator=实现过程，是调用copy constructor创建一个新对象，并返回，将会丢失当前this指针所对应的对象，与operator=的含义不符．

operator＝是对已经存在的对象进行赋值，而不是重新创建一个对象．

正如<<Effective C++>>提到的，不应该以某个copying函数去实现另一个copying函数．应该将共同机能放进第三个函数中，并由两个copying函数共调用．

针对上述不合理的代码，进行修正，得到如下的代码：

CMyString::CMyString(const CMyString& rhs)
{
    if(rhs.pData == NULL)
    {
        pData = NULL;
        len = 0;
    }
    else
    {            
        pData = (char*)malloc(sizeof(char) * (rhs.len + 1));
        memset(pData,'/0',sizeof(char) * (rhs.len + 1));
        len = rhs.len;            //通过对象访问私有成员变量
        strcpy(pData,rhs.pData);
    }
}
CMyString& CMyString::operator=(const CMyString& rhs)
{
    if(this = &rhs)        //证同测试
        return *this;
    if(pData != NULL)    //*this不是空字符串
    {
        free(pData);    //释放实例自身已有内存
    }
    pData = (char*)malloc(sizeof(char) * (rhs.len + 1));
    memset(pData,'/0',sizeof(char) * (rhs.len + 1));
    len = rhs.len;            //通过对象访问私有成员变量
    strcpy(pData,rhs.pData);
}

经过修正后，解决了浅拷贝和当前this所指向对象丢失的问题，但这个实现仍不是异常安全的．

在operator=中，如果第24行分配内存失败，产生异常．此时当前的pData所指向内存已被释放，导致pData指向空指针．

此外，第12行代码中，为什么可以通过对象访问私有成员变量，其详细解释请参考：

http://www.cnblogs.com/dwdxdy/archive/2012/07/17/2595741.html

上述解决方法时，可以利用临时指针保存当前的pData，然后当完成赋值操作后，再根据临时指针释放原始pData所指的空间．

CMyString& CMyString::operator=(const CMyString& rhs)
{
    char* pOri = pData;                //保存原始指针
    pData = (char*)malloc(sizeof(char) * (rhs.len + 1));
    memset(pData,'/0',sizeof(char) * (rhs.len + 1));
    len = rhs.len;
    strcpy(pData,rhs.pData);
    free(pOri);                        //释放原始指针所指内存
    return *this;
}

这种实现，当前rhs和*this是同一个对象，也可以安全完成赋值操作．

参考资料：

Effective C++

http://www.cnblogs.com/xwdreamer/archive/2012/05/14/2500632.html

http://blog.csdn.net/zijinshi/article/details/111039

http://www.cnblogs.com/dwdxdy/archive/2012/07/17/2595821.html