面向对象程序设计|字符串操作（string）

题目描述：

给定n个字符串（从1开始编号），每个字符串中的字符位置从0开始编号，长度为1-500，现有如下若干操作：

copy N X L：取出第N个字符串第X个字符开始的长度为L的字符串。

add S1 S2：判断S1，S2是否为0-99999之间的整数，若是则将其转化为整数做加法，若不是，则作字符串加法，返回的值为一字符串。

find S N：在第N个字符串中从左开始找寻S字符串，返回其第一次出现的位置，若没有找到，返回字符串的长度。

rfind S N：在第N个字符串中从右开始找寻S字符串，返回其第一次出现的位置，若没有找到，返回字符串的长度。

insert S N X：在第N个字符串的第X个字符位置中插入S字符串。

reset S N：将第N个字符串变为S。

print N：打印输出第N个字符串。

printall：打印输出所有字符串。

over：结束操作。

其中N，X，L可由find与rfind操作表达式构成，S，S1，S2可由copy与add操作表达式构成。

提示：本题练习string类使用，所有的操作可调用string的方法实现。

输入要求：

第一行为一个整数n（n在1-20之间） 接下来n行为n个字符串，字符串不包含空格及操作命令等。 接下来若干行为一系列操作，直到over结束。

输出要求：

根据操作提示输出对应字符串。

输入样例：

3
329strjvc
Opadfk48
Ifjoqwoqejr
insert copy 1 find 2 1 2 2 2
print 2
reset add copy 1 find 3 1 3 copy 2 find 2 2 2 3
print 3
insert a 3 2
printall
over

输出样例：

Op29adfk48
358
329strjvc
Op29adfk48
35a8

#include<iostream>
#include<iomanip>
#include<cstring>
#include<string> 
#include<cmath>
#include<algorithm>
using namespace std;

string Copy();//对所有函数提前声明
string Add();
int Find();
int rFind();
string Insert();
string Reset();
void Print(int site);
void Printall(int total);
bool isnum(string s);

string* str;

//由于N，X，L可由find与rfind操作表达式构成，S，S1，S2可由copy与add操作表达式构成
//故在输入前要判断N,X,L,S等的具体操作

string Copy()
{
    string N, X, L;
    int n, x, l;
    cin >> N;
    if (N == "find")//如果是find，则调用Find函数
    {
        n = Find();
    }
    else if (N == "rfind")//如果是rfind，则调用rFind函数
    {
        n = rFind();
    }
    else//如果都不是，则只能是string型的数字，把它转化成int型
    {
        n = stoi(N);
    }
    cin >> X;//X与N同理
    if (X == "find")
    {
        x = Find();
    }
    else if (X == "rfind")
    {
        x = rFind();
    }
    else
    {
        x = stoi(X);
    }
    cin >> L;//X与N同理
    if (L == "find")
    {
        l = Find();
    }
    else if (L == "rfind")
    {
        l = rFind();
    }
    else
    {
        l = stoi(L);//string类型转int型 运用stoi函数
    }
    string endcpy = str[n - 1].substr(x, l);//最终得到一个字符串，即从第N个字符串的X出取出L长的子串，运用substr函数
    return endcpy;
}

//substr()的功能是返回某个子字符串
//用法：
//string str1 = str0.substr();  //默认时的长度为从开始位置到尾
//string str2 = str0.substr(p);  //获得字符串str0中 从第p位开始到尾的字符串
//string str3 = str0.substr(p, l);  //获得字符串str0中 从第p位开始的长度为l的字符串

string Add()
{
    string S1, S2, s1, s2;
    int si1, si2;
    cin >> S1;
    if (S1 == "copy")//如果是copy则调用Copy函数
    {
        s1 = Copy();
    }
    else if (S1 == "add")//如果是add则调用Add函数
    {
        s1 = Add();
    }
    else//如果不是，则直接的到S串
    {
        s1 = S1;
    }
    cin >> S2;//S2同S1
    if (S2 == "copy")
    {
        s2 = Copy();
    }
    else if (S2 == "add")
    {
        s2 = Add();
    }
    else
    {
        s2 = S2;
    }
    if (isnum(s1) && isnum(s2))//判断是否s1和s2都是整数，若是先从string型转化为int型，相加后再转化成string型
    {
        si1 = stoi(s1);
        si2 = stoi(s2);
        int sumi = si1 + si2;
        string sume = to_string(sumi);//int型转化成string型运用 to_string函数
        return sume;
    }
    else
    {
        return s1 + s2;//不是则可以直接相加，string类型常用操作有：“>”“<”“>=”“<=”“==”“!=”“+”“+=”
    }
}

