重载＜＜和＞＞

<<、>>可以重载为类的方法或全局函数

重载<<

hstring& hstring::operator<<(const hstring& hstr)
{
    unsigned short hstrlen = getlength(hstr.cstr);
    char* tempmem = cstr;
    if (hstrlen + uslen+2 > usmlen)
    {
        cstr = new char[hstrlen + uslen+2];
        memcpy(cstr, tempmem, uslen);
    }
    else
    {
        cstr = new char[0x32];
        memcpy(cstr, tempmem, uslen);
    }
    memcpy(cstr+uslen, hstr.cstr, hstrlen);
    cstr[uslen + hstrlen] = 0;
    uslen = uslen + hstrlen ;
    return *this;
}
hstring& hstring::operator+(const hstring& hstr)
{
    return *this << hstr;
}

void hstring::copystr(char*& dest, const char* source)
{
   unsigned short len = getlength(source);
    if (len > usmlen)
    {
        dest = new char[len+1];   //重新分配内存
        uslen = len;
    }
    else
    {
        uslen = len;
        dest = new char[usmlen]; 
    }
    memcpy(dest, source, len);
    dest[len] = 0;
}

这里重载了左移和加号运算符，这样我们就能实现字符串的连接了，但是这个代码有个缺陷，就是不支持连续的连接。即hstr1+"1234"+"321"

int main()
{
    char a_str[]{ "88888" };
    hstr1 = a_str;       
    hstr1 <<"777777";
    hstr1 + "666666";
    std::cout << hstr.getstr();
    system("pause");
}

但是原生的cout支持输出字符串类，而我们这里还要添加成员函数，不方便，于是我们重载<<,为什么不重载cout呢，因为cout本身就是一个类，无法重载，所以我们可以i重载cout后面的<<运算符

std::ostream& operator<< (std::ostream& _cout, hstring hstr)
{
    std::cout << hstr.getstr();
    return _cout;
}

cout的类型为ostream,所以返回值类型要用osteram,为什么一定要返回ostream呢

这就是链式编程，如果我们要cout<<hstr1<<hstr2，就要先cout<<hstr1，然后返回一个cout，返回一个cout后，再用这返回的cout<<hstr2。

如果重载为成员函数

std::ostream& operator<< (std::ostream& _cout)
{
    return _cout <<(*this).getstr();
}

 特别注意*：类的运算符重载如果写成成员函数，就只能有一个参数

 使用的时候就是hstr.operator<<(cout)呢，所以输出的时候应该这样写

hstr.operator<<( std::cout );
或者
hstr << std::cout;

重载>>

std::istream& operator>>(std::istream& _cin, hstring& hstr)
{
    char mem[0xff];
    _cin >> mem;
    hstr = mem;
    return _cin;
}

这里cin的类型为istream,hstr的参数类型为引用，是因为在函数内需要改变它的值

    std::cin >> hstr1;
    std::cout << hstr1<<std::endl;