MyString Class Segmentation Fault

[oatmeal678]

I am doing a program for creating a simple string class using c-strings and dynamically allocated memory. Somewhere along the line I have done something wrong and I am getting a segementation default when I run my driver program with my cpp file.
Here is my code:

#ifndef MYSTRING_H
#define MYSTRING_H
#include <iostream>
using namespace std;

class MyString
{
  friend ostream& operator<< (ostream& , const MyString& );
  friend istream& operator>> (istream& , MyString& );
  friend istream& getline (istream& , MyString& , char delim = '\n');

  friend MyString operator+ (const MyString& , const MyString& );

  friend bool operator< (const MyString& , const MyString& );
  friend bool operator> (const MyString& , const MyString& );
  friend bool operator<=(const MyString& , const MyString& );
  friend bool operator>=(const MyString& , const MyString& );
  friend bool operator==(const MyString& , const MyString& );
  friend bool operator!=(const MyString& , const MyString& );

public:
  MyString();				// empty string
  MyString(const char* );		// conversion from c-string
  MyString(int );			// conversion from int
  ~MyString();				// destructor
  MyString(const MyString& );		// copy constructor
  MyString& operator=(const MyString& );   // assignment operator

  MyString& operator+=(const MyString& );  // concatenation/assignment

  // bracket operators to access char positions
  char& operator[] (unsigned int index);
  const char& operator[] (unsigned int index) const;

  // insert s into the string at position "index"
  MyString& insert(unsigned int index, const MyString& s);

  // find index of the first occurrence of s inside the string
  //  return the index, or -1 if not found
  int indexOf(const MyString& s) const;
  
  int getLength() const;		// return string length
  const char* getCString() const;	// return c-string equiv

  MyString substring(unsigned int , unsigned int ) const;
  MyString substring(unsigned int ) const;

private:

char * str;
int size;


};
#endif 

//begin of .cpp file
#include <iostream>
#include <cstring>
#include <cctype>
#include <iomanip>
#include "mystring.h"

MyString::MyString()
{
	size = 0;
	str = new char[size+1];
	str = NULL;
}                           

MyString::MyString(const char* s)
{
	size = strlen(s);
	str = new char[size+1];
	strcpy(str,s);
	str[size]='\0';
}               

MyString::MyString(int convert)
{
	int con = convert;
	int counter = 0;

	do	
	{
		con = con / 10;
		counter++;
	}while(con != 0);
	
	size = counter + 1;
	str = new char[size];
 	
	do	
	{
		str[counter - 1] = char((convert % 10) + 48);
		convert = convert / 10;
		counter--;
	}while(counter >= 1);
	str[size] = '\0';
}                       

MyString::~MyString()
{
	delete [] str;
}                          

MyString::MyString(const MyString& second)
{
	size = second.size;
	str = new char[size+1];
	strcpy(str,second.str);
}

MyString& MyString::operator=(const MyString& second )
{
        
	if (this != &second)
        {
                delete []str;
		size = strlen(second.str);
                str = new char[size+1];
                strcpy(str,second.str);
		str[size]='\0';
        }
	
                return *this;
}

MyString& MyString::operator+=(const MyString& first)
{
   	size += first.size;
   	char  *temp = str;
   	str = new  char[size+1];
   	strcpy(str,temp);
   	strcat(str,first.str);
   	delete  [] temp;
   	return  *this;
}

ostream& operator<< (ostream& os, const MyString& s)
{
	os << s;
	return os;
}

istream& operator>> (istream& is, MyString& s)
{
	int maxsize = 0;
	int index = 0;
	char* buffer = new char[maxsize];	     
	
	while(isspace(is.peek()))	
		is.ignore();

	while((!isspace(is.peek())) && (!is.eof())) 
	{
		char* tempstring = new char[maxsize + 1];
		is >> buffer[index];

		for(int i = 0; i < maxsize; i++)
			tempstring[i] = buffer[i];

		index++;
		maxsize++;
		delete [] buffer;
		buffer = tempstring;
	}
	
	buffer[index] = '\0';
	delete [] s.str;	
	s.str = buffer;
	return is;
}

istream& getline (istream& is, MyString& s, char delim)
{
	int index = 0;
	int buffersize = 10;
	char* buffer = new char[buffersize];  

	do
	{
		if(!is.eof())
		{
			if(index < buffersize - 1)
			{	
				buffer[index] = is.get();
				index++;
			}
			else
			{
				buffersize++;
				char* temp = new char[buffersize];

				for(int i = 0; i < index; i++)
					temp[i] = buffer[i];
				
				temp[index] = is.get();
				index++;
				delete [] buffer;
				buffer = temp;
			}
		}			
	}while((is.peek() != delim) && (!is.eof()));	
	is.ignore();					
	
	buffersize = index + 1;
	buffer[index] = '\0';
	delete [] s.str;			
	s.str= buffer;
	s.size= buffersize;
	return is;		
}

