MyString

【摘自C++程序设计语言】

MyString.h

#include <cstring>
#include <iostream>
#include <stdexcept>

#ifndef _MYSTRING
#define _MYSTRING

class MyString
{
public:
    MyString();
    MyString(const char* p);

    MyString(const MyString& x);
    MyString& operator=(const MyString& x);

    MyString(MyString&& x);
    MyString& operator=(MyString&& x);

    ~MyString()
    {
        if (short_max < sz)
            delete[] ptr;
    }

    char& operator[](int n) { return ptr[n]; }
    char operator[](int n) const { return ptr[n]; }

    char& at(int n) { check(n); return ptr[n]; }
    char at(int n) const { check(n); return ptr[n]; }

    MyString& operator+=(char c);

    const char* c_str() { return ptr; }
    const char* c_str() const { return ptr; }

    int size() const { return sz; }
    int capacity() const { return (sz <= short_max) ? short_max : sz + space; }
    
private:
    void check(int n) const
    {
        if (n < 0 || sz <= n)
            throw std::out_of_range("String::at()");
    }

    char* expand(const char* ptr, int n)
    {
        char* p = new char[n];
        strcpy(p, ptr);
        return p;
    }

    void copy_from(const MyString& x);
    void move_from(MyString& x);
private:
    static const int short_max = 15;
    unsigned int sz;
    char* ptr;
    union {
        int space;
        char ch[short_max+1];
    };
};

std::ostream& operator<<(std::ostream& os, const MyString& s);
std::istream& operator>>(std::istream& is, MyString& s);
bool operator==(const MyString& a, const MyString& b);
bool operator!=(const MyString& a, const MyString& b);
char* begin(MyString& x);
char* end(MyString& x);
const char* begin(const MyString& x);
const char* end(const MyString& x);
MyString& operator+=(MyString& a, const MyString& b);
MyString operator+(const MyString& a, const MyString b);

#endif

MyString.cpp

#include "MyString.h"
using namespace std;

MyString::MyString()
: sz{0}, ptr{ch}
{
    ch[0] = 0;
}

MyString::MyString(const char* p)
: sz{strlen(p)},
ptr{(sz <= short_max) ? ch : new char[sz + 1]},
space{0}
{
    strcpy(ptr, p);
}

MyString::MyString(const MyString& x)
{
    copy_from(x);
}

MyString& MyString::operator=(const MyString& x)
{
    if (this == &x)    return *this;

    char* p = (short_max < sz) ? ptr : 0;
    copy_from(x);
    delete[] p;
    return *this;
}

MyString::MyString(MyString&& x)
{
    move_from(x);
}

MyString& MyString::operator=(MyString&& x)
{
    if (this == &x) return *this;

    if (short_max < sz) delete[] ptr;
    move_from(x);
    return *this;
}

MyString& MyString::operator+=(char c)
{
    if (sz == short_max) {
        int n = sz + sz + 2;
        ptr = expand(ptr, n);
        space = n - sz - 2;
    }
    else if (short_max < sz) {
        if (space == 0) {
            int n = sz + sz + 2;
            char* p = expand(ptr, n);
            delete[] ptr;
            ptr = p;
            space = n - sz - 2;
        }
        else {
            --space;
        }
    }
    ptr[sz] = c;
    ptr[++sz] = 0;

    return *this;
}

void MyString::copy_from(const MyString& x)
{
    if (x.sz <= short_max) {
        memcpy(this, &x, sizeof(x));
        ptr = ch;
    }
    else {
        ptr = expand(x.ptr, sz + 1);
        sz = x.sz;
        space = 0;
    }
}

void MyString::move_from(MyString& x)
{
    if (x.sz <= short_max) {
        memcpy(this, &x, sizeof(x));
        ptr = ch;
    }
    else {
        ptr = x.ptr;
        sz = x.sz;
        space = x.space;
        x.ptr = x.ch;
        x.sz = 0;
        x.ch[0] = 0;
    }
}

ostream& operator<<(ostream& os, const MyString& s)
{
    os << s.c_str();
    return os;
}

istream& operator>>(istream& is, MyString& s)
{
    s = "";
    is >> ws;
    char ch = ' ';
    while (is.get(ch) && !isspace(ch)) {
        s += ch;
    }
    return is;
}

bool operator==(const MyString& a, const MyString& b)
{
    if (a.size() != b.size())
        return false;
    for (int i = 0; i != a.size(); ++i) {
        if (a[i] != b[i])
            return false;
    }
    return true;
}

bool operator!=(const MyString& a, const MyString& b)
{
    return !(a == b);
}

char* begin(MyString& x)
{
    return (char*)x.c_str();
}

char* end(MyString& x)
{
    return (char*)(x.c_str() + x.size());
}

const char* begin(const MyString& x)
{
    return x.c_str();
}

const char* end(const MyString& x)
{
    return x.c_str() + x.size();
}

MyString& operator+=(MyString& a, const MyString& b)
{
    for (auto x : b) {
        a += x;
    }
    return a;
}

MyString operator+(const MyString& a, const MyString b)
{
    MyString res{b};
    res += b;
    return res;
}

Test.cpp

#include <iostream>
#include "MyString.h"
using namespace std;

int main()
{
    MyString s("abcdefghij");
    cout << s << "\n";
    s += 'k';
    s += 'l';
    s += 'm';
    s += 'n';
    cout << s << "\n";

    MyString s2 = "Hell";
    s2 += " and high water";
    cout << s2 << "\n";

    MyString s3 = "qwerty";
    s3 = s3;
    MyString s4 = "the quick brown fox jumped over the lazy dog";
    s4 = s4;
    cout << s3 << " " << s4 << "\n";

    cout << s + "." + s3 + MyString(".") + "Horsefeathers\n";

    MyString buf;
    while (cin >> buf && buf != "quit") {
        cout << buf << " " << buf.size() << " " << buf.capacity() << "\n";
    }
}