MyString类的实现--基础中的基础C语言

MyString 类是学习 C++ 的过程中一个很重要的例子，涉及到面向对象的封装、堆内存申请和释放、函数的重载以及 C++ 的 “Big Three”。本例子重点在于复习和理解上述的 C++ 特性，实现的功能并不多。

MyString 的声明中包含了一个带指针的 C++ 类应有的函数，并且包含了一些常用的功能。其中终点讨论一下用 friend 关键字修饰的两个函数，它们是用来提供 ostream 的输出的。声明为 friend 是为了使 ostream 的对象（例如 cout）可以访问到 MyString 的成员。而这两个函数不声明为内部方法的原因是我们一般写输入输出语句都是将流对象写在前，如果声明成了成员函数则调用的时候要写成这样：

MyString str;
str.operator<<(cout);

这看起来相当怪异，所以我们希望写成 cout << str 这样。这句实际上就是 cout 对象调用重载的运算符，也可以写在实例化 cout 对象的类 ostream 里，但是 ostream 一般来说我们并不会去改动这个文件，所以写了一个全局函数来将 ostream 和 MyString 联系起来。

class MyString {
    friend std::ostream &operator<<(std::ostream &os, const MyString &str);
    friend std::ostream &operator>>(std::ostream &os, MyString &str);
public:
    MyString(const char *cstr = nullptr);
    // Big Three
    MyString(const MyString &str);
    MyString &operator=(const MyString &str);
    ~MyString();

    char *get_c_str() const { return m_data; }

    // operator reload
    MyString &operator+(const MyString &str);
    bool operator==(const MyString &str);

    size_t length() const;
private:
    char *m_data;
};

C++ 的构造函数和 Big Three

C++ 的 Big Three 包括拷贝赋值、拷贝构造和析构函数。Big Three 主要针对带有指针的类，类中的指针一般指向类所管理的一些资源，可能是该类自己申请的内存或者创建的某种对象。类维护着这些资源，负责它们的生老病死——资源的创建、使用和销毁。

一个类中如果带有着指针，那么必须要自己重写有拷贝构造和拷贝赋值函数。如果不自己重写，那么会采取默认的行为，即逐位拷贝。采取逐位拷贝的对象内部的指针也被拷贝过去，称为浅拷贝。我们希望拷贝一个对象，其管理的资源也一并拷贝一份，称为深拷贝。为了实现深拷贝，重写的拷贝赋值、拷贝构造函数中应实现资源复制的行为。而在对象生命周期结束后，其管理的资源也应该关闭或者销毁，故也需要重写析构函数。

C++ 的这三个函数紧密地联系在了一起，具体体现为逻辑上如果需要重写其中任何一个函数，那么另外两个函数也应该被重写。

inline
MyString::MyString(const char *cstr = nullptr) {
    if (cstr) {
        m_data = new char[strlen(cstr) + 1];
        strcpy(m_data, cstr);
    }
    else {
        m_data = new char[1];
        *m_data = '';
    }
}

inline
MyString::~MyString() {
    delete[] m_data;
}

inline
MyString::MyString(const MyString &str) {
    m_data = new char[strlen(str.m_data) + 1];
    strcpy(m_data, str.m_data);
}

inline 
MyString &MyString::operator=(const MyString &str) {
    if (this == &str) return *this;
    delete[] m_data;
    m_data = nullptr;
    m_data = new char[strlen(str.m_data) + 1];
    strcpy(m_data, str.m_data);
    return *this;
}

在上面的实现中，有两个值得注意的地方，一个是在拷贝赋值运算符重载中的自赋值检查，在拷贝赋值运算符函数中，如果不进行检查，按照逻辑来说，会释放被赋值对象的资源，如果是同一个对象的自我赋值，则会产生严重的后果：字符串资源被删除，两个对象指向被回收了的内存，当访问这个字符串时会出现不可预料的后果。可见，防御式编程不仅要求程序对黑客行为的输入的那些很离谱的数据做防御，还要对用户可能出现的错误进行防御。

另外一个值得注意的地方就是重载的等于操作符，用户在使用的时候有时可能会对字符串连续赋值，就像使用 cout 连续输出一样，这种类似于函数的链式调用。实现的时候只要返回对象的引用就可以了。

输入输出运算符重载

除了链式调用需要返回对象引用的这个主意点外，输入输出函数的第二个参数的 const 属性也应该主意的。具体来说输出函数的第二个参数不会被改变，我们应该将它声明为 const 的；而输入函数的第二个对象正是我们希望改变的对象，希望将数据输入到这个对象中，它应该是非 const 引用。

std::ostream &operator<<(std::ostream &os, const MyString &str) {
    os << str.m_data;
    return os;
}

std::ostream &operator>>(std::ostream &os, MyString &str) {
    os >> str.m_data;
    return os;
}

至此一个非常简单的 C++ MyString 类已经实现完成了，在 STL 中，string 类的实现更加复杂，包括了正则在内的高级功能。这个例子仅仅为了学习 C++ 的一些特性，还不够深入，希望未来能专门研究一下 string 的实现。

--------------------- 本文来自 ProJ7-Jeffy 的CSDN 博客，全文地址请点击：https://blog.csdn.net/u013040821/article/details/80455108?utm_source=copy