C++反复遗忘--自定义String类

1. 在学习C++诡异的语法的时候，由于没有正式的使用C++作为工作使用的语言，所以经常遗忘，这就需要反复的学习。而C++的友元函数和运算符重载如果不经常使用，真的很容易忘记。

#include <iostream>
#include <cstring>

using namespace std;

class String
{
public:
    ~String();
    String();                  //无参
    String(const char *s);     //有参
    String(const String &obj); //拷贝

    String &operator=(const String &obj);
    String &operator=(const char *s);

    friend String operator+(const String &obj1, const String &obj2); // str1 + str2 全局函数实现（友元函数实现），也可以使用成员函数实现

    friend ostream &operator<<(ostream &out, const String &obj);
    friend istream &operator>>(istream &in, const String &obj);

    String &operator+=(const String &obj); //str1+=str2
    String &operator+=(const char *s);

    char &operator[](const int idx) const; //返回引用，可以利用下标修改内容

private:
    char *_arr;
    unsigned int _len;
};
String::~String()
{
    delete _arr;
    _arr = NULL;
}
String::String()
{
    cout << "String()" << endl;
    _len = 0;
    _arr = new char[1];
}
String::String(const char *s)
{
    cout << "String(const char *s)" << endl;
    _len = strlen(s);
    _arr = new char[_len + 1];
    strcpy(_arr, s);
}
String::String(const String &obj)
{
    cout << "String(const String &obj)" << endl;
    _len = obj._len;
    _arr = new char[_len + 1];
    strcpy(_arr, obj._arr);
}
String &String::operator=(const String &obj)
{
    cout << "operator=(const String&)" << endl;
    delete _arr;
    _len = obj._len;
    _arr = new char[_len + 1];
    strcpy(_arr, obj._arr);
    return *this;
}
String &String::operator=(const char *s)
{
    cout << "oeprator=(const char*)" << endl;
    delete _arr;
    _len = strlen(s);
    _arr = new char[_len + 1];
    strcpy(_arr, s);
    return *this;
}
String operator+(const String &obj1, const String &obj2)
{
    cout << "operator+(const String &, const String&)" << endl;
    String s;
    s._len = obj1._len + obj2._len;
    s._arr = new char[s._len + 1];
    strcpy(s._arr, obj1._arr);
    strcat(s._arr, obj2._arr);
    return s;
}
ostream &operator<<(ostream &out, const String &obj)
{
    cout << "operator<<(ostream&, const String &obj)" << endl;
    out << obj._arr;
    return out;
}
istream &operator>>(istream &in, const String &obj)
{
    cout << "operator>>(istream&, const String &obj)" << endl;
    in >> obj._arr;
    return in;
}
String &String::operator+=(const String &obj)
{
    cout << "operator+=(const String &obj)" << endl;
    char *temp = _arr;
    _len += obj._len;
    _arr = new char[_len + 1];
    strcpy(_arr, temp);
    strcat(_arr, obj._arr);
    delete temp;
    return *this;
}
String &String::operator+=(const char *s)
{
    cout << "operator+=(const char *s)" << endl;
    char *temp = _arr;
    _len += strlen(s);
    _arr = new char[_len + 1];
    strcpy(_arr, temp);
    strcat(_arr, s);
    delete temp;
    return *this;
}
char &String::operator[](const int idx) const
{
    cout << "operator[]" << endl;
    return _arr[idx];
}

int main()
{
    String s0;
    String s1("hello");
    String s2(s1);
    String s3 = s2;      //执行拷贝构造，类似于 String s2(s1)
    String s4 = "world"; //执行有参构造，类似于 String s1("hello")

    s0 = s3;     //执行operator=(const String &)
    s0 = "good"; //执行operator=(const char*)

    String s5 = s1 + s4;
    s5 = s1 + s4;       //执行operator+ 、String()、operator= 三个函数
    cout << s5 << endl; //输出 helloworld
    s5 += s1;
    cout << s5 << endl; //输出 helloworldhello
    s5 += "world";
    cout << s5 << endl; //输出 helloworldhelloworld
    char c0 = s5[0];
    cout << c0 << endl; //输出 h
    s5[0] = 'x';
    cout << s5 << endl; //输出 xelloworldhelloworld
    cin >> s5;          //输入 hahaha
    cout << s5 << endl; //输出 hahaha

    return 0;
}

对应以上代码的输出：

oop % ./String
String()
String(const char *s)
String(const String &obj)
String(const String &obj)
String(const char *s)
operator=(const String&)
oeprator=(const char*)
operator+(const String &, const String&)
String()
operator+(const String &, const String&)
String()
operator=(const String&)
operator<<(ostream&, const String &obj)
helloworld
operator+=(const String &obj)
operator<<(ostream&, const String &obj)
helloworldhello
operator+=(const char *s)
operator<<(ostream&, const String &obj)
helloworldhelloworld
operator[]
h
operator[]
operator<<(ostream&, const String &obj)
xelloworldhelloworld
operator>>(istream&, const String &obj)
hahaha               #此行为输入
operator<<(ostream&, const String &obj)
hahaha
oop % 

需要强调的是，运算符重载中有一个非常特殊的存在，那就是‘=’，它和拷贝构造函数有一定的功能重叠。当仅定义其中一个时（比如，只定义拷贝构造），使用‘=’运算符时同样不会报错，这是因为编译器对函数调用做了隐式转换。我的理解是，在不能完全肯定不会出错的情况下，要么就把各种情况下的函数都定义一遍，尽量不让编译器做出隐式转换，或者使用explicit关键字组织此类隐式转换。

最后，你的每一句留言都让博主欣喜若狂。