#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

using namespace std;

class String {

public:

    String() : size_(0), capacity_(15), str_(new char[capacity_]) {
        total_number_string_++;
    }

    explicit String(const int string_capacity) : size_(0), capacity_(string_capacity), str_(new char[capacity_]) {
        total_number_string_++;
    } // здесь ставим explicit во избежание неявного приведения int к string

    String(const char* new_string) : size_(strlen(new_string)), capacity_(size_ + 1), str_(new char[capacity_]) {
        strcpy(str_, new_string);
        total_number_string_++;
    } // здесь explicit лучше не ставить чтобы иметь возможность преобразовать символьный массив к String

    String(const String& other) : size_(other.size_), capacity_(other.capacity_), str_(new char[capacity_]) {
        strcpy(str_, other.str_);
        total_number_string_++;
    }

    String(String&& other) : size_(other.size_), capacity_(other.capacity_), str_(other.str_) {
        other.str_ = nullptr;
        other.size_ = 0;
        other.capacity_ = 0;
        total_number_string_++;
    }

    String& operator=(const String& other) {
        if (&other != this) { // проверка на самоприсваивание
            size_ = other.size_;
            capacity_ = other.capacity_;
            delete[] str_;
            str_ = new char[capacity_];
            strcpy(str_, other.str_);
        }
        return *this;
    } // переопределение копирующего оператора присваивания для String

    String& operator=(String&& other) {
        if (&other != this) { // проверка на самоприсваивание
            size_ = other.size_;
            capacity_ = other.capacity_;
            delete[] str_;
            str_ = other.str_;
            other.str_ = nullptr;
            other.size_ = 0;
            other.capacity_ = 0;
        }
        return *this;
    } // переопределение перемещающего оператора присваивания для String

    String& operator=(const char* str) {
        size_ = strlen(str);
        capacity_ = size_ + 1;
        delete[] str_;
        str_ = new char[capacity_];
        strcpy(str_, str);
        return *this;
    } // переопределение копирующего оператора присваивания для строкового литерала

    const char* get_string() const {
        return str_;
    }


    int size() const {
        return size_;
    }

    int capacity() const {
        return capacity_;
    }

    bool operator==(const String& other) const {
        return !strcmp(str_, other.str_);
    } // переопределение оператора ==

    bool operator!=(const String& other) const {
        return strcmp(str_, other.str_);
    } // переопределение оператора !=

    char& operator[](const int index) {
        if (index < 0 || index >= size_) {
            cout << "Некорректный индекс" << endl;
        }
        return str_[index];
    } // переопределение оператора индексирования

    const char& operator[](const int index) const {
        if (index < 0 || index >= size_) {
            cout << "Некорректный индекс" << endl;
        }
        return str_[index];
    } // переопределение оператора индексирования для константных объектов

    static int get_total_number_strings() {
        return total_number_string_;
    }

    ~String() {
        delete[] str_;
        total_number_string_--;
    }


private:
    int size_;
    int capacity_;
    char* str_;
    static int total_number_string_;
};

ostream& operator<<(ostream& output, const String& string) {
    output << string.get_string();
    return output;
} // переопределение оператора вывода в поток

istream& operator>>(istream& input, String& string) {
    int capacity = 15;
    int i = 0;
    char* str = new char[capacity];
    char ch;
    while (ch = input.get()) {
        if (ch == ' ' || ch == '\n') {
            break;
        }
        if (i == capacity - 1) {
            char* temp = new char[capacity *= 2];
            for (int j = 0; j < i; j++) {
                temp[j] = str[j];
            }
            delete[] str;
            str = temp;
        }
        str[i] = ch;
        i++;
    }
    str[i] = '\0';
    string = str;
    return input;
} // переопределение оператора чтения из потока



int String::total_number_string_ = 0;

int main() {
    setlocale(LC_ALL, "ru");

    String str1;

    String str2(30);

    cout << String::get_total_number_strings() << endl;

    String str3("Привет");

    cout << str3 << endl;

    str3 = "Новая строка";

    cout << str3 << endl;

    str1 = "Еще одна новая строка";

    cout << str1 << endl;

    String str4(str3);

    cout << str3 << endl;

    cout << str4 << endl;

    cout << (str1 == str4) << endl;
    cout << (str3 == str4) << endl;
    cout << (str1 != str4) << endl;
    cout << (str3 != str4) << endl;

    String str5;
    str5 = str1;
    cout << str5 << endl;
    str5 = str5;
    str5[0] = 'Т';
    cout << str5 << endl;

    String str7 = "Привет";

    cout << str7[0] << endl;

    cout << str7 << endl;

    String str8;
    str8 = move(str7);
}