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.

You know that there is a `getline()` function that reads `std::string`, right? — Šimon Tóth, Apr 30 '12 at 12:58
I've used getline() to implement the >> operator, but I can use that to implement << as well?? — user1363061, Apr 30 '12 at 13:10
No, I was pointing out that you are using the `char*` variant of `getline()`. There is a `std::string` variant. As for the `<<` operator, since `getline()` reads from the stream and you want to write to the stream, then logically no, you can't use `getline()`. — Šimon Tóth, Apr 30 '12 at 13:12

score 2 · Answer 1 · answered Apr 30 '12 at 13:01

2

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();

answered Apr 30 '12 at 13:01

Šimon Tóth

35,456
20
106
151

would that be output = rhs.get_data(); ?? – user1363061 Apr 30 '12 at 13:11
`output` is a stream, just like `cout`. Your operator<< function should write data from `rhs` to `output` using statements like `output << rhs.foo()` or `output << rhs.bar()`. – Nate Kohl Apr 30 '12 at 13:14
@user1363061 How do you get the content of your string? It will be `rhs.something()`. So just write `output << rhs.something();`. – Šimon Tóth Apr 30 '12 at 13:15
so would I have to implement an additional function for get_data()? – user1363061 Apr 30 '12 at 13:18
@user1363061 Well, how do you access the content of your string? – Šimon Tóth Apr 30 '12 at 13:21
I have edited my code, can you please give me some feedback on it? – user1363061 Apr 30 '12 at 13:23
usually rhs.String, String is defined in the class. but in this case would I use rhs.MyString(p); just the same as I had in the >> definition? – user1363061 Apr 30 '12 at 13:26
@user1363061 You are trying to call the constructor on an existing object. You can't do that. – Šimon Tóth Apr 30 '12 at 13:26
It's that one line that's giving me trouble. I understand logically that I need to place the rhs to output but I am not sure how at all – user1363061 Apr 30 '12 at 13:28
let us [continue this discussion in chat](http://chat.stackoverflow.com/rooms/10701/discussion-between-let-me-be-and-user1363061) – Šimon Tóth Apr 30 '12 at 13:31

Overloading insertion and extraction operators for strings

1 Answers1