小弟在自定义的String类时，重载了一个"+"。但出现了编译问题，请各位大哥指教一下。其程序如下：
#include<iostream>
using namespace std;

class String
{
public:
String();//ok
String(char *p) ;//ok
String(String &strs);//ok
~String();//ok

//===============成员函数===================
int length() const;//ok
int find(String &str);//ok

//===============运算符重载=====================
void operator =(String str);//ok
friend bool operator ==(String str1,String str2);//ok
friend bool operator <(String str1,String str2);//ok
friend bool operator >(String str1,String str2);//ok
friend String operator + (String str1,String str2);

//================流操作符重载===================
friend istream operator >>(istream &cin,String &str);//ok
friend ostream operator <<(ostream &cout,String &str);//ok

char operator [](int n) const;//ok

private:
char *strp=new char[256];
};

//不带参数的构造函数的实现
String::String()
{
strp[0]=NULL;
}

//带参数的构造函数的实现
String::String(char *p)
{
for(int i=0;p[i]!=NULL;i++)
strp[i]=p[i];
strp[i]=NULL;
}

//深拷贝构造函数的实现
String::String(String &strs)
{
for(int i=0;strs.strp[i]!=NULL;i++)
strp[i]=strs.strp[i];
strp[i]=NULL;
}

//析构函数的实现
String::~String()
{
if(strp)delete [] strp;
}

//========================成员函数的实现=========================
int String::length() const
{
return strlen(strp);
}

//======================运算符重载的实现===============================
void String::operator = (String str)
{
if(strp) delete [] strp;
for(int i=0;str.strp[i]!=NULL;i++)
strp[i]=str.strp[i];
strp[i]=NULL;
}

String operator +(String str1,String str2)
{
int l1 = strlen(str1.strp),l2 = strlen(str2.strp);
char *str0=new char(l1+l2+1);
for(int i=0;i<l1;i++)
str0[i]=str1.strp[i];
for(int j=l1;j<(l1+l2);j++)
str0[j]=str2.strp[j-l1];
str0[l1+l2]=NULL;

return String(str0);
}

char String::operator [](int n) const
{
return *(strp+n);
}

//===================== 比较运算符重载的实现=======================
bool operator ==(String str1,String str2)
{
if(str1.length()!=str2.length())
return false;
else
{
for(int i=0;i<str1.length();i++)
{
if(str1.strp[i]!=str2.strp[i])
return false;
}
return true;
}
}

bool operator <(String str1,String str2)
{
if(str1==str2)
return false;
else
{
for(int i=0;str1.strp[i]!=str2.strp[i];i++){}
return (str1.strp[i]<str2.strp[i]);
}
}

bool operator >(String str1,String str2)
{
if(str1==str2)
return false;
else
{
for(int i=0;str1.strp[i]!=str2.strp[i];i++){}
return (str1.strp[i]>str2.strp[i]);
}
}

//=====================流操作符重载的实现=====================
istream operator >>(istream &cin,String &str)
{
cin>>str.strp;
return cin;
}
ostream operator <<(ostream &cout,String &str)
{
cout<<str.strp;
return cout;
}

//====================find函数重载的实现=======================
int String::find(String &str)
{
int len=length();
if(len<str.length())
return -1;
else
{
int i,j,k=0;
f: for(i=k;strp[i]!=str[0]&&i<len;i++){}
if(len-i<str.length())
return -1;
else
{
for(j=0;j<str.length();j++)
{
if(strp[i+j]!=str[j])
break;
}
if(j==str.length())
return i;
else
{
k=i+1;
goto f;
}
}
}
}

//====================main=============================
int main()
{
String s1,s2,s3;
cin>>s1>>s2;
s3=s1+s2;
cout<<s3<<endl;
for(int i=0;i<s3.length();i++)
cout<<s3[i];
cout<<endl;
if(s1>s2)
cout<<s1<<" is more larger than "<<s2<<endl;
cout<<s3.find(s2)<<endl;
return 0;
}