Overloading insertion and extraction operators for strings

Question

I would like to implement both of these functions so that I would be able to input and output objects of my class. I have gotten the >> operator to work but not so much <<.

Here is my code in my .h file:

    class MyString
    {
        public:
            MyString();
            MyString(char *message);
            ~MyString();
            void Print();



            void Copy(MyString& rhs);
            int Length();

            MyString& operator()(const int index, const char b);
            char& operator()(const int i);
            MyString& operator=(const MyString& rhs);
            bool operator==(const MyString& other) const;
            bool operator!=(const MyString& other) const;
            const MyString operator+(const MyString& rhs) const;

            MyString& operator+=(const MyString& rhs);

       private:

            char *String;
            int Size;
    };

    istream& operator>>(istream& input, MyString& rhs);
    ostream& operator<<(ostream& output, const MyString& rhs);

Here is my code for the two functions in my .cpp file:

 MyString::MyString()
{
    char temp[] = "Hello World";

    int counter(0);
    while(temp[counter] != '\0') {
            counter++;
    }
    Size = counter;
    String = new char [Size];
    for(int i=0; i < Size; i++)
            String[i] = temp[i];

}
MyString::MyString(char *message)
 {

    int counter(0);

    while(message[counter] != '\0') {
            counter++;
    }
    Size = counter;
    String = new char [Size];
    for(int i=0; i < Size; i++)
            String[i] = message[i];

}

  MyString::~MyString()
  {
    delete [] String;
  }
 int MyString::Length()
  {
    int counter(0);

    while(String[counter] != '\0')
    {
            counter ++;
    }





    return (counter);
  }

const MyString MyString::operator+(const MyString& rhs) const
 {

    char* tmp = new char[Size + rhs.Size +1];

    for(int i = 0; i < Size; i++)
    {
            tmp[i] = String[i];
    }
    for(int i = 0; i < rhs.Size+1; i++)
    {
             tmp[i+Size] = rhs.String[i];
   }

const MyString MyString::operator+(const MyString& rhs) const
  {

    char* tmp = new char[Size + rhs.Size +1];

    for(int i = 0; i < Size; i++)
    {
            tmp[i] = String[i];
    }
    for(int i = 0; i < rhs.Size+1; i++)
    {
            tmp[i+Size] = rhs.String[i];
    }

    MyString result;


    delete [] result.String;
    result.String = tmp;
    result.Size = Size+rhs.Size;

    return result;

  }
MyString& MyString::operator()(const int index, const char b)
 {
    if(String[index] == '\0')
    {
            exit(1);
    }
    else
    {

            String[index] = b;
    }


  }

MyString& MyString::operator=(const MyString& rhs)
 {

    if(this != &rhs)
    {

            delete [] String;
            String = new char[rhs.Size];
            Size = rhs.Size;

    for(int i = 0; i < rhs.Size+1 ; i++)
    {
            String[i] = rhs.String[i];
    }



    }

    return *this;


 }
  void MyString::Copy(MyString& rhs)
 {
    delete [] String;
    Size = rhs.Size;
    String = new char[rhs.Size];

    String = rhs.String;
  }

MyString& MyString::operator+=(const MyString& rhs)
  {

    char* tmp = new char[Size + rhs.Size + 1];

    for(int i = 0; i < Size; i++)
    {
            tmp[i] = String[i];
    }

    for(int i = 0; i <rhs.Size+1; i++)
    {
            tmp[i+Size] = rhs.String[i];
    }


    delete [] String;
    String = tmp;

    Size += rhs.Size;

    return *this;


 }

bool MyString::operator!=(const MyString& other) const
 {

    return !(*this == other);


  }
bool MyString::operator==(const MyString& other)const
  {
    if(other.Size == this->Size)
    {
            for(int i = 0; i < this->Size+1; i++)
            {
                    if(&other == this)

                            return true;
            }
    }
    else
            return false;
  }

 char& MyString::operator()(const int i)
{

    if( String[i] == '\0')
    {
            exit(1);
    }
    else
    {

    return String[i];

      }
 }



   void MyString::Print()
 {
    for(int i=0; i < Size; i++)
            cout << String[i];
    cout << endl;

  }




istream& operator>>(istream& input, MyString& rhs)
{
    char* temp;
    int size(256);
    temp = new char[size];
    input.getline(temp,size);
    rhs = MyString(temp);
    delete [] temp;

    return input;
}

ostream& operator<<(ostream& output, const MyString& rhs)
{
    char* p;
    int size(256);
    p = new char[size];
    output << rhs.MyString(p);
    delete [] p;
    return output;
}

Here is how it is called in the main.cpp file:

cin >> SearchString >> TargetString; // Test of cascaded string-extraction operator<</*

if(SearchString.Find(ConstString) != -1) {       
  cout << ConstString << " is not in " << SearchString << endl;  } 

else {       
  cout << ConstString << " is in " << SearchString << endl;
  cout << "Details of the hit: " << endl;       
  cout << "Starting poisition of the hit: " << SearchString.Find(ConstString) << endl;                
  cout << "The matching substring is: " << SearchString.Substring(SearchString.Find(ConstString), ConstString.length()); }

Again, the cin>> operator works perfectly but please help me to figure out how to output the string.

Answer 1

Not really sure what you are asking. The implementation depends on how you want to output the string.

For some raw output the code will most likely look like this:

output << rhs.get_data();