类的成员函数(构造、析构、拷贝构造、赋值、运算符重载)的实现

以String类为例实现其成员函数

class String
{
    //友元函数重载运算符
    friend ostream& operator<<(ostream &out,String& str);
    friend istream& operator>>(istream& in, String& str);
public:
    //通用构造函数
    String(const char* str)
    {
        if(!str)    //对m_data加NULL判断
        {
            length = 0;
            m_data = new char[1];   //对空字符串自动申请存放结束标志'\0'的空
            *m_data = '\0';
        }
        else
        {
            length = strlen(str);
            m_data = new char[length + 1];
            strcpy(m_data, str);
        }
    }
    //析构函数
    virtual ~String()
    {
        delete[] m_data;
    }

    //拷贝构造
    String(const String &str)   //输入参数为const型
    {
        length = str.length;
        m_data = new char[length+1];
        strcpy(m_data, str.m_data);
    }

    //赋值构造
    String& operator=(const String &str)    //输入参数为const型
    {
        if (this == &str)   //检查自赋值
            return *this;
        delete[] m_data;
        int length = strlen(str.m_data);
        m_data = new char[length + 1];
        strcpy(m_data, str.m_data);
        return *this;   //返回本对象的引用
    }

    //重载+
    String operator+(const String &str) const
    {
        String newString("");
        newString.length = length + strlen(str.m_data);
        newString.m_data = new char[newString.length + 1];
        strcpy(newString.m_data, m_data);
        strcat(newString.m_data, str.m_data);
        return newString;
    }

    //重载[]
    inline char& operator[](int n)
    {
        if (n > length)
            return m_data[length - 1];
        else
            return m_data[n];
    }

    //重载+=
    String& operator+=(const String& str)
    {
        length += str.length;
        char *newData = new char[length + 1];
        strcpy(newData,m_data);
        strcat(newData, str.m_data);
        delete[] m_data;
        m_data = newData;
        return *this;
    }

    //重载==
    inline bool operator==(const String& str) const
    {
        if (length != str.length)
            return false;
        return strcmp(m_data, str.m_data) ? false : true;
    }

    inline size_t size() const
    {
        return length;
    }

private:
    char* m_data;
    size_t length;
};

//为什么要重载为友元函数？
/*如果是双目运算符，只要设置一个参数作为右侧运算量,左侧运算符就是对象this本身
 *但是>>或<<左侧运算符是cin或cout而不是对象本身，只能声明为友元了
 *如果一定要声明为成员函数，只能声明为ostream & operator<<(ostream &output)
 *在运用这个<<运算符时就变为这种形式了：data<<cout;不合符人的习惯。
 */

ostream& operator<<(ostream& out,String& str)
{
    out << str.m_data;
    return out;
}

istream& operator>>(istream& in,String& str)
{
    char temp[1024];
    in >> temp;
    str.length = strlen(temp);
    str.m_data = new char[str.length + 1];
    strcpy(str.m_data, temp);
    return in;
}