MyString operator+ (const MyString& first, const MyString& second)
{
	MyString s = first;
   	s += second;
   	return  s; 
}

char& MyString::operator[] (unsigned int index)
{
	//assert aborts program with error message
	if(index>=0 && index < strlen(str))
	{
		cout << "Not Valid";
		
	}
	return str[index];
}

const char& MyString::operator[] (unsigned int index) const
{
	if(index>=0 && index < strlen(str))
	{
		cout << "Not Valid";
		
	}
	return str[index];
}

MyString& MyString::insert(unsigned int index, const MyString& s)
{
	if(index <= size - 1)	
	{
		char* tempstring = new char[size + s.size - 1];
		
		for(int i = 0; i < index; i++)
			tempstring[i] = str[i];

		for(int i = 0; i < s.size - 1; i++)
			tempstring[i + index] = s.str[i];

		for(int i = index + s.size - 1; i < size + s.size -2; i++)
			tempstring[i] = str[i - s.size +1];

		tempstring[size + s.size -2] = '\0';
		delete [] str;
		str = tempstring;
		size = size + s.size - 1;
	}
	else				
	{
		char* tempstring = new char[size + s.size - 1];

		for(int i = 0; i < size - 1; i++)
			tempstring[i] = str[i];

		for(int i = 0; i < s.size - 1; i++)
			tempstring[size - 1 + i] = s.str[i];

		tempstring[size + s.size - 2] = '\0';
		delete [] str;
		str = tempstring;
		size = size + s.size - 1;
	}
		return *this;  
}


int MyString::indexOf(const MyString& s) const
{
	if(size < s.size)	
		return -1;
	else if(size == s.size)	
	{
		int i = 0;

		while((str[i] == s.str[i]) && (str[i] != '\0'))
			i++;

		if(str[i] == '\0')
			return 0;
		else
			return -1;
	}
	else					
	{
		int index = 0;

		while(index < (size - s.size + 1))
		{	
			int j = 0;
			int k = 0;
			while((s[0] != str[index]) && (index < (size - s.size + 1)))
				index++;
		
			if(index == size - s.size + 1)
				return -1;
			else
			{
				k = index;
				while((s[j] == str[k]) && (s[j] != '\0'))
				{
					k++;
					j++;
				}

				if(s[j] == '\0')
					return index;
				else
					index++;
			}
		}
	}	
}

int MyString::getLength() const
{
	return size;
}

const char* MyString::getCString() const
{
	return str;
}

MyString MyString::substring(unsigned int index, unsigned int sz ) const
{
	MyString sub = substring(index);
	
	if(sub.size - 1 <= sz)
	{
		return sub;
	}
	else
	{
		char* tempstring = new char[sz + 1];
		
		for(int i = 0; i < sz; i++)
		{
			tempstring[i] = sub.str[i];
		}
		
		tempstring[sz] = '\0';
		delete [] sub.str;
		sub.str = tempstring;
		sub.size = sz + 1;
		return sub;
	}
}

MyString MyString::substring(unsigned int index) const
{
	MyString sub;
	int tempsize = size - index;
	
	if(tempsize <= 1)
	{
		sub.str = '\0';
		sub.size = 1;
	}
	else
	{
		char* tempstring = new char[tempsize];
		
		for(int i = 0; i < tempsize - 1; i++)
		{
			tempstring[i] = str[i + index];
		}
		
		tempstring[tempsize - 1] = '\0';	
		delete [] sub.str;
		sub.str = tempstring;
		sub.size = tempsize;
	}
	return sub;
}


bool operator< (const MyString& first, const MyString& second)
{
	return strcmp(first.str,second.str)<0;
}

bool operator> (const MyString& first, const MyString& second)
{
	return strcmp(first.str,second.str)>0;
}

bool operator<=(const MyString& first, const MyString& second)
{
	return strcmp(first.str,second.str)<=0;
}

bool operator>=(const MyString& first, const MyString& second)
{
	return strcmp(first.str,second.str)>=0;
}

bool operator==(const MyString& first, const MyString& second)
{
	return strcmp(first.str,second.str)==0;
}

bool operator!=(const MyString& first, const MyString& second)
{
	return strcmp(first.str,second.str)!=0;
}

[Peter87]

Well, one mistake seems to be in the copy constructor.

Instead of strlen(second.str + 1) I think you want strlen(second.str) + 1.

You've also forgot to update the size.