Advertisement
Guest User

Untitled

a guest
Apr 5th, 2020
141
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 7.15 KB | None | 0 0
  1. #include "MyString.h"
  2.  
  3. String::String(){
  4.     string = new char[1];
  5.     string[0] = '\0';
  6. }
  7. String::String(const char*_string){
  8.     string = nullptr;
  9.     setString(_string);
  10. }
  11. String::String(const char _string) {
  12.     string = nullptr;
  13.     setString(_string);
  14. }
  15. String::~String(){
  16.     delete[]string;
  17. }
  18. String::String(const String& other){
  19.     setString(other.getString());
  20. }
  21. String& String::operator=(const String& other){
  22.     if (this == &other) {
  23.         return *this;
  24.     }
  25.     setString(other.getString());
  26.     return *this;
  27. }
  28. String& String::operator=(const char* other) {
  29.     this->string = nullptr;
  30.     setString(other);
  31.     return *this;
  32. }
  33. char String:: operator[](int index) {
  34.     if (index >= length() || index < 0 || empty()) {
  35.         cout << "ERROR" << endl;
  36.         return '0';
  37.     }
  38.     else {
  39.         return string[index];
  40.     }
  41. }
  42. String operator+(const String& left,const String& right) {
  43.     cout << "length " << left.length() + right.length() << endl;
  44.     char* sum = new char[left.length() + right.length()+1];
  45.     int i_sum = 0;
  46.     for (int i = 0;left.string[i] != '\0';i++, i_sum++) {
  47.         sum[i_sum] = left.string[i];
  48.     }
  49.     for (int i = 0;right.string[i] != '\0';i++, i_sum++) {
  50.         sum[i_sum] = right.string[i];
  51.     }
  52.     cout << i_sum << endl;
  53.     sum[i_sum+1] = '\0';
  54.     cout << sum;
  55.     String result=sum;
  56.     delete[] sum;
  57.     return result;
  58. }
  59. bool operator==(const char* left,const String& right){
  60.     return (strcmp(left, right.getString()) == 0);
  61. }
  62. bool operator==(const String& left, const String& right) {
  63.     return (strcmp(left.getString(), right.getString()) == 0);
  64. }
  65. bool operator==(const String& left, const char* right) {
  66.     return (strcmp(left.getString(), right) == 0);
  67. }
  68. //
  69. bool operator!=(const char* left, const String& right) {
  70.     return (!(strcmp(left, right.getString()) == 0));
  71. }
  72. bool operator!=(const String& left, const String& right) {
  73.     return (!(strcmp(left.getString(), right.getString()) == 0));
  74. }
  75. bool operator!=(const String& left, const char* right) {
  76.     return (!(strcmp(left.getString(), right) == 0));
  77. }
  78. //
  79. bool operator>(const String& left,const String& right){
  80.     for (int i = 0;left.getString()[i] != '\0' && right.getString()[i] != '\0';i++) {
  81.         if (left.getString()[i] != right.getString()[i]) {
  82.             if (left.getString()[i] > right.getString()[i]) {
  83.                 return true;
  84.             }
  85.             else {
  86.                 return false;
  87.             }
  88.         }
  89.     }
  90.     return false;
  91. }
  92. bool operator>(const char* left, const String& right) {
  93.     for (int i = 0;left[i] != '\0' && right.getString()[i] != '\0';i++) {
  94.         if (left[i] != right.getString()[i]) {
  95.             if (left[i] > right.getString()[i]) {
  96.                 return true;
  97.             }
  98.             else {
  99.                 return false;
  100.             }
  101.         }
  102.     }
  103.     return false;
  104. }
  105. bool operator>(const String& left, const char* right) {
  106.     for (int i = 0;left.getString()[i] != '\0' && right[i] != '\0';i++) {
  107.         if (left.getString()[i] != right[i]) {
  108.             if (left.getString()[i] > right[i]) {
  109.                 return true;
  110.             }
  111.             else {
  112.                 return false;
  113.             }
  114.         }
  115.     }
  116.     return false;
  117. }
  118. //
  119. bool operator<(const String& left, const String& right) {
  120.     for (int i = 0;left.getString()[i] != '\0' && right.getString()[i] != '\0';i++) {
  121.         if (left.getString()[i] != right.getString()[i]) {
  122.             if (left.getString()[i] < right.getString()[i]) {
  123.                 return true;
  124.             }
  125.             else {
  126.                 return false;
  127.             }
  128.         }
  129.     }
  130.     return false;
  131. }
  132. bool operator<(const char* left, const String& right) {
  133.     for (int i = 0;left[i] != '\0' && right.getString()[i] != '\0';i++) {
  134.         if (left[i] != right.getString()[i]) {
  135.             if (left[i] < right.getString()[i]) {
  136.                 return true;
  137.             }
  138.             else {
  139.                 return false;
  140.             }
  141.         }
  142.     }
  143.     return false;
  144. }
  145. bool operator<(const String& left, const char* right) {
  146.     for (int i = 0;left.getString()[i] != '\0' && right[i] != '\0';i++) {
  147.         if (left.getString()[i] != right[i]) {
  148.             if (left.getString()[i] < right[i]) {
  149.                 return true;
  150.             }
  151.             else {
  152.                 return false;
  153.             }
  154.         }
  155.     }
  156.     return false;
  157. }
  158. //
  159. bool operator>=(const String& left, const String& right) {
  160.     for (int i = 0;left.getString()[i] != '\0' && right.getString()[i] != '\0';i++) {
  161.         if (left.getString()[i] != right.getString()[i]) {
  162.             if (left.getString()[i] > right.getString()[i]) {
  163.                 return true;
  164.             }
  165.             else {
  166.                 return false;
  167.             }
  168.         }
  169.     }
  170.     return true;
  171. }
  172. bool operator>=(const char* left, const String& right) {
  173.     for (int i = 0;left[i] != '\0' && right.getString()[i] != '\0';i++) {
  174.         if (left[i] != right.getString()[i]) {
  175.             if (left[i] > right.getString()[i]) {
  176.                 return true;
  177.             }
  178.             else {
  179.                 return false;
  180.             }
  181.         }
  182.     }
  183.     return true;
  184. }
  185. bool operator>=(const String& left, const char* right) {
  186.     for (int i = 0;left.getString()[i] != '\0' && right[i] != '\0';i++) {
  187.         if (left.getString()[i] != right[i]) {
  188.             if (left.getString()[i] > right[i]) {
  189.                 return true;
  190.             }
  191.             else {
  192.                 return false;
  193.             }
  194.         }
  195.     }
  196.     return true;
  197. }
  198. //
  199. bool operator<=(const String& left, const String& right) {
  200.     for (int i = 0;left.getString()[i] != '\0' && right.getString()[i] != '\0';i++) {
  201.         if (left.getString()[i] != right.getString()[i]) {
  202.             if (left.getString()[i] < right.getString()[i]) {
  203.                 return true;
  204.             }
  205.             else {
  206.                 return false;
  207.             }
  208.         }
  209.     }
  210.     return true;
  211. }
  212. bool operator<=(const char* left, const String& right) {
  213.     for (int i = 0;left[i] != '\0' && right.getString()[i] != '\0';i++) {
  214.         if (left[i] != right.getString()[i]) {
  215.             if (left[i] < right.getString()[i]) {
  216.                 return true;
  217.             }
  218.             else {
  219.                 return false;
  220.             }
  221.         }
  222.     }
  223.     return true;
  224. }
  225. bool operator<=(const String& left, const char* right) {
  226.     for (int i = 0;left.getString()[i] != '\0' && right[i] != '\0';i++) {
  227.         if (left.getString()[i] != right[i]) {
  228.             if (left.getString()[i] < right[i]) {
  229.                 return true;
  230.             }
  231.             else {
  232.                 return false;
  233.             }
  234.         }
  235.     }
  236.     return true;
  237. }
  238. void String::setString(const char*_string) {
  239.     delete[] this-> string;
  240.     this->string = new char[strlen(_string) +1];
  241.     strcpy_s(this->string, strlen(_string) + 1, _string);
  242. }
  243. void String::setString(const char _string) {
  244.     delete[] string;
  245.     string = new char[2];
  246.     string[0] = _string;
  247.     string[1] = '\0';
  248. }
  249. const char* String::getString()const {
  250.     return string;
  251. }
  252. void String::append(const char* add) {
  253.     char* result = new char[strlen(string) + strlen(add) +1];
  254.     int i_result = 0;
  255.     for (int i = 0;string[i] != '\0';i++,i_result++) {
  256.         result[i_result] = string[i];
  257.     }
  258.     for (int i = 0;add[i] != '\0';i++, i_result++) {
  259.         result[i_result] = add[i];
  260.     }
  261.     result[i_result] = '\0';
  262.     setString(result);
  263.     delete[]result;
  264.  
  265. }
  266. void String::append(const char add) {
  267.     char* result = new char[strlen(string) + 2];
  268.     int i_result = 0;
  269.     for (int i = 0;string[i] != '\0';i++, i_result++) {
  270.         result[i_result] = string[i];
  271.     }
  272.     result[i_result] = add;
  273.     result[i_result + 1] = '\0';
  274.     setString(result);
  275.     delete[]result;
  276. }
  277. void String::print()const {
  278.     cout << string << endl;
  279. }
  280. int String::length()const {
  281.     return strlen(string);
  282. }
  283. bool String::empty()const {
  284.     if (length() == 0) {
  285.         return true;
  286.     }
  287.     else {
  288.         return false;
  289.     }
  290. }
  291. const char* String::c_str()const {
  292.     return string;
  293. }
  294. istream& operator>>(istream& in, String& _string) {
  295.     char input[250];
  296.     in >> input;
  297.     _string = input;
  298.     return in;
  299. }
  300. ostream& operator<<(ostream& out, const String& _string) {
  301.     out<<_string.string;
  302.     return out;
  303. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement