Advertisement
KShah

Untitled

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