C++ 重写String类

最新推荐文章于 2025-09-26 09:39:08 发布
原创 最新推荐文章于 2025-09-26 09:39:08 发布 · 2.9k 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C++ #重写String类

本文介绍了一个自定义的String类实现，包括构造方法、成员方法及文件操作功能。该类提供了字符串复制、连接、比较等操作，并能将操作结果写入文件，支持字符串的大小写转换、空格去除等功能。

一、运行环境

codeblocks

gcc version 4.9.2 (tdm-1)

二、String内部描述

1、构造方法
构造方法描述
String(char *s,int len)构造方法初始化数据
2、功能描述
成员方法描述
char *getStr()获取当前的String(打印)
int getLength()获取当前String的长度
char *Strcpy(char *s)字符串的复制
char *Strcat(char *s)字符串的连接
int Compare(char *b)字符串的比较
char *substring(int sub_start,int sub_end)指定起始终止位置求子串
void exchange(char *s)字符串的交换
int BF_Find_String(char *s)在当前字符串String中查找子串
int indexOf(char index)查找某字符在当前String中第一次出现的位置
void toUpperCase()字符串小写转大写
void toLowerCase()字符串大写转小写
char *trim()消除字符串中的空格
char *SplitStr()消除{,!”“#$%&’()*+,-./}的字符
void set(int index,char letter)在指定字符串的指定位置添加某字符
3、操作文件功能

操作文件方法描述
void write_copy(char s1[30])字符串复制结果写入文件
void write_connect(char s1[30])字符串连接结果写入文件
void write_compare(char s1[15],char s2[15],int flag)字符串比较(compare)结果写入文件
void write_substring(char s1[15],char s2[15],int sub_start,int sub_end)将所求子串写入文件
void write_exchange(char s1[15],char s2[15],int flag)字符串交换前后数据写入文件
void write_BF_Find_String(char str[15],char s[15],int find_string_value)字符串的查找结果写入文件
void write_indexOf(char str[15],char index,int pos)将某字符在字符串第一次出现的位置写入文件
void write_LowerAndUpperCase(char s1[15],char s2[15])将转换大小写结果写入文件
void write_trim(char s1[15],char s2[15])消除字符串中的空格后结果写入文件
void write_SplitStr(char s1[15],char s2[15])消除常用标点符号,!”“#$%&’()*+,-./的结果写入文件
void write_set(char s1[15],char s2[15],int index,char one_letter)将某字符添加到某字符串的某个位置的结果写入文件
void write_reverse_str(char s1[15],char s2[15])将字符串翻转后写入文件
void write_initvalue(int n)起始写入文件的字符串
char * read(int count)读取文件指定位置的字符串

三、依赖

  • #include< iostream>
  • #include< string.h>
  • #include< fstream>
  • #include< malloc.h>

四、源码(不含测试)

    /*************************************************************************
    > File Name: 重写string类
    > Author: 浅然
    > Mail: xulinjie0105@gmail.com
    > Created Time: 2018年05月21日 星期一 14时11分34秒
 ************************************************************************/

#include<iostream>
#include<string.h>
#include<fstream>
#include<malloc.h>

using namespace std;
char s[15];//读取文件中的数据时存储在s数组中
/*
 *String
 *成员属性:*str,length
 *成员方法:
    1.显示构造器:String(char *s,int len)
    2.析构器:~String()
    3.获取此时的string:char *getStr()
    4.获取此时的length:int getLength()
    5.字符串的复制:char *Strcpy(char *s)
    6.字符串的连接:char *Strcat(char *s)
    7.字符串的比较:int Compare(char *b).
    8.求子串:char *substring(int sub_start,int sub_end)
    9.字符串的交换:void exchange(char *s)
    10.查找字符串(BF):int BF_Find_String(char *s)
    11.求出现某字符在指定字符串中第一次出现的位置:int indexOf(char index)
    12.字符串小写转大写:void toUpperCase().
    13.字符串大写转小写:void toLowerCase().
    14.消除字符串中的空格:char *trim().
    15.消除{,!""#$%&'()*+,-./}的字符:char *SplitStr().
    16.在指定字符串的指定位置添加某字符:  void set(int index,char letter).
 */
class String
{
    //成员变量
    private:
        char *str;
        int length;
    //构造器
    public:
        String(char *s,int len)
        {
            str=new char[strlen(s)+1];
            strcpy(str,s);
            length=len;
        }
        //析构器
        ~String()
        {
            delete[] str;
        }

        /*
         *获取此时的string
         */
        char *getStr(){
            return str;
        }
        /*
         *获取此时的length
         */
        int getLength(){
            return length;
        }
        /*
         *字符串的复制
         */
        char *Strcpy(char *s){
            char *destinaton=new char[strlen(s)+1];//为destinaton开辟内存空间
            strcpy(destinaton,s);                  //将s复制给destinaton
            if(destinaton!=NULL){                  //如果destinaton不为空,说明复制完成,且成功
                cout<<"复制完成"<<endl;
            }
            if(str)
                delete[]str;                       //释放str指向的内存
            str=destinaton;                        //将str指向destinaton所指向的地址(赋值)
            length=strlen(destinaton);             //此时所用的字符串长度更新
            return str;
        }
        /*
         *字符串的连接
         */
        char *Strcat(char *s){
            char *original = new char[strlen(s)+strlen(str)+1];//为original开辟内存空间
            strcpy(original,str);                              //将str复制给original
            strcat(original,s);                                //将s与original连接
            if(original!=str){                                 //如果original与str不相等,说明连接完成,且成功
                cout<<"连接完成"<<endl;
            }
            return original;
        }
        /*
         *字符串的比较
         */
        int Compare(char *b){
            int flag = 0;                        //比较大小标志域
            int com = strcmp(str,b);             //比较函数,得出大小

            if(com == 0){                        //com==0得出str==b
                cout<<str<<"和"<<b<<"相等"<<endl;
                flag=0;
            }

            else if(com<0){                      //com<0得出str<b
                cout<<str<<"小于"<<b<<endl;
                flag=-1;
            }

            else if(com>0){                      //com>0得出str>b
                cout<<str<<"大于"<<b<<endl;
                flag=1;
            }

            return flag;
        }

        /*
         *求子串
         *设置开始和结束位置求出子串
         */
        char *substring(int sub_start,int sub_end)
        {
            char *low_string=new char[sub_end-sub_start+1];//为low_string开辟内存空间
            int i=sub_start;                               //i初始化为所求子串在父串的初始位置
            int j=0;                                       //j为递增变量

            while(i<=sub_end){                             //确定i的范围,为low_string赋值
                low_string[j++] = str[i++];
            }
            low_string[j]='\0';
            return low_string;
        }

        /*
         *字符串的交换
         */
        void exchange(char *s)
        {
            char *temp_str = new char[length];      //为临时存放str的temp_str,开辟内存
            char *temp_s = new char[strlen(s)+1];   //为临时存放s的temp_s开辟内存

            cout<<"交换之前 ："<<s<<"\t"<<str<<endl;//打印交换前
            strcpy(temp_str,str);                   //将str复制给temp_str,下同
            strcpy(temp_s,s);
            str=temp_s;                             //实现更新交互,更新str的值,下同
            s=temp_str;
            cout<<"交换之后 ："<<s<<"\t"<<str<<endl;//打印交换后
        }

        /*
         *查找字符串(BF)
         *设置从某位置开始查找子串
         */
        int BF_Find_String(char *s)
        {
            int a,b;
            int i=0,j=0;

            a=strlen(str);
            b=strlen(s);
            j=0;

            cout<<(" 请输入数i,代表从主串s哪个位置开始\n");
            cin>>i;

            while(j<b && i<a)
            {
                if(str[i]==s[j])
                {
                    i++;
                    j++;
                }
                else
                {
                    i=i-j+1;
                    j=0;
                }
            }
            if(j>=b){
                cout<<"匹配成功,查找成功\n";
                return 1;
            }

            else{
                cout<<"匹配失败,查找失败\n";
                return -1;
            }

        }

        /*
         *求出现某字符在指定字符串中第一次出现的位置
         */
        int indexOf(char index)
        {
            for(int i = 0;i < strlen(str);i++){
                if(str[i] == index){
                    return i+1;
                }
            }
            return 0;
        }

        /*
         *字符串小写转大写
         */
        void toUpperCase()
        {
            for(int i = 0; str[i]!='\0';i++){
                if( str[i]>='a' && str[i]<='z'){
                    str[i] = str[i]-32;
                }
            }
        }

        /*
         *字符串大写转小写
         */
        void toLowerCase()
        {
            for(int i =0;str[i]!='\0';i++){
                if(str[i]>='A' && str[i]<='Z'){
                    str[i] = str[i]+32;
                }
            }
        }

        /*
         *消除字符串中的空格
         */
        char *trim()
        {
            int j = 0;
            int count = 0;
            char *s = new char[strlen(str)+1];
            for(int i = 0;i<strlen(str);){      //消除空格
                if(str[i] == ' '){
                    i++;
                    continue;
                }else{
                    s[j++] = str[i];
                    i++;
                }
            }
            s[j]='\0';                          //字符串结束
            return s;
        }

        /*
         *字符串分割
         *消除{,!""#$%&'()*+,-./}的字符
         */
        char *SplitStr()
        {
            int j = 0;
            char *s = new char[strlen(str)+1];
            for(int i = 0 ;i < strlen(str);){
                if((int)str[i] >= 33 && (int)str[i] <= 47){
                    i++;
                }else{
                    s[j++] = str[i];
                    i++;
                }
            }
            s[j] = '\0';
            return s;
        }

        /*
         *将字符添加到字符串指定位置
         */
        void set(int index,char letter)
        {
            int i = 0;
            int j = strlen(str);
           // char *s = str;
            //str = (char*)realloc(s,100);

            for(i = strlen(str)-1 ; i > index ; i--){
                str[i+1] = str[i];
            }
            str[i+1] = str[i];
            str[i] = letter;
            str[j+1] = '\0';
            length++;
        }

        /*
         *字符串翻转
         */
        char *reverse_str()
        {
            char temp;
            char *temp_s = new char[strlen(str)+1];
            strcpy(temp_s,str);                     //拷贝str到temp_s中
            int i,j;
            for(i=0;  ;i++)
            {
                if(*(temp_s+i)=='\0')
                break;
            }                                       //求字符串长度
            i--;
            for(j=0;j<=i;i--,j++)
            {
                temp=*(temp_s+j);
                *(temp_s+j)=*(temp_s+i);
                *(temp_s+i)=temp;
            }
            return temp_s;                           //字符串翻转
        }

};

/*
 *以下是文件写入操作
    1.字符串复制结果写入文件:void write_copy(char s1[30])
    2.字符串连接结果写入文件:void write_connect(char s1[30])
    3.字符串比较(compare)结果写入文件:void write_compare(char s1[15],char s2[15],int flag)
    4.将所求子串写入文件:void write_substring(char s1[15],char s2[15],int sub_start,int sub_end)
    5.字符串交换前后数据写入文件:void write_exchange(char s1[15],char s2[15],int flag)
    6.字符串的查找结果写入文件:void write_BF_Find_String(char str[15],char s[15],int find_string_value)
    7.将某字符在字符串第一次出现的位置写入文件:void write_indexOf(char str[15],char index,int pos)
    8.将转换大小写结果写入文件:void write_LowerAndUpperCase(char s1[15],char s2[15])
    9.消除字符串中的空格后结果写入文件: void write_trim(char s1[15],char s2[15])
    10.消除常用标点符号,!""#$%&'()*+,-./的结果写入文件:void write_SplitStr(char s1[15],char s2[15])
    11.将某字符添加到某字符串的某个位置的结果写入文件:void write_set(char s1[15],char s2[15],int index,char one_letter)
    12.将字符串翻转后写入文件: void write_reverse_str(char s1[15],char s2[15])
    13.起始写入文件的字符串:void write_initvalue(int n)
    14.读取文件指定位置的字符串:char * read(int count)
 */
/*
 *copy结果写入文件
 */
void write_copy(char s1[30])
{
    ofstream out;//向文件写入数据

    //out:以写的方式打开
    //ate:打开文件后立即定位到文件末尾
    //app:每次写操作前均定位到文件末尾
    out.open("d:\\j33.txt",ios::out|ios::ate|ios::app);
    if(!out){
        cout<<"文件打开失败!"<<endl;
    }

    out<<"字符串复制\n";
    out<<"copy:"<<s1<<"\n\n";
    out.close();
 }

/*
 *connect结果写入文件
 */
void write_connect(char s1[30])
{
    ofstream out;//向文件写入数据

    out.open("d:\\j33.txt",ios::out|ios::ate|ios::app);
    if(!out){
        cout<<"文件打开失败!"<<endl;
    }

    out<<"字符串连接\n";
    out<<"connect:"<<s1<<"\n\n";
    out.close();
 }

/*
 *字符串比较(compare)结果写入文件
 */
void write_compare(char s1[15],char s2[15],int flag)
{
    ofstream out;//向文件写入数据

    out.open("d:\\j33.txt",ios::out|ios::ate|ios::app);
    if(!out){
        cout<<"文件打开失败!"<<endl;
    }

    out<<"字符串比较\n";
    if(flag == 0)
        out<<s1<<"等于"<<s2<<"\n\n";
    else if(flag == -1)
        out<<s1<<"小于"<<s2<<"\n\n";
    else if(flag == 1)
        out<<s1<<"大于"<<s2<<"\n\n";
    out.close();
 }
/*
 *将所求子串写入文件
 */
void write_substring(char s1[15],char s2[15],int sub_start,int sub_end)
{
    ofstream out;//向文件写入数据

    out.open("d:\\j33.txt",ios::out|ios::ate|ios::app);
    if(!out){
        cout<<"文件打开失败!"<<endl;
    }
    out<<"求子串\n";
    out<<s2<<"通过起始位置:"<<sub_start<<"和结束位置"<<sub_end<<"所求的子串"<<s1<<"\n\n";
    out.close();
 }

/*
 *字符串交换前后数据写入文件
 */
void write_exchange(char s1[15],char s2[15],int flag)
{
    ofstream out;//向文件写入数据

    out.open("d:\\j33.txt",ios::out|ios::ate|ios::app);
    if(!out){
        cout<<"文件打开失败!"<<endl;
    }
    out<<"字符串交换\n";
    if(flag){
        out<<"字符串交换后:  old_string:"<<s1<<"\t"<<"new_string:"<<s2<<"\n\n";
    }else{
        out<<"字符串交换前： old_string:"<<s1<<"\t"<<"new_string:"<<s2<<"\n\n";
    }
 }

 /*
  *字符串的查找结果写入文件
  */
void write_BF_Find_String(char str[15],char s[15],int find_string_value)
{
    ofstream out;

    out.open("d:\\j33.txt",ios::out|ios::ate|ios::app);
    if(!out){
        cout<<"文件打开失败!"<<endl;
    }
    out<<"字符串查找\n";
    if(find_string_value == 1){
        out<<str<<"与"<<s<<"匹配成功,查找成功\n\n";
    }
    else if(find_string_value == -1){
        out<<str<<"与"<<s<<"匹配失败,查找失败\n\n";
    }
 }

/*
 *将某字符在字符串第一次出现的位置写入文件
 */
void write_indexOf(char str[15],char index,int pos)
{
    ofstream out;

    out.open("d:\\j33.txt",ios::out|ios::ate|ios::app);
    if(!out){
        cout<<"文件打开失败!"<<endl;
    }
    out<<"查找"<<index<<"在"<<str<<"中第几号位置第一次出现亦或没有\n";
    if(pos){
        out<<index<<"在"<<str<<"的第:"<<pos<<"\n\n";
    }
    else{
        out<<index<<"没有出现在string中\n\n";
    }
 }

 /*
 *将转换大小写结果写入文件
 */
void write_LowerAndUpperCase(char s1[15],char s2[15])
{
    ofstream out;

    out.open("d:\\j33.txt",ios::out|ios::ate|ios::app);
    if(!out)
    {
        cout<<"文件打开失败!"<<endl;
    }
    out<<"字符串大小写转换\n";
    out<<s1<<"转换为"<<s2<<"\n\n";
    out.close();
 }

 /*
  *消除字符串中的空格后结果写入文件
  */
 void write_trim(char s1[15],char s2[15])
 {
    ofstream out;

    out.open("d:\\j33.txt",ios::out|ios::ate|ios::app);
    if(!out)
    {
        cout<<"文件打开失败!"<<endl;
    }

    out<<"忽略"<<s1<<"中的空格 : "<<s2<<"\n\n";
 }

 /*
  *消除常用标点符号,!""#$%&'()*+,-./的结果写入文件
  */
 void write_SplitStr(char s1[15],char s2[15])
 {
    ofstream out;

    out.open("d:\\j33.txt",ios::out|ios::ate|ios::app);
    if(!out)
    {
        cout<<"文件打开失败!"<<endl;
    }

    out<<"忽略"<<s1<<"中的标点 : "<<s2<<"\n\n";
 }

 /*
  *将某字符添加到某字符串的某个位置的结果写入文件
  */
 void write_set(char s1[15],char s2[15],int index,char one_letter)
 {
    ofstream out;

    out.open("d:\\j33.txt",ios::out|ios::ate|ios::app);
    if(!out)
    {
        cout<<"文件打开失败!"<<endl;
    }

    out<<s1<<"在"<<index<<"位置添加"<<one_letter<<"后 : "<<s2<<"\n\n";
 }

 /*
  *将字符串翻转后写入文件
  */
 void write_reverse_str(char s1[15],char s2[15])
 {
    ofstream out;

    out.open("d:\\j33.txt",ios::out|ios::ate|ios::app);
    if(!out)
    {
        cout<<"文件打开失败!"<<endl;
    }

    out<<s1<<"通过字符串翻转 : "<<s2<<"\n\n";
 }

 /*
  *起始写入文件的字符串
  */
void write_initvalue(int n)
{
    ofstream out;
    int i=0;

    out.open("d:\\j33.txt",ios::out);
    if(!out)
    {
        cout<<"文件打开失败!"<<endl;
    }
    cin.ignore(1);
    while(i<n)
    {
        char s1[20];

        cout<<"input "<<i+1<<" string :";
        cin.getline(s1,15);
        out<<s1<<"\n";
        i++;
    }
    out<<"\n";
    out.close();
 }

/*
 *读取文件指定位置的字符串
 */
 char * read(int count)
 {
    ifstream in;                        //从文件读取数据
    in.open("d:\\j33.txt",ios::in);     //以读的方式打开
    if(!in){
        cout<<"文件打开失败!"<<endl;
        return NULL;
    }

    while(count){
        in.getline(s,15);               //从第一行开始,读到第count次,读到count行
        count--;
    }
    in.close();//关闭流
    return s;
}

/*
 *修饰作用(横线)
 */
void decorate()
{
    ofstream out;

    out.open("d:\\j33.txt",ios::out|ios::ate|ios::app);
    if(!out)
    {
        cout<<"文件打开失败!"<<endl;
    }
    for(int i = 0;i < 40;i++){
        cout<<"-";
        out<<"-";
    }
    out<<"\n\n";
}

/*
 *测试
 */
 int main()
{
    int m;                      //选择第几行字符串来使用的变量
    int k;                      //选择操作数变量
    int j=1;                    //判断用户是否选择退出
    int MAX;                    //含有多少个字符串
    int pos;                    //indexOf获取某字符在字符串的第一次出现的位置
    char *strback;              //获取操作结果的字符串
    int compare_string_value;   //字符串比较所返回的值
    int find_string_value;      //是否匹配查找字符串成功标志域
    char *letter;               //查找子串时作为子串
    char index;                 //查找字符在string第一次出现位置的字符变量
    int flag = 0;               //字符串比较时的标志域

    cout<<"您将在文件中输入几行字符串:";
    cin>>MAX;
    cout<<"\n请输入字符串: \n";
    write_initvalue(MAX);
    decorate();
    cout<<"\n";
    cout<<"1————字符串复制\n\n";
    cout<<"2————字符串连接\n\n";
    cout<<"3————字符串比较\n\n";
    cout<<"4————字符串求子串\n\n";
    cout<<"5————字符串交换\n\n";
    cout<<"6————查找指定的字符串\n\n";
    cout<<"7————查找某字符在字符串第一次出现的位置\n\n";
    cout<<"8————将字符串所有字符都转换为大写\n\n";
    cout<<"9————将字符串所有字符都转换为小写\n\n";
    cout<<"10———消除字符串中的空格\n\n";
    cout<<"11———消除字符串中常用标点符号\n\n";
    cout<<"12———将字符添加到字符串的指定位置\n\n";
    cout<<"13———字符串翻转\n\n";
    cout<<"0————退出\n\n";

    cout<<"请输入一个整型m,选择你此时将使用第几行字符串: ";
    while(cin>>m){
        if(m<=0||m>MAX){
            cout<<"\n输入的m不在指定范围内,请重新输入:";
            continue;
        }
        break;
    }

    String str_ing(read(m),12);                       //创建str_ing对象
    char *temp = new char[strlen(str_ing.getStr())+1];//用于交换的临时字符指针
    cout<<"此时的string为 : "<<str_ing.getStr()<<"\n\n";
    cout<<"请选择操作号 : ";
    while(j!=0&&cin>>k){
        switch(k){
          case 1:
                cout<<"此时你的操作字符串为"<<str_ing.getStr()<<"\n";
                cout<<"\n请输入你将选择第几行字符串复制给string : ";
                cin>>m;
                strback = str_ing.Strcpy(read(m));
                write_copy(strback);
                cout<<"\n复制完成后的string ：";
                cout<<strback <<"\n";
                decorate();
                break;
          case 2:
                cout<<"此时你的操作字符串为"<<str_ing.getStr()<<"\n";
                cout<<"\n输入m选择文件中第几个字符串连接 : ";
                cin>>m;
                strback =  str_ing.Strcat(read(m));
                write_connect(strback);
                cout<<"\n连接后的字符串:"<<strback<<endl;
                decorate();
                break;
          case 3:
                cout<<"此时你的操作字符串为"<<str_ing.getStr()<<"\n";
                cout<<"\n输入m选择文件中第几个字符串进行比较 : ";
                cin>>m;
                compare_string_value = str_ing.Compare(read(m));
                write_compare(str_ing.getStr(),read(m),compare_string_value);
                decorate();
                break;
          case 4:
                int sub_start,sub_end;
                cout<<"此时你的操作字符串为"<<str_ing.getStr()<<"\n";
                cout<<"\n请输入需要取子串的起始与结束位置 : ";
                cin>>sub_start>>sub_end;
                cout<<"所求子串为:   ";
                strback = str_ing.substring(sub_start,sub_end);
                write_substring(strback,str_ing.getStr(),sub_start,sub_end);
                cout<<strback<<endl;
                decorate();
                break;
          case 5:
                cout<<"此时你的操作字符串为"<<str_ing.getStr()<<"\n";
                cout<<"\n输入m选择文件中第几个字符串进行交换 : ";
                cin>>m;
                strcpy(temp,str_ing.getStr());
                write_exchange(str_ing.getStr(),read(m),0);
                str_ing.exchange(read(m)) ;
                write_exchange(str_ing.getStr(),temp,1);
                decorate();
                break;
          case 6:
                cout<<"此时你的操作字符串为"<<str_ing.getStr()<<"\n";
                cout<<"\n请输入要查找的子串 : ";
                cin>>letter;
                find_string_value = str_ing.BF_Find_String(letter);
                write_BF_Find_String(str_ing.getStr(),letter,find_string_value);
                decorate();
                break;
          case 7:
                cout<<"此时你的操作字符串为"<<str_ing.getStr()<<"\n";
                cout<<"\n请输入你要找的字符 : ";
                cin>>index;
                pos = str_ing.indexOf(index);
                if(pos){
                    cout<<index<<"在"<<str_ing.getStr()<<"中第一次出现的位置在 : "<<pos<<"\n";
                }else{
                    cout<<index<<"没有在string中找到\n";
                }
                write_indexOf(str_ing.getStr(),index,pos);
                decorate();
                break;
          case 8:
                cout<<"此时你的操作字符串为"<<str_ing.getStr()<<"\n";
                strcpy(temp,str_ing.getStr());
                cout<<str_ing.getStr()<<"\n转换为大写后 : ";
                str_ing.toUpperCase();
                cout<<str_ing.getStr()<<"\n";
                write_LowerAndUpperCase(temp,str_ing.getStr());
                decorate();
                break;
          case 9:
                cout<<"此时你的操作字符串为"<<str_ing.getStr()<<"\n";
                strcpy(temp,str_ing.getStr());
                cout<<str_ing.getStr()<<"\n转换为小写后 : ";
                str_ing.toLowerCase();
                cout<<str_ing.getStr()<<"\n";
                write_LowerAndUpperCase(temp,str_ing.getStr());
                decorate();
                break;
          case 10:
                cout<<"此时你的操作字符串为"<<str_ing.getStr()<<"\n";
                strback = str_ing.trim();
                cout<<"\n消除空格后 ："<<strback<<"\n";
                write_trim(str_ing.getStr(),strback);
                decorate();
                break;
          case 11:
                cout<<"此时你的操作字符串为"<<str_ing.getStr()<<"\n";
                strback = str_ing.SplitStr();
                cout<<"\n消除标点符号后:"<<strback<<"\n";
                write_SplitStr(str_ing.getStr(),strback);
                decorate();
                break;
          case 12:
                int index;
                char one_letter;
                strback = str_ing.getStr();
                cout<<"此时你的操作字符串为"<<str_ing.getStr()<<"\n";
                cout<<"\n请输入插入的位置和字符 : ";
                cin>>index>>one_letter;
                while(1){
                    if(index >= 0 && index < strlen(str_ing.getStr())){
                        break;
                    }
                    cout<<"输入范围有误,请重新输入(0-"<<strlen(str_ing.getStr())-1<<"):\n";
                    cin>>index>>one_letter;
                }
                str_ing.set(index,one_letter);
                cout<<str_ing.getStr()<<"\n";
                write_set(strback,str_ing.getStr(),index,one_letter);
                decorate();
                break;
          case 13:
                cout<<"此时你的操作字符串为"<<str_ing.getStr()<<"\n";
                strback = str_ing.reverse_str();
                cout<<"\n字符串翻转的结果 : "<<strback<<"\n";
                write_reverse_str(str_ing.getStr(),strback);
                decorate();
                break;
          case 0:
                j=0;
                cout<<"Thanks,bye\n";
                break;
        }
        if(j){
            cout<<"\n\n请选择操作号 : ";
        }
    }
    return 0;
 }

五、控制台操作界面

1、目录

这里写图片描述

2、部分操作演示

这里写图片描述

3、写入文件

这里写图片描述

工程下载—github

工程下载—优快云下载

C++重写String类
05-26
C++重写String类C++重写String类C++重写String类C++重写String类
c++String类的重写
06-23
写了string类的一些简单的运算符重载，还有构造函数的重载等基本操作。
深入理解 C++ 中的重写、重载与重定义
最新发布
AC的博客
09-26 473
重写发生在具有继承关系的类中，当子类重新定义了父类中的虚函数时，就构成了重写。重写的函数必须与父类中的虚函数具有相同的函数名、参数列表和返回类型（协变返回类型除外，即子类重写函数的返回类型可以是父类虚函数返回类型的派生类）。重载是指在同一个作用域内，多个函数具有相同的函数名，但参数列表不同（参数个数、类型或顺序不同）。返回类型与函数重载无关，即返回类型不同不能构成函数重载。重定义通常指在不同的作用域中，对已经定义过的标识符重新进行定义。
c++重写string类
rqc112233的专栏
03-02 943
这是第一次写的string类，可能会有些没有考虑到的问题，还请大神指导。。。。 //重写string类 #include #include using namespace std; class my_string///* { public: //三种构造函数 my_string(){}; my_string(int n,const char a) { len=n+1; da
C++重写string类
qq_56108311的博客
10-03 445
重写String类
重写String类
02-19 3158
classs String {     private:     char *m_data;   //数据成员       public:     String(const char *str = NULL)    //普通构造函数     {          if (str == NULL)          {           
C++实现String类深度重写技巧
在C++中重写String类是一个高级话题，涉及到C++编程的基础知识，尤其是类的继承和多态性。在这个过程中，开发者通常会创建一个新的类，它继承自标准的string类，并覆盖或添加新的成员函数以改变原有的功能或添加新的...
掌握C++ String类重写：运算符与构造函数
重写string类通常指的是在原有标准库string类的基础上，通过继承和重载运算符以及构造函数等方式，实现一个具有额外功能或者优化性能的string类。下面将详细介绍在C++中进行string类重写时可能涉及的知识点。 1. ...
C++对象模型深度解析：重写String类与内存布局详解
该文章以重写String类为实验核心，涵盖了对象的创建方式，如局部对象、动态对象和通过复制构造函数生成的对象，以及它们对不同类型的成员（静态和非静态）的内存位置和访问。 在实验中，作者首先介绍了内存模型的...
C++重写String类（部分）
Cy_2024的博客
02-03 719
课程设计的作业，不过后面因为一些事并没写完，而且有些要求太过模糊，老师也没解释个所以然...有空的时候整理吧，先丢代码了，抱歉。话说因为写的时候是个彻彻底底的弱鸡（虽然现在也还是..），所以肯定有一堆很奇怪的地方，希望大佬们不要太在意某些细节，若给出建议，万分感谢。emmmm仅供学习参考。 ---------------------------------- 头文件：string.h #pr
重写string类
changke的博客
03-25 1478
mystring类实现的都是些常用的操作，字符串的累加，各种形式的赋值，迭代器的前置++和后置++等！通过写这个感觉主要熟悉了c++运算符重载的原理，另外就是熟悉了string对象的内置常用方法。 头文件 //mystring.h #pragma once #include<string.h> #include<strings.h> #include<stdlib....
C++（三十七） — 字符串的函数重载—案例
dbsggal90047018的博客
05-26 342
1、MyString.h 头文件 #pragma once #include <iostream> using namespace std; class MyString { public: MyString(); MyString(const char *p); MyString(const MyString& ...
c++ 重写string类 MyString
名字不必太长------>小沐
03-23 1852
只作为自己的学习笔记，有空时可以翻看自己的学习路程，之前是将这些笔记记录在一个*note软件中，现在重新做一遍。网络上也有大把相似内容，但自己要动手实践去做一遍，验证一遍，然后理解它。如有不妥之处，欢迎网友们提出指正。文章后面进行了运行结果。 运行环境：win7 - x64；visual studio 2010
【C&C++】C++ String类的重写
love131452098的博客
06-21 234
拷贝构造 拷贝赋值 移动构造 移动赋值 未完待续!!!
c/c++实现string类的重写
Mr_fightingboy的博客
07-27 1211
  实现string类是一道考验c++基础知识的好题，接下来看这样一道题目，顺便了解string类的内部实现 已知string类的原型代码如下，请编写l类string的7个函数： #ifndef STRING_H #define STRING_H #include&lt;iostream&gt; using namespace std; class String { public:     S...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值