字符串类string类模板

#include 
   
   
    
    
using namespace std;
#define MAX 200

class String
{
private:
    char *m_data;
    int count;//字符串长度
public:
    String();//构造函数
    ~String();//析构函数
    String(const String &s);//拷贝构造函数
    String(const char *s);//有字符串作为参数传入构造函数
    String(int x);//指定长度的构造函数
    bool empty();//返回字符串是否为空
    const int size();//返回字符串的长度
    String operator+(const String &s) const;//重载+运算符，用于拼接字符串
    const String &operator=(const String &s);//重载=运算符
    friend ostream &operator<<(ostream &output,const String &s)//输出
    {
        output<
    
    
     
     >(istream &input,String &s)//输入
    {
        input>>s.m_data;
        s.count=strlen(s.m_data);
        return input;
    }
    char operator[](int x) const;//重载[]
    friend String m_Substr(const String &s, int S, int len);//取子串操作
};

String::String() //构造函数
{
    m_data=new char[MAX];
    count=0;
}

String::String(int x)
{
    m_data=new char[x+1];
    count=x;
}

String::~String() //析构函数
{
    delete []m_data;
    count=0;
}

String::String(const char *s)//有字符串作为参数传入构造函数
{
    if(!s) {//如果传入字符串为空字符串
        count = 0;
        m_data=new char[1];
        *m_data='\0';
    }
    else{
        m_data=new char[strlen(s)+1];
        count=strlen(s);
        strcpy(m_data,s);
    }
}

String::String(const String &s) //拷贝构造函数
{
    m_data=new char[s.count+1];//最后一位加上'\0'
    count=s.count;
    strcpy(m_data,s.m_data);
    m_data[count]='\0';
}

bool String::empty() //返回字符串是否为空
{
    return count==0;
}

const int String::size() //返回字符串的长度
{
    return count;
}

String String::operator+(const String &s) const//重载+运算符，用于拼接字符串
{
    String str(count+s.count);
    strcpy(str.m_data,m_data);
    strcat(str.m_data,s.m_data);
    return str;
}

const String &String::operator=(const String &s) //重载=运算符
{
    if(this==&s)
        return *this;
    delete[]m_data;//释放原有空间
    count=s.count;
    m_data=new char[count+1];
    strcpy(m_data,s.m_data);
    return *this;
}

char String::operator[](int x) const//重载[]
{
    return m_data[x];
}

String m_Substr(const String &s, int S, int len)//取子串操作
{
    String temp(len
     
     
      
      > s[1] >> s[2];
    int i, j, k, l, S;
    char order;
    while (cin >> order) {
        switch (order) {
            case 'A':
                cin >> i >> j;
                s[j] = s[i];
                break;
            case 'C':
                cin >> i >> j >> k;
                s[k] = s[i] + s[j];
                break;
            case 'F':
                cin >> i >> S >> l >> k;
                s[k] = m_Substr(s[i], S, l);
                break;
            case 'P':
                cin >> i;
                cout << s[i] << endl;
                break;
        }
    }
    return 0;
}