string

#include <iostream>
#include <cstring>
#include <vector>
using namespace std;

class String{
    int _size; // длина
    char * _str; // массив символов
public:
// Конструкторы и деструкторы
    String(); // Дефолтный конструктор
    String(const char *); // Конструктор с параметром
    String(const String&); // Конструктор копирования
    ~String(); // Деструктор
// Операторы
    String& operator =(const String&);
    String& operator =(const char*);
    void operator -=(const char*);
    void operator -=(const String&);
    void operator +=(const char*);
    void operator +=(const String&);
friend istream & operator >>(istream & is, String & s);
friend ostream & operator <<(ostream & os, String const & s);
friend bool operator == ( String const & a, String const & b );
friend bool operator != ( String const & a, String const & b );
friend bool operator < ( String const & a, String const & b );
friend bool operator > ( String const & a, String const & b );
friend bool operator <= ( String const & a, String const & b );
friend bool operator >= ( String const & a, String const & b );
friend String operator + ( String const & a, String const & b );
// Функции
    vector<int> all_pos(const char*) const; // Все вхождения подстроки в стиле си
    int pos(const char*, int p = 0)const; // Первое вхождение подстроки в стиле си начиная с позиции p
    int last_pos(const char*)const; // Последнее вхождение подстроки в стиле си

    vector<int> all_pos(const String& ) const; // Все вхождения подстроки
    int pos(const String&, int p = 0)const; // Первое вхождение подстроки начиная с позиции p
    int last_pos(const String&)const; // Последнее вхождение подстроки

    void erase(int p, int l); // удаляет l элементов начиная с позиции p

    void delete_left_spaces(); // удаляет пробелы слева
    void delete_right_spaces(); // удаляет пробелы справа
    void delete_all_spaces(); // удаляет все пробелы

    int remove(const char*); // Удаление всех вхождений подстроки в стиле си и возврат количества удалений
    int remove(const String&); // Удаление всех вхождений подстроки и возврат количества удалений

    int replace(const char* substr, const char * str); // Замена всех вхождений подстроки в стиле си на строку в стиле си . Возврат количества замен
    int replace(const char, const char); // Замена всех вхождений одного символа на другой символ . Возврат количества замен
    int replace(const String&, const String&); // Замена всех вхождений подстроки на строку . Возврат количества замен

    char * select(int p, int l)const; // Выделение подстроки в стиле си длиной l символов начиная с позиции p
    String select_str(int p, int l)const; // Выделение подстроки длиной l символов начиная с позиции p

    void to_lower(); // Преобразование к нижнему регистру
    void to_upper(); // Преобразование к верхнему регистру

    void add(const char*); // Добавление подстроки в стиле си в конец строки
    void add(const String&); // Добавление подстроки в конец строки

    void insert(const char*, int p); // Вставка строки в стиле си в позицию p
    void insert(const String&, int p); // Вставка строки в позицию p

    int get_size() const ; // Получение длины строки
    char* get_str() const; // Получение массива символов

    int compare ( const String& ) const; // Сравнение строки со строкой
};

int main(){
    String s1, s2 = "abcd";
    for (int i = 0; i < 5; ++i) s1 += s2;
    cout << s1 << endl;

    s1.replace("cd", "ba");
    cout << s1 << endl;

    s1.remove("bb");
    cout << s1 << endl;

    s1.to_upper();
    cout << s1 << endl;

}

void String::insert(const char * s , int p) {
    String temp = s;
    insert(temp, p);
}

void String::insert(const String & s, int p){
    *this = select_str(0, p) + s + select_str(p+s._size , _size - p - s._size );
}

int String::remove(const String & s){
    return remove(s._str);
}

void String::delete_left_spaces(){
    int i;
    for (i = 0; i < _size && isspace(_str[i]); ++i);
    erase(0, i);
}

void String::delete_right_spaces(){
    int i;
    for (i = _size-1; i >= 0 && isspace(_str[i]); --i);
    i++;
    erase(i, _size-i);
}

void String::delete_all_spaces(){
    int i = _size - 1, j;
    while ( i >= 0 ) {
        for (j = 0; i >= 0 && isspace( _str[i] ); --i) ++j;
        _size -= j;
        for (int k = i+1 ; k < _size; ++k) _str[k] = _str[k+j];
        for (; i >= 0 && ! isspace( _str[i] ); --i) ;
    }

    if ( _size != strlen(_str) )
        *this = select_str(0, _size);
}

void String::erase(int p, int l){
    if ( p < _size ) {
        if ( p + l > _size ) l = _size - p;
        String temp1 = select_str (0, p);
        String temp2;
        p += l;
        if ( p < _size )
            temp2 = select_str(p, _size - p );
        *this = temp1 + temp2;
    }
}

vector<int> String::all_pos(const String & s) const {
    return all_pos(s._str);
}

int String::pos(const String & s, int p)const {
    return pos(s._str, p);
}

int String::last_pos(const String & s)const{
    return last_pos(s._str);
}

void String::to_lower(){
    for (int i = 0; i < _size; ++i)
        *(_str+i) = tolower(*(_str+i));
}

void String::to_upper(){
    for (int i = 0; i < _size; ++i)
        *(_str+i) = toupper(*(_str+i));
}


int String::replace(const char a, const char b){
    char substr[2] = {a, '\0'};
    char str[2] = {b, '\0'};
    return replace(substr, str);
}

int String::replace(const String & substr, const String & str){
    return replace(substr._str, str._str);
}

