Advertisement
KShah

Untitled

Nov 11th, 2021
851
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. #include <cstring>
  3.  
  4. class String{
  5. private:
  6.     char* str = nullptr; // указатель на массив
  7.     size_t sz = 0; // размер
  8.     size_t maxsz = 1; // максимально возможный размер str
  9.  
  10.     void growBuffer() {
  11.         maxsz *= 2;
  12.         char* newstr = new char[maxsz];
  13.         memcpy(newstr, str, sz);
  14.  
  15.         delete[] str;
  16.         str = newstr;
  17.     }
  18.  
  19.     void cutBuffer() {
  20.         maxsz /= 2;
  21.         char* newstr = new char[maxsz];
  22.         memcpy(newstr, str, sz);
  23.  
  24.         delete[] str;
  25.         str = newstr;
  26.  
  27.     }
  28.  
  29. public:
  30.     // Конструктор по умолчанию
  31.     String() = default;
  32.  
  33.     // Конструктор от C-style строки
  34.     String(const char* s): str(new char[strlen(s)]), sz(strlen(s)), maxsz(strlen(s)) {
  35.         memcpy(str, s, sz);
  36.     }
  37.     // Конструктор от двух параметров (size, char)
  38.     String(const size_t n, const char c): str(new char[n]), sz(n), maxsz(n) {
  39.         memset(str, c, n);
  40.     }
  41.      
  42.     // Конструктор копирования
  43.     String(const String &s): str(new char[s.sz]), sz(s.sz), maxsz(s.sz)  {
  44.        memcpy(str, s.str, s.sz);
  45.     }
  46.  
  47.     // Оператор присваивания
  48.     String& operator=(const String& other) {
  49.         String copy = other;
  50.         sz = copy.sz;
  51.  
  52.         maxsz = other.maxsz;
  53.         delete[] str;
  54.  
  55.         str = new char[maxsz];
  56.         memcpy(str, copy.str, sz);
  57.  
  58.         return *this;          
  59.     }
  60.  
  61.     // Оператор ==, проверка строк на совпадение
  62.     bool operator==(const String& s) {
  63.         if (this->sz != s.sz) {
  64.             return false;
  65.         } else {
  66.             for (size_t i = 0; i < this->sz; ++i) {
  67.                 if (this->str[i] != s.str[i]) {
  68.                     return false;
  69.                 }
  70.             }  
  71.             return true;
  72.         }
  73.     }
  74.  
  75.     // Квадратные скобки для конст. строк
  76.     const char& operator[](const size_t pos) const {
  77.         return str[pos];
  78.     }
  79.     // Квадратные скобки для неконст. строк
  80.     char& operator[](const size_t pos) {
  81.         return str[pos];
  82.     }
  83.  
  84.     // length() - размер строки
  85.     int length() const {
  86.         return sz;
  87.     }
  88.  
  89.     // push_back(char), pop_back() за O(1) амортизиованно
  90.     void push_back(const char c) {
  91.         if (sz == maxsz) {
  92.             growBuffer();
  93.         }
  94.         str[sz] = c;
  95.         sz++;
  96.     }
  97.  
  98.     void pop_back() {
  99.         if (sz <= (maxsz / 4)) {
  100.             cutBuffer();
  101.         }
  102.         --sz;
  103.     }
  104.     // front(), back() - ссылка на начальный и на последний символы строки
  105.    
  106.     char& front() const {
  107.         return str[0];
  108.     }
  109.    
  110.     char& back() const {
  111.         return str[sz - 1];
  112.     }
  113.  
  114.     // += - добавить к строке символ или строку. Символ за O(1) учётно.
  115.     String& operator+=(const String& s) {
  116.         for (size_t i = 0; i < s.sz; ++i) {
  117.             push_back(s[i]);
  118.         }
  119.         return *this;
  120.     }
  121.    
  122.     String& operator+=(const char c) {
  123.         push_back(c);
  124.         return *this;
  125.     }
  126.     // + -  оператор складывания 1) строки с символом 2) символ и строка 3) строка и строка
  127.  
  128.     // find(substring), rfind(substring) - индекс вхождения строки с начала и с конца (length - в противном случае)
  129.    
  130.     size_t find(const String& subStr) const {
  131.         int flag = 1;
  132.         for (size_t i = 0; i < sz; ++i) {
  133.             for (size_t j = 0; j < subStr.sz; ++j) {
  134.                 if (i + j >= sz) {
  135.                     flag = 0;
  136.                     break;
  137.                 }
  138.                 if (str[i + j] != subStr.str[j]) {
  139.                     flag = 0;
  140.                     break;
  141.                 }
  142.             }
  143.             if (flag == 1) {
  144.                 return i;
  145.             }
  146.             flag = 1;
  147.         }
  148.         return sz;
  149.     }
  150.  
  151.     size_t rfind(const String& subStr) const {
  152.         int flag = 1;
  153.         for (size_t i = 0; i < sz; ++i) {
  154.             for (size_t j = 0; j < subStr.sz; ++j) {
  155.                 if ((sz - 1 - i + j) >= sz) {
  156.                     flag = 0;
  157.                     break;
  158.                 }
  159.                 if (str[sz - 1 - i + j] != subStr.str[j]) {
  160.                     flag = 0;
  161.                     break;
  162.                 }
  163.             }
  164.  
  165.             if (flag == 1) {
  166.                 return sz - 1 - i;
  167.             }
  168.             flag = 1;
  169.         }
  170.         return sz;
  171.     }
  172.     // substr(start, count) - вернуть подстроку длины count начиная со start
  173.     String substr(size_t start, size_t count) const {
  174.         String res(count, '\0');
  175.         for (size_t i = start; i < start + count; ++i) {
  176.             res.str[i] = str[i];
  177.         }
  178.         return res;
  179.     }
  180.  
  181.     // empty() - проверка на пустоту
  182.     bool empty() const {
  183.         if (sz == 0) {
  184.             return true;
  185.         } else {
  186.             return false;
  187.         }
  188.     }
  189.  
  190.     // clear() - очистка строки
  191.     void clear() {
  192.         delete[] str;
  193.         sz = 0;
  194.         maxsz = 1;
  195.         str = new char[1];
  196.     }
  197.     // ~ Деструктор
  198.     ~String() {
  199.         delete[] str;
  200.     }
  201.  
  202.  
  203.     // вывод из потока
  204.     friend std::ostream& operator<<(std::ostream& os, const String& Str) {
  205.         os<< Str.str;
  206.         return os;
  207.     }
  208.     // ввод в поток
  209.     friend std::istream& operator>>(std::istream& is, String& Str) {
  210.         is >> Str.str;
  211.         return is;
  212.     }
  213. };
  214.  
  215. String operator+(const char lstr, const String& rstr) {
  216.     String copy(1, lstr);
  217.     copy += rstr;
  218.     return copy;
  219. }
  220.  
  221. String operator+(const String& lstr, const char rstr) {
  222.     String copy = lstr;
  223.     copy.push_back(rstr);
  224.     return copy;
  225. }
  226.  
  227. String operator+(const String& lstr, const String& rstr) {
  228.     String copy = lstr;
  229.     copy += rstr;
  230.     return copy;
  231. }
  232.  
  233. int main() {
  234.     String s;
  235.     std::cin >> s;
  236.     std::cout << s.length() << "\n";
  237.  
  238.  
  239.     return 0;
  240. }
  241.  
Advertisement
Advertisement
Advertisement
RAW Paste Data Copied
Advertisement