Advertisement
KShah

Untitled

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