#include<iostream> #include<cstring> using namespace std; class String{ public: char* str; String(char* a){ str=new char[strlen(a)+1]; strcpy(str,a); } String(){ str=NULL; } friend istream & operator>>(istream &i,String &op) //liucharu { char *p =new char[30]; op.str=p; i>>op.str; return i; } friend ostream & operator<<(ostream &o,String &op) //liutiqv { o<<op.str<<endl; return o; } String & operator=(const char* op) { if(str) delete []str; if(op){ str=new char[strlen(op)+1]; strcpy(str,op); } else str=NULL; return* this; } String operator+(const String &op) { strcat(str,op.str); return* this; } String operator+=(char *op) { strcat(str,op); return* this; } char & operator[](int n) str[5] { return str[n]; } bool operator<(const String &op) { if(strcmp(str,op.str)>0) return false; else return true; } void replace(int pos,int n,char* s){ int i=strlen(str); if(i<pos-1) //HUOQVZIFUCHUANCHANGDU cout<<"超出范围！"; else { n=n-1; strcpy(str+pos+n,s); // s到str 拷贝 cong pos +n kaobei } } String(const String &a){ char *b=new char[30]; this->str=b; strcpy(str,a.str); } ~String() { delete []str; } }; char find(String& s,int pos){ // chaxun int i=strlen(s.str); if(i<pos-1) cout<<"超出范围！"; else { pos=pos-1; return s.str[pos]; } } int main() { cout<<"请输入S1与S2\n"; String s1,s2; cin>>s1>>s2; while(1) { cout<<"1.查找s1第pos个字符\n"; cout<<"2.s1从pos开始的n个字符替换为s2\n"; cout<<"3.拷贝s2至s3\n"; int n; cin>>n; switch(n){ case 1:{ cout<<"输入pos\n"; int pos; cin>>pos; cout<<find(s1,pos)<<endl; };break; case 2:{ cout<<"输入pos,n\n"; int pos,n; cin>>pos>>n; s1.replace(pos,n,s2.str); cout<<s1.str<<endl; };break; case 3:{ String s3(s2); cout<<s3.str<<endl; };break; } } return 0; }加注释

#include<iostream> //输入输出流头文件
#include<cstring> //字符串操作头文件
using namespace std; //命名空间

class String{ //定义String类
public: 
    char* str; //字符指针，用于存储字符串

    String(char* a){ //带参构造函数，传入一个字符指针
        str=new char[strlen(a)+1]; //动态分配内存，大小为字符串长度+1
        strcpy(str,a); //将传入的字符串复制到str指向的内存中
    }

    String(){ //无参构造函数
        str=NULL; //将字符指针初始化为空
    }

    //友元函数，重载输入运算符，用于从流中输入一个String对象
    friend istream & operator>>(istream &i,String &op){ 
        char *p =new char[30]; //动态分配内存，大小为30
        op.str=p; //将p赋值给op的字符指针
        i>>op.str; //从流中输入一个字符串，并赋值给op的字符指针
        return i; //返回输入流对象
    }

    //友元函数，重载输出运算符，用于输出String对象
    friend ostream & operator<<(ostream &o,String &op){ 
        o<<op.str<<endl; //将op的字符指针指向的字符串输出到流中，并换行
        return o; //返回输出流对象
    }

    //重载赋值运算符，用于将一个字符指针赋值给String对象
    String & operator=(const char* op){  
        if(str) //如果字符指针不为空，释放其指向的内存
            delete []str; 
        if(op){ //如果字符指针不为空
            str=new char[strlen(op)+1]; //动态分配内存，大小为字符串长度+1
            strcpy(str,op); //将传入的字符串复制到str指向的内存中
        }
        else 
            str=NULL; //否则将字符指针置为空
        return *this; //返回当前对象的引用
    }

    //重载加法运算符，用于将两个String对象连接成一个新的String对象
    String operator+(const String &op){ 
        strcat(str,op.str); //将op的字符指针指向的字符串连接到当前对象的字符指针指向的字符串末尾
        return *this; //返回当前对象的引用
    }

