String类的部分实现

#include <iostream.h>

#include <assert.h>

#include <ostream.h>

#include <string.h>

 

class MyString

{

public:

    MyString(const char *str = NULL); //默认构造函数

    virtual ~MyString(void);    //析构函数

    MyString(const MyString &other); //拷贝构造函数

    MyString & operator =(const MyString &other); //赋值运算符

    friend MyString operator +(const MyString &oneString, const MyString &twoString); //两对象连接

    MyString operator +(const char *str); //对象与字符串连接

    friend MyString operator +(const char *str, const MyString &cString); //字符串与对象连接

    friend ostream & operator <<(ostream &output, const MyString &cString); //重载流插入运算符

private:

    char *m_data; //数据成员，存储字符串首地址

};

 

int main()

{

    cout<<"测试结果："<<endl;

    MyString oneStr;

    cout<<"oneStr:"<<oneStr<<endl;

    MyString twoStr("world");

    cout<<"twoStr:"<<twoStr<<endl;

    MyString threeStr;

    threeStr = twoStr;

    cout<<"threeStr:"<<threeStr<<endl;

    MyString fourStr;

    fourStr = twoStr + threeStr;

    cout<<"fourStr:"<<fourStr<<endl;

    MyString fiveStr;

    fiveStr = twoStr + " !";

    cout<<"fiveStr:"<<fiveStr<<endl;

    MyString sixStr;

    sixStr = "Hello " + twoStr;

    cout<<"sixStr:"<<sixStr<<endl;

  

    return 0;

}

 

//构造函数

MyString::MyString(const char *str)

{

    if (NULL==str)

    {

        m_data = new char[1];

        m_data[0] = '/0';

    }

    else

    {

        int length = (int)strlen(str);

        m_data = new char[length+1];

        strcpy(m_data, str);

    }

}

 

//析构函数

MyString::~MyString(void)

{

    delete []m_data;

}

 

//拷贝构造函数

MyString::MyString(const MyString &other)

{

    assert(NULL != other.m_data);

    m_data = new char[strlen(other.m_data) + 1];

    strcpy(m_data, other.m_data);

}

 

//赋值运算符(=)重载

MyString & MyString::operator =(const MyString &other)

{

    assert(NULL != other.m_data);

    if (this == &other)

        return *this;

    delete []m_data;

    m_data = new char[strlen(other.m_data) + 1];

    strcpy(m_data, other.m_data);

    return *this;

}

 

//加号运算符(+)重载,连接两个MyString对象

MyString operator +(const MyString &oneString, const MyString &twoString)

{

    assert(NULL != oneString.m_data);

    assert(NULL != twoString.m_data);

    MyString catString;

    catString.m_data = new char[strlen(oneString.m_data) + strlen(twoString.m_data) + 1];

    strcpy(catString.m_data, oneString.m_data);

    strcat(catString.m_data, twoString.m_data);

    return catString;

}

 

//加号运算符(+)重载,连接一个MyString对象和一字符串

MyString MyString::operator +(const char *str)

{

    if (NULL==str)

    {

        return *this;

    }

    MyString catString;

    catString.m_data = new char[strlen(m_data) + strlen(str) + 1];

    strcpy(catString.m_data, m_data);

    strcat(catString.m_data, str);

    return catString;

}

 

//加号运算符(+)重载,连接一字符串和一个MyString对象

MyString operator +(const char *str, const MyString &cString)

{

    if (NULL==str)

    {

        return cString;

    }

    MyString catString;

    catString.m_data = new char[strlen(cString.m_data) + strlen(str) + 1];

    strcpy(catString.m_data, str);

    strcat(catString.m_data, cString.m_data);

    return catString;

 

}

 

//重载流插入运算符

ostream & operator <<(ostream &output, const MyString &cString)

{

    output<<cString.m_data;

    return output;

}