相关类的实现------字符串

字符串类的实现

主要涉及类的成员，以及构造函数，析构函数，重载运算符等基本类型的实现
主要注意的是内存的申请与释放，避免内存泄漏！

#include<iostream>
#include<ostream>
#include<istream>
#include<cstring>
#include<cstddef>
using namespace std;

/*
注意，类的成员函数中，有一些是加了const修饰的，表示这个函数不会对类的成员进行任何修改。
一些函数的输入参数也加了const修饰，表示该函数不会对改变这个参数的值。
*/

class String{
public:
    String(const char* str=nullptr);
    String(const String &str);
    ~String();

    String operator+(const String &str) const;
    String& operator=(const String &str);
    String& operator+=(const String &str);
    bool operator==(const String &str) const;
    char& operator[] (int n) const;

    size_t size() const;
    const char* c_str() const;

    friend istream& operator>>(istream& is,String &str);
    friend ostream& operator<<(ostream& os,String &str);

//private:
    char *data;        //字符串
    size_t length;     //长度
};

String::String(const char* str){       //通用构造函数
    if(!str){
        length=0;
        data=new char[1];
        *data='\0';
    }
    else{
        length=strlen(str);
        data=new char[length+1];
        strcpy(data,str);
    }
}

String::String(const String &str){    //拷贝构造函数(深拷贝)
    length=str.size();
    data=new char[length+1];
    strcpy(data,str.data);
}

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

/*重载字符串连接运算，这个运算会返回一个新的字符串。*/
String String::operator+(const String &str) const{
    String newString;
    newString.length=length+str.size();
    newString.data=new char[newString.length+1];
    strcpy(newString.data,data);
    strcat(newString.data,str.data);
    return newString;
}

/*重载字符串赋值运算，这个运算会改变原有字符串的值，为了避免内存泄露，这里释放了原先申请的内存再重新申请一块适当大小的内存存放新的字符串。*/
String& String::operator=(const String &str){
    if(this==&str) return *this;
    delete[] data;
    length=str.length;
    data=new char[length+1];
    strcpy(data,str.data);
    return *this;
}

/*重载字符串+=操作，总体上是以上两个操作的结合。*/
String& String::operator+=(const String &str){
    length+=str.length;
    char* newData=new char[length+1];
    strcpy(newData,data);
    strcat(newData,str.data);
    delete[] data;
    data=newData;
    return *this;
}

/*重载相等关系运算，这里定义为内联函数加快运行速度。*/
inline bool String::operator==(const String &str) const{
    if(length!=str.length) return false;
    return strcmp(data,str.data)?false:true;
}

/*重载字符串索引运算符，进行了一个简单的错误处理，当长度太大时自动读取最后一个字符。*/
inline char& String::operator[](int n) const   //重载[]
{
    if (n >= length) return data[length-1];    //错误处理
    else return data[n];
}

/*重载两个读取私有成员的函数，分别读取长度和C字符串。*/
inline size_t String::size() const//获取长度
{
    return length;
}

inline const char* String::c_str() const{
   return data;
}

istream& operator>>(istream &is,String &str){
    char temp[1000];
    is>>temp;
    str.length=strlen(temp);
    str.data=new char [str.length+1];
    strcpy(str.data,temp);
    return is;
}

ostream& operator<<(ostream &os,String &str){
    os<<str.data;
    return os;
}

int main()
{
    String s;
    cin >> s;
    cout << s << ": " << s.size() << endl;

    char a[] = "Hello", b[] = "World!";
    String s1(a), s2(b);
    String m=s1+s2;
    cout<<s1<<" + "<<s2<<" = "<<m<< endl;

    String s3 = s1 + s2;
    if (s1 == s3)    cout << "First: s1 == s3" << endl;
    s1 += s2;
    if (s1 == s3)    cout << "Second: s1 == s3" << endl;
    return 0;
}