#include <cstddef>
#include <iostream>
#include <cstring>
#include <ostream>

class String{
    // вывод из потока
    friend std::ostream& operator<<(std::ostream& os, const String& s) {
        os << s.str;
        return os;
    }
    // ввод в поток
    friend std::istream& operator>>(std::istream& is, const String& s) {
        is >> s.str;
        return is;
    }
private:
    char* str = nullptr; // указатель на массив
    size_t sz = 0; // размер
    size_t maxsz = 0; // максимально возможный размер str

    void growBuffer() {
        maxsz *= 2;
        char* newstr = new char[maxsz];
        memcpy(newstr, str, sz);

        delete[] str;
        str = newstr;
    }

    void cutBuffer() {
        maxsz /= 2;
        char* newstr = new char[maxsz];
        memcpy(newstr, str, sz);

        delete[] str;
        str = newstr;

    }

public:
    // Конструктор по умолчанию
    String() = default;

    // Конструктор от C-style строки
    String(const char* s): str(new char[strlen(s)]), sz(strlen(s)), maxsz(strlen(s)) {
        memcpy(str, s, sz);
    }
    // Конструктор от двух параметров (size, char)
    String(size_t n,  char c): str(new char[n]), sz(n), maxsz(n) {
        memset(str, c, n);
    }

    // Конструктор копирования
    String(const String &s): str(new char[s.sz]), sz(s.sz), maxsz(s.sz)  {
       memcpy(str, s.str, s.sz);
    }

    //swap
    void swap(String& s) {
        std::swap(str, s.str);
        std::swap(sz, s.sz);
    }

    // Оператор присваивания
    String& operator=(const String& s) {
        String copy = s;
        swap(copy);
        return *this;
    }

    // Оператор ==, проверка строк на совпадение
    bool operator==(const String& s) {
        if (this->sz != s.sz) {
            return false;
        } else {
            for (int i = 0; i < this->sz; ++i) {
                if (this->str[i] != s.str[i]) {
                    return false;
                }
            }
            return true;
        }
    }


    // Квадратные скобки для конст. строк
    // By Anton {
    const char& operator[](const size_t pos) const {
        return str[pos];
    }
    // Квадратные скобки для неконст. строк
    char& operator[](const size_t pos) {
        return str[pos];
    }
    // }

    // length() - размер строки
    size_t length() const {
        return sz;
    }

    // push_back(char), pop_back() за O(1) амортизиованно
    void Push_back(const char c) {
        if (sz == maxsz) {
            growBuffer();
        }
        str[sz] = c;
        sz++;
    }
    // front(), back() - ссылка на начальный и на последний символы строки

    char& front() const {
        return str[0];
    }

    char& back() const {
        return str[sz - 1];
    }

    // += - добавить к строке символ или строку. Символ за O(1) учётно.
    String& operator+=(const String& s) {
        for (size_t i = 0; i < s.sz; ++i) {
            Push_back(s[i]);
        }
        return *this;
    }

    String& operator+=(const char c) {
        Push_back(c);
        return *this;
    }
    // + -  оператор складывания 1) строки с символом 2) символ и строка 3) строка и строка
    String& operator+(const String& s) {
        *this += s;
        return *this;
    }
    // find(substring), rfind(substring) - индекс вхождения строки с начала и с конца (length - в противном случае)

    size_t find(const String& subStr) const {
        int flag = 1;
        for (size_t i = 0; i < sz; ++i) {
            for (size_t j = 0; j < subStr.sz; ++j) {
                if (i + j >= sz) {
                    flag = 0;
                    break;
                }
                if (str[i + j] != subStr.str[j]) {
                    flag = 0;
                    break;
                }
            }
            if (flag == 1) {
                return i;
            }
            flag = 1;
        }
        return sz;
    }

    size_t rfind(const String& subStr) const {
        int flag = 1;
        for (size_t i = sz - 1; i >= 0; --i) {
            for (size_t j = 0; j < subStr.sz; ++j) {
                if ((i + j) >= sz) {
                    flag = 0;
                    break;
                }
                if (str[sz - 1 - i + j] != subStr.str[j]) {
                    flag = 0;
                    break;
                }
            }

            if (flag == 1) {
                return sz - 1 - i;
            }
            flag = 1;
        }
        return sz;
    }
    // substr(start, count) - вернуть подстроку длины count начиная со start

    // empty() - проверка на пустоту

    // clear() - очистка строки
    void clear() {
        delete[] str;
        sz = 0;
        maxsz = 0;
        str = nullptr;
    }
    // ~ Деструктор
    ~String() {
        delete[] str;
    }
};

int main() {
    /*
    String s(10, 'a');
    String ss = s;
    char c = 'c';
    ss += c;
    std::cout << s << " " << ss << "\n";
    */

    String a("abcd");
    String b("dsafdabcd");
    std::cout << b.find(a) << "\n";
    return 0;
}