Перегрузка операторов +,-,+=,-=...

mString&[COLOR="Red"](должен быть void)[/COLOR] mString::operator+=(const mString &string)
{
     int l=strlen(string.getStr());
    _str=new char[l+1];                   //получаете стоку из кракозябр с неопределенным концом, так как конец строки - должен быть '\0';
    _str=strcat(_str,string.getStr()); //объеденяете кракозябры неопределенной длины со вторым словом!
//    return _str;
}

void mString::operator+=(const mString &string)
{
      char* buffer = strcat(_str,string.getStr()); //объеденяем строки
      delete _str;    //освобождаем текущую строку
      _str = buffer;  //принимаем объеденную за текущую
}

#include <stdio.h>
#include <iostream.h>
#include <string.h>

using namespace std;
class mString
{
private:
    char *_str;
public:
    char* getStr(void)const ;
    void setStr(char *str);
    mString(const char *ch);
    mString(const mString &string);
    mString();
    ~mString();
    mString& operator=(const mString &str);
    mString& operator+=(const mString &str);
    mString& operator+=(const char *);
    mString& operator-=(const mString &str);

    char operator[] (size_t idx) const {return _str[idx];}
     char& operator[] (size_t idx) {return _str[idx];}
};

//Constructor get NULL parameters
mString::mString()
{
   _str =NULL;
}


mString::~mString()
{
  if(_str)
    delete[] _str;
}



//Constructor get OBJ
mString::mString(const mString &string)
{
    int l=strlen(string.getStr());
    _str=new char[l+1];
    strcpy(_str,string.getStr());
}

//Constructor get String
mString::mString(const char *ch)
{
    int l=strlen(ch);
    _str=new char[l+1];
    strcpy(_str,ch);
}

//A new line-length jobs
char* mString::getStr(void)const
{
    return _str;
}

void mString::setStr(char *str)
{
     int l=strlen(str);
     _str =new char[l+1];
    strcpy(_str,str);
}

mString& mString::operator=(const mString &string)
{
    int l=strlen(string.getStr());
    _str=new char[l+1];
    strcpy(_str,string.getStr());
    return *this;
}


ostream& operator << (ostream& os, const mString& str)
{
    os<<str.getStr()<<endl;
    return os;
}

//Перегружаемые функции +
//################################################################
static const mString operator+( mString &strL, mString &strR)
{
    mString t=strL;
    t+=strR;
    return t;
}


static const mString operator+(char *strL, mString &strR)
{
     int l=strlen(strL);
        mString t;
     t.setStr(strL);
    t+=strR;
    return t;
}

static const mString operator+( mString &strL, char *strR)
{

    mString tmp;
    tmp.setStr(strR);
    strL+=tmp;
    return strL;
}


//Перегружаемые функции -
//################################################################
static const mString operator - (const mString &strL, mString &strR)
{
    mString tmp1;
    mString tmp2;
    int L = strlen(strL.getStr());
    int R = strlen(strR.getStr());

     char* nv1=NULL;
    char* nv2=NULL;

     int i=0;

    for(i=L-1; i>=0; --i)
    {
      if(strL.getStr() != ' ')
      {
          nv1=new char;
          strncpy(nv1,strL.getStr(),i+1);
          i=0;
      }
    }

     int k=0,j=0;
    for(j=0; j<R-1; ++j)
    {
      if(strR.getStr()[j] != ' ') {k = j; break;}
    }

    nv2=new char[(j-k)+1];
    for(j=0; j<R; ++j)
    {
       nv2[j]=strR.getStr()[j+k];
    }

    tmp1.setStr(nv1);
    tmp2.setStr(nv2);

//  cout<<"tmp1->>"<<tmp1.getStr();
//  cout<<"tmp2->>"<<tmp2.getStr();

    tmp1+=tmp2;
    return tmp1;
}

//Перегружаемые функции +=, -=
//################################################################
mString& mString::operator+=(const mString &string){
    int l=strlen(string.getStr())+strlen(_str);
    char* nv=new char[l+1];
    strcpy(nv,_str);
    delete[] _str;
    _str=strcat(nv,string.getStr());
    return *this;
}



//Переопределить метод +=?
//для возможности вызова таким образом z="super hello"+=a;
//или же описать ещё одну фцию mString operator+=(const char *str, const mString& s);
mString& mString::operator+=(const char *str){
    int l=strlen((str)+strlen(_str));
    char* nv=new char[l+1];
    strcpy(nv,str);
//    delete[] str;
//    _str=strcat(nv,string.getStr());
    return *this;
}




mString& mString::operator-=(const mString &string)
{
    int l=strlen(string.getStr())+strlen(_str);
    char* nv=new char[l+1];
    strcpy(nv,_str);
    delete[] _str;
    _str=strcat(nv,string.getStr());
    return *this;
}







int main(void)
{
    mString str1="Super Mega   ";
    mString str2="                      Max";
    mString str_n;
    mString a = "first", b = "second", z;

    cout<<"1= "<<str1;
     cout<<"2= "<<str2;


     z=a+b;
     cout<<"3= "<<z;

     z="hello"+a;
     cout<<"4= "<<z;

     z=a+"hello";
     cout<<"5= "<<z;

     z=str1-str2;
     cout<<"6= "<<z;

     z = a+=b;
     cout<<"7= "<<z;


     cout<<"8= "<< a[6] <<"\n";
     cout<<"9= "<< a[1] <<"\n";

     z=a=b;
     cout<<"10= "<<z;

     (z=a)=b;
     cout<<"11= "<<z;

     (z="hello")+=a;
     cout<<"12= "<<z;

     (z="mega hello")-=a;
     cout<<"14= "<<z;


//   z="super hello"+=a;
//   cout<<"15= "<<z;

//   ( z + a ) = b; NO

    return 0;
}