int Find()
{
    string S, N;
    string s;
    int n;
    cin >> S;
    if (S == "copy")
    {
        s = Copy();
    }
    else if (S == "add")
    {
        s = Add();
    }
    else
    {
        s = S;
    }
    cin >> N;
    if (N == "find")
    {
        n = Find();
    }
    else if (N == "rfind")
    {
        n = rFind();
    }
    else
    {
        n = stoi(N);
    }
    int place;
    if (str[n - 1].find(s) != string::npos)//在str串中查找s串的位置，如果找到，则返回该子字符串首次出现时其首字符的索引；
                                           //否则，返回 string::npos
                                           //string 类将 npos 定义为保证大于任何有效下标的值
    {
        place = str[n - 1].find(s);//找到的话记录下其位置
    }
    else
    {
        place = str[n - 1].size();//没找到则返回其长度
    }
    return place;
}

int rFind()
{
    string S, N;
    string s;
    int n;
    cin >> S;
    if (S == "copy")
    {
        s = Copy();
    }
    else if (S == "add")
    {
        s = Add();
    }
    else
    {
        s = S;
    }
    cin >> N;
    if (N == "find")
    {
        n = Find();
    }
    else if (N == "rfind")
    {
        n = rFind();
    }
    else
    {
        n = stoi(N);
    }
    int place;
    if (str[n - 1].rfind(s) != string::npos)//rfind与find原理相同，区别是其从右端开始检索
    {
        place = str[n - 1].rfind(s);
    }
    else
    {
        place = str[n - 1].size();
    }
    return place;
}

string Insert()
{
    string S, N, X;
    string s;
    int n, x;
    cin >> S;
    if (S == "copy")
    {
        s = Copy();
    }
    else if (S == "add")
    {
        s = Add();
    }
    else
    {
        s = S;
    }
    cin >> N;
    if (N == "find")
    {
        n = Find();
    }
    else if (N == "rfind")
    {
        n = rFind();
    }
    else
    {
        n = stoi(N);
    }
    cin >> X;
    if (X == "find")
    {
        x = Find();
    }
    else if (X == "rfind")
    {
        x = rFind();
    }
    else
    {
        x = stoi(X);
    }
    string ist = str[n - 1].insert(x, s);//用insert函数在str的x处插入s字符串
    return ist;
}

//insert()的功能是进行插入
//用法：
//str0.insert(size_t pos,const string＆str);  // 在str0的pos位置处插入字符串str
//str0.insert(size_t pos,const string＆str,size_t subpos,size_t sublen);// 在str0的pos位置处插入字符串str从位置处开始的sublen个字符

string Reset()
{
    string S, N;
    string s;
    int n;
    cin >> S;
    if (S == "copy")
    {
        s = Copy();
    }
    else if (S == "add")
    {
        s = Add();
    }
    else
    {
        s = S;
    }
    cin >> N;
    if (N == "find")
    {
        n = Find();
    }
    else if (N == "rfind")
    {
        n = rFind();
    }
    else
    {
        n = stoi(N);
    }
    swap(str[n - 1], s);//重置直接用swap交换即可，str是全局变量，而s是局部变量，生命周期不同
    return str[n - 1];//返回交换后的str，注意第n个字符串是str[n-1]
}

void Print(int site)
{
    cout << str[site - 1] << endl;//输出单个字符串
}

void Printall(int total)
{
    for (int i = 0; i < total; i++)
    {
        cout << str[i] << endl;//输出全部字符串
    }
}

bool isnum(string s)//判断字符串是否全为数字
{
    if (s.size() > 5)
    {
        return false;
    }
    else
    {
        for (int i = 0; i < s.size(); i++)
        {
            if (s.at(i) > '9' || s.at(i) < '0')
            {
                return false;
            }
        }
        return true;
    }
}

//at()的功能是存取单一字符
//用法：
//string str;
//str.at(p)表示字符串str中下标为p的字符


int main()
{
    int n0;
    cin >> n0;
    str = new string[n0];
    for (int i = 0; i < n0; i++)
    {
        cin >> str[i];//输入字符串到str中，其中str是全局变量
    }
    while (1)//操作若干，over结束，因此选择while(1)
    {
        string operation;
        cin >> operation;
        if (operation == "copy")//根据对应的operation，进行对应的操作
        {
            Copy();
        }
        else if (operation == "add")
        {
            Add();
        }
        else if (operation == "find")
        {
            Find();
        }
        else if (operation == "rfind")
        {
            rFind();
        }
        else if (operation == "insert")
        {
            Insert();
        }
        else if (operation == "reset")
        {
            Reset();
        }
        else if (operation == "print")
        {
            int site0;
            cin >> site0;
            Print(site0);
        }
        else if (operation == "printall")
        {
            Printall(n0);
        }
        else if (operation == "over")//若是over直接跳出循环，程序运行结束
        {
            break;
        }
    }
    return 0;
}

本代码总共388行，是由于笔者的能力有限，选择了最简单的方法（可能会比较繁琐），加上个人格式的书写喜好与必要的文字说明，因而达到了近400行。粗略计算，本代码的有效长度只有200行左右，请读者多多担待！