    //重载加等于运算符，用于将一个字符指针连接到当前对象的字符指针指向的字符串末尾
    String operator+=(char *op){ 
        strcat(str,op); //将op指向的字符串连接到当前对象的字符指针指向的字符串末尾
        return *this; //返回当前对象的引用
    }

    //重载下标运算符，用于访问当前对象的字符指针指向的字符串中的某个字符
    char & operator[](int n){ 
        return str[n]; //返回当前对象的字符指针指向的字符串中的第n个字符
    }

    //重载小于运算符，用于比较两个String对象的字符指针指向的字符串的大小
    bool operator<(const String &op){ 
        if(strcmp(str,op.str)>0) //如果当前对象的字符指针指向的字符串大于op的字符指针指向的字符串
            return false; //返回false
        else 
            return true; //否则返回true
    }

    //定义replace函数，用于替换当前对象的字符指针指向的字符串中从pos开始的n个字符为s指向的字符串
    void replace(int pos,int n,char* s){ 
        int i=strlen(str); //获取当前对象的字符指针指向的字符串长度
        if(i<pos-1) //如果pos超出了范围
            cout<<"超出范围！"; //输出超出范围提示
        else{ 
            n=n-1; //将n减1，为了方便替换
            strcpy(str+pos+n,s); //将s指向的字符串拷贝到当前对象的字符指针指向的字符串从pos+n开始的位置中
        }
    } 

    //拷贝构造函数，用于将一个String对象复制给另一个String对象
    String(const String &a){ 
        char *b=new char[30]; //动态分配内存，大小为30
        this->str=b; //将b赋值给当前对象的字符指针
        strcpy(str,a.str); //将a的字符指针指向的字符串复制到当前对象的字符指针指向的内存中
    }

    //析构函数，用于释放当前对象的字符指针指向的内存
    ~String(){ 
        delete []str; 
    }
}; 

//定义find函数，用于查找传入的String对象中第pos个字符
char find(String& s,int pos){                   
    int i=strlen(s.str); //获取传入的String对象的字符指针指向的字符串长度
    if(i<pos-1) //如果pos超出了范围
        cout<<"超出范围！"; //输出超出范围提示
    else{ 
        pos=pos-1; //将pos减1，因为下标从0开始
        return s.str[pos]; //返回传入的String对象的字符指针指向的字符串中第pos个字符
    }
} 

int main(){ 
    cout<<"请输入S1与S2\n"; //输出提示
    String s1,s2; //定义两个String对象
    cin>>s1>>s2; //从流中输入两个字符串，并赋值给s1和s2的字符指针
    while(1){ 
        cout<<"1.查找s1第pos个字符\n"; //输出提示
        cout<<"2.s1从pos开始的n个字符替换为s2\n"; //输出提示
        cout<<"3.拷贝s2至s3\n"; //输出提示
        int n; 
        cin>>n; //从流中输入一个整数，用于选择操作
        switch(n){ 
            case 1:{ //如果选择了1
                cout<<"输入pos\n"; //输出提示
                int pos; 
                cin>>pos; //从流中输入一个整数，表示要查找的字符的位置
                cout<<find(s1,pos)<<endl; //输出查找到的字符，并换行
            };break; 
            case 2:{ //如果选择了2
                cout<<"输入pos,n\n"; //输出提示
                int pos,n; 
                cin>>pos>>n; //从流中输入两个整数，分别表示要替换的字符的起始位置和数量
                s1.replace(pos,n,s2.str); //调用replace函数，将s2的字符指针指向的字符串替换到s1的字符指针指向的字符串中
                cout<<s1.str<<endl; //输出替换后的字符串，并换行
            };break; 
            case 3:{ //如果选择了3
                String s3(s2); //用s2的字符指针指向的字符串构造一个新的String对象，赋值给s3
                cout<<s3.str<<endl; //输出s3的字符指针指向的字符串，并换行
            };break; 
        } 
    } 
    return 0; //程序结束
}