String

请实现String类
主程序(C/C++)

//#include <string>
#include <iostream>
using namespace std;

#include "source.cpp" // must include

int main() {
    String text = "good";
    String text2("good");
    text = "Good";
    text += " morning";
    text2.append(" morning");
    cout << text << endl;
    cout << text.size() << endl;
    text2 = text + ".";
    text2 = ">" + text2;
    text.at(3) = 'D';
    text[3] = 'D';
    cout << text.at(3) << endl;
    cout << text[3] << endl;
    cout << text.compare(text2) << endl;
    cout << (text < text2) << endl;
    cout << (text <= text2) << endl;
    cout << (text > text2) << endl;
    cout << (text >= text2) << endl;
    cout << (text == text2) << endl;
    cout << (text != text2) << endl;
    
    cout << text.find("morn") << endl;
    cout << (text.find("morn", 7) == -1) << endl; // unsigned long
    text.erase(5, 4);
    cout << text << endl;
    text.insert(5, "morn");
    cout << text << endl;
    text.replace(5, 4, "MORN");
    cout << text << endl;    
}

答案

#include <cstring> // <string.h>

class String
{
private:
    char * ptr;
    
    void _copy(const char text[]) {
        ptr = new char[strlen(text)+1];
        strcpy(ptr, text);
    }
    
public:
    String() {
        ptr = new char[1];
        ptr[0] = 0;
    }
    
    String(const char text[]) {
        _copy(text);
    }
    
    const char * c_str() const {
        return ptr;
    }
    
    String(const String & s) {
        _copy(s.ptr);
    }
    
    ~String() {
        delete [] ptr;
    }
    
    String & operator = (const String & s) {
        delete [] ptr;
        _copy(s.ptr);
        return *this;
    }
            
    String & append(const String & s) {
        char * tmp = new char[strlen(ptr)+strlen(s.ptr)+1];
        strcpy(tmp, ptr);
        strcpy(tmp+strlen(ptr), s.ptr);
        delete [] ptr;
        ptr = tmp;
        return *this;
    }
    
    String & operator += (const String & s) {
        return append(s);
    }
    
    char & at(int index) const {
        return ptr[index];
    }
    
    char & operator [] (int index) const {
        return ptr[index];
    }
        
    int compare(const String & s) const {
        return strcmp(ptr, s.ptr);
    }
    
    bool operator < (const String & s) const {
        return strcmp(ptr, s.ptr) < 0;
    }
    
    bool operator <= (const String & s) const {
        return strcmp(ptr, s.ptr) <= 0;
    }
    
    bool operator > (const String & s) const {
        return strcmp(ptr, s.ptr) > 0;
    }
    
    bool operator >= (const String & s) const {
        return strcmp(ptr, s.ptr) >= 0;
    }
    
    bool operator == (const String & s) const {
        return strcmp(ptr, s.ptr) == 0;
    }
    
    bool operator != (const String & s) const {
        return strcmp(ptr, s.ptr) != 0;
    }
        
    unsigned long find(const String & s, int from=0) const {
        int n = strlen(s.ptr);
        int cmp_times = strlen(ptr) - n + 1 - from;
        for (int i = 0; i < cmp_times; ++ i) {
            if (strncmp(ptr+from+i, s.ptr, n) == 0) return from+i;
        }
        return -1;
    }
    
    String substr(int from, int len=-1) const {
        String s(ptr+from);
        if (len >= 0)
            s.ptr[len] = 0;
        return s;
    }
    
    String & replace(int from, int len, const String & s) {
        String tmp = substr(0, from);
        tmp += s;
        tmp += substr(from+len);
        *this = tmp;
        return *this;
    }
    
    String & erase(int from, int len) {
        return replace(from, len, "");    
    }
    
    String & insert(int to, const String & s) {
        return replace(to, 0, s);    
    }
    
    unsigned long size() const {
        return strlen(ptr);
    }

};

#include <iostream>
using namespace std;

ostream & operator << (ostream & o, const String & s) {
    o << s.c_str();
    return o;
}

char buf[1000];

istream & operator >> (istream & in, String & s) {
    in >> buf;
    s = buf;
    return in;
}

String operator + (const String & left_op, const String & right_op) {
    String tmp(left_op);
    tmp += right_op;
    return tmp;
}

我的答案

#include <cstring>
#include <iostream>
using namespace std;

class String
{
private:
    char * array;
    
    void __assign(const char text[]){
        if(array!=0){
            delete [] array;
        }
        int length = strlen(text);
        array = new char[length+1];
        strcpy(array,text);
    }
public:
    String(){
        array = new char[1];
        array[0] = '\0';
    }
    
    String(const String & str){
        array=0;
        __assign(str.array);
    }
    
    String & operator = (const String & str){
        __assign(str.array);
        return (*this);
    }
    
    ~String(){
        delete [] array;
    }
    
    String(const char text[]){
        array=0;
        __assign(text);
    }
        
    void assign(const String & str){
        __assign(str.array);
    }
    
    int size() const{
        return strlen(array);
    }
    
    void append(const String & str){
        int length = strlen(array);
        int length2 = strlen(str.array);
        char * array2 = new char[length + length2 + 1];
        strncpy(array2,array,length);
        strncpy(array2+length,str.array,length2+1);
        delete [] array;
        array=array2;
    }
    
    String operator += (const String & str){
        append(str.array);
        return (*this);
    }
    
    const char * c_str() const{
        return array;
    }
    
    char & at(int index) const{
        return array[index];
    }
    
    char & operator [] (int index) const{
        return array[index];
    }
    
    int compare(const String & str) const{
        return strcmp(array,str.array);
    }
    
    bool operator < (const String & str) const{
        return compare(str)<0;
    }
    
    bool operator <= (const String & str) const{
        return compare(str)<=0;
    }
    
    bool operator > (const String & str) const{
        return compare(str)>0;
    }
    
    bool operator >= (const String & str) const{
        return compare(str)>=0;
    }
    
    bool operator == (const String & str) const{
        return compare(str)==0;
    }
    
    bool operator != (const String & str) const{
        return compare(str)!=0;
    }
        
    String substr(int start) const{
        String str(array + start);
        return str;
    }
    
    String substr(int start, int length) const{
        String str(array+start);
        str.array[length]='\0';
        return str;
    }
    
    int find(const String & str,int start) const{
        int length = strlen(array);
        int length2 = strlen(str.array);
        int end = length - length2;
        for (int i = start; i <= end; ++ i) {
            if(strncmp(array+i,str.array,length2)==0) 
                return i;
        }
        return -1;
    }
    
    int find(const String & str) const{
        return find(str.array,0);
    }
    
    void replace(int start ,int length,const String & str){
        String str1=substr(0,start);
        String str2=substr(start+length);
        assign(str1);
        append(str);
        append(str2);
    }
    
    void erase (int start,int length){
        replace(start,length,"");
    }
    
    void insert(int index,const String & str){
        replace(index,0,str);
    }
};

ostream & operator << (ostream & out,const String & str){
    out << str.c_str();
    return out;
}

String operator + (const String & str1,const String & str2){
    String str = str1;
    str += str2;
    return str;
}