int String::replace(const char * substr, const char * str){
    auto v = all_pos(substr);
    int count = v.size();
    int len1 = strlen(substr);
    int len2 = strlen(str);
    int new_len = _size - count * (len1-len2);
    char * temp = new char [new_len+1];
    *temp = '\0';
    int i, p;
    for ( i = 0, p = 0; i < count; ++i ){
        strcat(temp, select(p, v[i]-p));
        strcat(temp, str);
        p = v[i] + len1;
    }
    if ( p < _size ) strcat(temp, select(p, _size-p));
    temp[new_len] = '\0';
    delete [] _str;
    _str = temp;
    _size = new_len;
    return count;
}

char * String::select(int p, int l)const{
    String s = select_str(p, l);
    int len = s.get_size();
    char * temp = new char [ len + 1];
    *temp = '\0';
    strcat(temp, s._str);
    temp[len] = '\0';
    return temp;
}

String String::select_str(int p, int l)const{
    String s;
    if ( p < _size ) {
        if ( p + l > _size ) l = _size - p;
        char * temp = new char [ l + 1 ];
        //*temp = '\0';
        for (int i = 0; i < l; ++i)
            *(temp+i) = *(_str+p+i);
        temp [l] = '\0';
        s = temp;
    }

    return s;
}

int String::compare ( const String & s ) const {
    return strcmp(_str , s._str);
}

istream & operator >>(std::istream & is, String & s){
    const int N = 1024; // Максимум символов , которые могут быть прочитаны из потока
    char temp[ N ];
    is.getline(temp , N+1);
    s = temp;
    return is;
}

ostream & operator <<(ostream & os, const String & s){
    return os << s.get_str();
}

bool operator == ( String const & a, String const & b ){ return ( a.compare(b) == 0 ); }
bool operator != ( String const & a, String const & b ){ return !( a == b ); }
bool operator < ( String const & a, String const & b ) { return ( a.compare(b) == -1 ); }
bool operator > ( String const & a, String const & b ) { return ( a.compare(b) == 1 ); }
bool operator <= ( String const & a, String const & b ) { return !( a > b ); }
bool operator >= ( String const & a, String const & b ) { return !( a < b ); }
String operator + ( String const & a, String const & b ) {
    String temp = a;
    temp += b;
    return temp;
}

int String::pos(const char * str, int p)const{
// Функция возвращает первое вхождение подстроки в строку начиная с позиции p или -1 , если вхождений нет вообще
    int len = strlen(str), answer = -1;
    for (int i = p, j = 0; i < _size; ++i){
        if ( _str[i] == str[j] ){
            j++;
            if ( j == len ) {
                answer = i-j+1;
                break;
            }
        } else j = 0;
    }

    return answer;
}

int String::last_pos(const char * str)const{
// Функция возвращает последнее вхождение подстроки или -1 , если его нет
    int len = strlen(str), answer = -1;
    for (int i = _size -1, j = len-1; i >= 0; --i){
        if ( _str[i] == str[j] ){
            j--;
            if ( j == -1 ) {
                answer = i;
                break;
            }
        } else j = len-1;
    }

    return answer;
}

vector<int> String::all_pos(const char* str)const {
// Функция возвращает вектор из всех вхождений
    vector<int> v;
    int p = -1;
    bool flag = true;
    while ( flag ) {
        p = pos( str , p+1);
        if ( p != -1 )
            v.push_back(p);
        else
            flag = false;
    }
    return v;
}

void String::operator +=(const char* str){
    add(str);
}

void String::operator +=(const String& str){
    add(str._str);
}

void String::add(const char* str){
    _size += strlen(str);
    char* temp = new char[_size+1];
    //*temp = '\0';
    strcpy(temp,_str);
    strcat(temp, str);
    temp[_size] = '\0';
    delete [] _str;
    _str = temp;
}

void String::operator -=(const char* str){
    remove(str);
}

void String::operator -=(const String& str){
    remove(str._str);
}

int String::remove(const char * str){
    return replace(str, "");
    /*
    auto v = allPos(str);

    for(int i = v.size()-1, len = strlen(str); i >= 0; --i){
        _size -= len;
        for(int j = v[i]; j < _size; j++){
            _str[j]=_str[j+len];
        }
    }

    if ( v.size() != 0 ) {
        char* temp = new char[_size+1];
        strncpy(temp, _str, _size);
        temp[_size] = '\0';
        delete [] _str;
        _str = temp;
    }

    return v.size();
    */
}

int String::get_size()const {return _size;}
char* String::get_str()const {return _str;}

String::String(){
    _size = 0;
    _str = new char [1];
    *_str = '\0';
}

String::String(const char* str){
    if (!str){
        _size = 0; _str = 0;
    } else {
        _size = strlen (str);
        _str = new char [_size +1];
        strcpy(_str, str);
    }
}

String::String(const String& str){
    _size = str._size;
    if ( !str._str ){
        _str = 0;
    } else {
        _str = new char[_size +1];
        strcpy(_str, str._str);
    }
}

String::~String(){
    delete [] _str;
}

String& String::operator=( const char * str ){
   if ( ! str ) {
     _size = 0;
     delete [] _str;
     _str = 0;
   } else {
     _size = strlen( str );
     delete [] _str;
     _str = new char[ _size + 1 ];
     strcpy( _str, str );
   }
   return *this;
}

String& String::operator=( const String & str)
{
   if ( this != & str) {
      delete [] _str;
      _size = str._size;
      if ( ! str._str )
         _str = 0;
      else {
         _str = new char[ _size + 1 ];
         strcpy( _str, str._str );
      }
   }
   return *this;
}