В классе Строка перегрузить оператор () для приема целочисленных и дробных значений

#include <iostream>
#include <string>
 
class string : public std::string
{
    using base = std::string;
    
public:
    using base::base;
    
    operator int()const    { return std::stoi(*this); }
    operator double()const { return std::stod(*this); }
};
 
int main()
{
    std::cout << "Hello, world!\n";
    
    const string value1 = "123";
    const string value2 = "123.5";
    
    const int re1 = value1;
    const double re2 = value2;
    
    std::cout<<"int = "    << re1 <<std::endl;
    std::cout<<"double = " << re2 <<std::endl;
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <stdexcept>
#include <utility>
#include <iterator>
#include <cstddef>
#include <string>
 
using namespace std;
 
class MyString
{
private:
    char* str;
    unsigned int length;
    unsigned int capacity;
    int m_nData;
public:
    friend bool operator== (const MyString&, const MyString&);
    friend bool operator > (const MyString& c1, const MyString& c2);
    friend bool operator < (const MyString& c1, const MyString& c2);
    friend bool operator >= (const MyString& c1, const MyString& c2);
    friend bool operator <= (const MyString& c1, const MyString& c2);
    friend bool operator != (const MyString& c1, const MyString& c2);
 
 
 
 
 
 
    MyString() : str(new char[length + 20 + 1]()), capacity(length + 20), length(0)
    {
        *str = '\0';
    }
 
    //2)? применить в конструкторах инициализаторы / делегирование(вместо функции Initialize)
    MyString(char* str, unsigned int capacity = 80) : str(""), capacity(80)
    {
        length = strlen(str);
        this->capacity = (capacity > length) ? capacity : length + 20;
        this->str = new char[this->capacity];
        strcpy_s(this->str, length + 1, str);
    }
 
 
    explicit MyString(unsigned int capacity) : length(strlen(str))  //1)? пометить конструктор String(unsigned int capacity) как explicit
    {
        length = strlen(str);
        this->capacity = (capacity > length) ? capacity : length + 20;
        this->str = new char[this->capacity];
        strcpy_s(this->str, length + 1, str);
 
    }
    MyString(const char* STR) :
        length(strlen(STR)), capacity(length + 20 + 1), str(new char[capacity]())
    {
        length = strlen(STR);
        this->capacity = (capacity > length) ? capacity : length + 20;
        this->str = new char[this->capacity];
        strcpy_s(this->str, length + 1, STR);
    }
 
    MyString(const int nData) :m_nData(nData)
    {
    }
 
 
    MyString(unsigned int length, char ch) :
        length(strlen("")), capacity(length + 20 + 1), str(new char[capacity]())
    {
        length = strlen("");
        this->capacity = (capacity > length) ? capacity : length + 20;
        this->str = new char[this->capacity];
        strcpy_s(this->str, length + 1, "");
    }
 
    MyString(const MyString& original) : str(""), capacity(80), length(original.length)
    {
        length = strlen(original.str);
        this->capacity = (original.capacity >original.length) ? original.capacity : original.length + 20;
        this->str = new char[this->capacity];
        strcpy_s(this->str, length + 1, original.str);
 
    }
 
    ~MyString()
    {
        delete[] str;
    }
 
    // геттеры-сеттеры
    const char* GetMyString() const
    {
        return str;
    }
 
    void SetMyString(const char* str)
    {
        length = strlen(str);
        if (length >= capacity)
        {
            delete[] this->str;
            capacity = length + 20;
            this->str = new char[capacity];
        }
        strcpy_s(this->str, length + 1, str);
    }
 
    int GetLength() const
    {
        return length;
    }
 
    // метода SetLength не должно быть!
 
    int GetCapacity() const
    {
        return capacity;
    }
 
    void Clear()
    {
        str[0] = '\0';
        length = 0;
    }
 
    void ShrinkToFit()
    {
        if (length + 1 == capacity)
        {
            return;
        }
 
        capacity = length + 1;
        char* temp = new char[capacity];
        strcpy_s(temp, capacity, str);
        delete[] str;
        str = temp;
    }
 
    void swap(MyString& c)
    {
        if (this != &c)
        {
            std::swap(length, c.length);
            std::swap(capacity, c.capacity);
            std::swap(str, c.str);
        }
    }
    void  resize(unsigned int new_len)
    {
        capacity = new_len + 20 + 1;
        char *new_arr = new char[capacity]();
        strcpy(new_arr, str);
        delete[] str;
        length = new_len;
        str = new_arr;
    }
 
    void push_back(const char& val)
    {
        if (length == capacity)
        {
            resize(length + 1);
            --length;
        }
 
        str[length++] = val;
    }
 
 
    //- перегрузка операции =
    MyString operator= (const MyString& s)
    {
        if (this != &s)
            MyString(s).swap(*this);
        return *this;
    }
    //- перегрузка () (повторная инициализация строки)
    /*operator MyString()const
    {
        return  *this;
    }*/
 
 
    //-перегрузка[](доступ к элементу строки по индексу, предусмотреть возможность обращения к несуществующему элементу.
    const char& operator[] (const int idx) const
    {
        if (idx >= length)
        {
            throw std::out_of_range("wrong index");
        }
        return str[idx];
    }
    //- перегрузка операции += (конкатенация String)
    MyString operator+= (const MyString& append)
    {
        resize(length + append.length + 1);
        strcat(str, append.str);
        return *this;
    }
    //- перегрузка операции += (конкатенация char*)
    MyString operator+= (const char* append)
    {
        resize(length + strlen(append) + 1);
        strcat(str, append);
        return *this;
    }
 
    MyString operator+= (const char append)
    {
        push_back(append);
        return *this;
    }
 
    //-перегрузка операции char* () - преобразование в char*
    /*operator char* ()const
    {
        return *this;
    }*/
    //- перегрузка операции int () - конвертация строки в целое число (если это возможно)
    /*operator int()const
    {
        return  *this;
    }*/
    //- перегрузка операции double () - конвертация строки в вещественное число (если это возможно)
    /*operator double()const
    {
        return  *this;
    }*/
 
 
};
//- перегрузка операции == (лексикографическое сравнение двух строк)
bool operator == (const MyString& c1, const MyString& c2)
{
    return strcmp(c1.str, c2.str) == 0;
}
//-перегрузка операции >
//-перегрузка операции <
//-перегрузка операции >=
//-перегрузка операции <=
//-перегрузка операции !=
bool operator > (const MyString& s1, const MyString& s2)
{
    return  strlen(s1.str) > strlen(s2.str);
}
bool operator < (const MyString& c1, const MyString& c2)
{
    return  strlen(c1.str) < strlen(c2.str);
}
bool operator >= (const MyString& c1, const MyString& c2)
{
    return  strlen(c1.str) >= strlen(c2.str);
}
bool operator <= (const MyString& c1, const MyString& c2)
{
    return  strlen(c1.str) <= strlen(c2.str);
}
bool operator != (const MyString& c1, const MyString& c2)
{
    return  strlen(c1.str) != strlen(c2.str);
}
//- перегрузка операции + (String + String)
MyString operator+ (const MyString& lhs, const MyString& rhs)
{
    MyString ret(lhs);
    ret += rhs;
    return ret;
}
//- перегрузка операции + (String + char*)
MyString operator+ (const MyString& lhs, const char* rhs)
{
    MyString ret(lhs);
    ret += rhs;
    return ret;
}
//-перегрузка операции + (char* +String)
MyString operator+ (const char* lhs, const MyString& rhs)
{
    MyString ret(lhs);
    ret += rhs;
    return ret;
}
//- перегрузка операции + (String + char)
MyString operator+ (const MyString& lhs, char rhs)
{
    MyString ret(lhs);
    ret += rhs;
    return ret;
}
//- перегрузка операции + (char + String)
MyString operator+ (char lhs, const MyString& rhs)
{
    MyString ret(1, lhs);
    ret += rhs;
    return ret;
}
//-перегрузка операции << (ostream&, String) - показ на экран
//- перегрузка операции >> (istream&, String) - ввод с клавиатуры
ostream& operator<< (ostream& out, const MyString& s)
{
    out << s.GetMyString();
    return out;
}
 
istream& operator>> (istream& in, MyString& s)
{
    char tmp[4096];
    in >> tmp;
    s = in ? tmp : MyString();
    return in;
}
 
 
 
 
 
void main()
{
    setlocale(0, "Russian");
    MyString a("other one");;
 
    MyString b("hello");
    MyString c = b;
    cout << a.GetMyString() << endl;
    cout << b.GetMyString() << endl;
    cout << c.GetMyString() << endl;
    cout << "========================\n";
    //- перегрузка операции =
    MyString x;
    x = b;
    cout << x.GetMyString() << endl;
    cout << "========================\n";
    //- перегрузка операции == (лексикографическое сравнение двух строк)
    cout << x.GetMyString() << endl;
    cout << b.GetMyString() << endl;
    cout << boolalpha << (x == b) << endl;
    cout << "========================\n";
    cout << a.GetMyString() << endl;
    cout << b.GetMyString() << endl;
    //-перегрузка операции >
    cout << boolalpha << (a > b) << endl;
    //-перегрузка операции <
    cout << boolalpha << (a < b) << endl;
    //-перегрузка операции >=
    cout << boolalpha << (a >= b) << endl;
    //-перегрузка операции <=
    cout << boolalpha << (a <= b) << endl;
    //-перегрузка операции !=
    cout << boolalpha << (a != b) << endl;
    cout << "========================\n";
    //-перегрузка[](доступ к элементу строки по индексу, предусмотреть возможность обращения к несуществующему элементу.
    cout << a.GetMyString() << endl;
    cout << a[2] << endl;
    cout << "========================\n";
    //-перегрузка операции += (конкатенация String)
    a += b;
    cout << a.GetMyString() << endl;
    cout << "========================\n";
    //- перегрузка операции += (конкатенация char*)
    b += "Russian";
    cout << b.GetMyString() << endl;
    cout << "========================\n";
    //-перегрузка операции + (String + String)
    MyString a1("hello");
    MyString a2("girl");
    MyString temp = a1 + a2;
    cout << temp.GetMyString() << endl;
    cout << "========================\n";
    //- перегрузка операции + (String + char*)
    char* d = "boy";
    MyString as = a1 + "boy";
    cout << as.GetMyString() << endl;
    cout << "========================\n";
    //- перегрузка операции + (char* + String)
    MyString sd = "boy" + a2;
    cout << sd.GetMyString() << endl;
    cout << "========================\n";
    //- перегрузка операции + (String + char)
    char zas[4] = "bag";
    MyString qw = a1 + zas;
    cout << qw.GetMyString() << endl;
    cout << "========================\n";
    //- перегрузка операции + (char + String)
    MyString dase = zas + a1;
    cout << dase.GetMyString() << endl;
    cout << "========================\n";
    //-перегрузка операции << (ostream&, String) - показ на экран
    //- перегрузка операции >> (istream&, String) - ввод с клавиатуры
    //MyString ssd;
    //cin >> ssd;
    //cout << ssd << '\n';
    cout << "========================\n";
    //- перегрузка () (повторная инициализация строки)
     
    cout << "========================\n";
    //-перегрузка операции char* () - преобразование в char*
     
    cout << "========================\n";
    //- перегрузка операции int () - конвертация строки в целое число (если это возможно)
 
    cout << "========================\n";
    //- перегрузка операции double () - конвертация строки в вещественное число (если это возможно)
 
 
}