Создать класс "Строка" и перегрузить операторы

#include <iostream>
#include <algorithm>
#include <memory>
 
using namespace std;
 
class Str {
    friend ostream& operator<<(ostream&, const Str&);
    allocator<char> alloc;
    char *beg;
    char *ff_str;
    char *cap;
    void real_str(size_t fl = 0);
 
    friend Str operator+(const Str&, const Str&);
    friend Str operator-(const Str&, const Str&);
 
    void free() {
        if (beg != ff_str) {
            for_each(beg, ff_str, [&alloc = alloc](char &sym) { alloc.destroy(&sym); });
            alloc.deallocate(beg, cap - beg);
        }
    }
 
 
    pair<char*, char*> str_copy(char *b, char *f, size_t cnt) {
        auto new_mem = alloc.allocate(cnt);
        char *tm = new_mem;
        for_each(b, f, [&alloc = alloc, &tm](char &sym) { alloc.construct(tm++, sym); });
        return make_pair(new_mem, tm);
    }
 
 
    void swap(Str &a, Str &b) {
        using std::swap; 
        swap(a.beg, b.beg);
        swap(a.ff_str, b.ff_str);
        swap(a.cap, b.cap);
    }
 
 
public:
    Str() : beg(nullptr), ff_str(nullptr), cap(nullptr) {}
    Str(char *str) : Str() { push_back(str); }
    Str(const Str &s) : Str() {
        if (this != &s) {
            size_t cnt = s.size();
            free();
            real_str(cnt);
            uninitialized_copy(s.beg, s.ff_str, beg);
            ff_str = beg + cnt;
        }
    }
 
 
    Str& operator+=(const Str);
    Str& operator-=(const Str);
 
 
    Str(Str &&x) {
        if (this != &x) {
            free();
            beg = x.beg;
            ff_str = x.ff_str;
            cap = x.cap;
            x.beg = x.ff_str = x.cap = nullptr;
        }
    }
 
 
    char* begin() { return beg; }
 
 
    ~Str() { free(); }
    Str& operator=(Str s) {
        swap(*this, s);
        return *this;
    }
 
 
    Str& operator=(Str &&s) {
        if (this != &s) {
            free();
            beg = s.beg;
            ff_str = s.ff_str;
            cap = s.cap;
            s.beg = s.ff_str = s.cap = nullptr;
        }
    }
 
 
    int size() const { return ff_str - beg; }
    void push_back(const char &sym) {
        if (ff_str == cap)
            real_str();
        *(ff_str - 1) = sym;
        *ff_str++ = '\0';
    }
    void push_back(const char *str) {
        while (*str != '\0')
            push_back(*str++);
    }
};
 
 
istream& operator>>(istream &is, Str &x) {
    char sym;
    while ((sym = cin.get()) != '\n')
        x.push_back(sym);
    return is;
}
 
 
ostream& operator<<(ostream &os, const Str &x) {
    for_each(x.beg, x.ff_str, [&os](char &sym) { os << sym; });
    return os;
}
 
 
Str& Str::operator+=(const Str a) {
    push_back(a.beg);
    return *this;
}
 
Str& Str::operator-=(const Str a) {
    if (char *ptr_beg = strstr(beg, a.beg)) {
        char *ptr_end = ptr_beg + a.size() - 1;
        do { *ptr_beg++ = *ptr_end; } while (++ptr_end != ff_str);
        if (!*beg) free();
        else ff_str = ptr_beg;
    }
    return *this;
}
 
 
Str operator-(const Str &a, const Str&b) {
    Str tm_obj(a);
    return tm_obj -= b;
}
 
 
Str operator+(const Str &a, const Str &b) {
    Str tm_obj(a.beg);
    return tm_obj += b;
}
 
 
int main() {
    
    Str ch;
    cin >> ch;
    cout << ch - "a" << endl;
    Str z = "hello";
    cout << z << endl;
    Str x = "e";
    z += "el";
    cout << z - "oel" << endl;
 
    return 0;
}
 
void Str::real_str(size_t fl) {
    int cnt = size() ? size() * 2 : 2;
    if (fl) cnt = fl;
    auto new_mem = alloc.allocate(cnt);
    char *tm = new_mem;
    if (beg) {
        for_each(beg, ff_str, [&alloc = alloc, &tm](char &sym) { alloc.construct(tm++, move(sym)); });
        free();
    }   
    ff_str = beg ? tm : tm + 1;
    beg = new_mem;
    cap = beg + cnt;
}