串的动态存储操作

该算法虽然是使用动态内存分配的方法实现，但因其存储单元的地址是连续的，所以本质上还是属于顺序存储。

<span style="font-size:14px;">#include <iostream>
#include <stdlib.h>
#include <stdbool.h>
#define MAX 225
using namespace std;
typedef struct
{
    char* base;
    int lengh;
}qstring,*pstring;
/************************************/
//初始化及创建
void init(pstring s)
{
    int i,j;
    char str[MAX];
    cin>>str;
    for(i=0;str[i]!='\0';i++)
        s->base=(char*)malloc(sizeof(char));//此循环i出来的时候是str的长度
    if(s->base==NULL)
        cout<<"内存分配失败";
    for(j=0;j<=i;j++)
        s->base[j]=str[j];//此循环j出来是长度加一
    s->lengh=j-1;
}
/************************************/
//遍历
void display(pstring s)
{
    int i;
    for(i=0;i<s->lengh;i++)
    {
        cout<<s->base[i];
    }
}
/************************************/
//获得字符串长度前提是字符串已经初始化
int  lengh(pstring s)
{
    return s->lengh;
}
bool empty(pstring s)
{
    if(s->lengh==0)
        return true;
    else
        return false;
}
//若s1大于s2返回值大于0 等于返回值等于0 小于返回值小于0
int compare(pstring s1,pstring s2)
{
    int i;
    for(i=0;i<s1->lengh && i<s2->lengh;i++)
    {
        if(s1->base[i]!=s2->base[i])
            return s1->base[i]-s2->base[i];
    }
    return s1->lengh-s2->length;//当s1大于s2且s1的前面等于s2的时候直接返回长度差，即正数，代表s1大于s2

/************************************/
//将s清空并释放内存
void clear(pstring s)
{
    s->lengh=0;
    free(s->base);
    s->base=NULL;
}
/************************************/
//链接两个字符串
void concat(pstring s1,pstring s2,pstring s3)
{
    int i,j;
    s3->lengh=s1->lengh+s2->lengh;
    s3->base=(char*)malloc(s3->lengh*sizeof(char));
    for(i=0;i<s1->lengh;i++)
    {
        s3->base[i]=s1->base[i];
    }
    for(j=0;j<s2->lengh;j++)
    {
        s3->base[j+i]=s2->base[j];
    }
}
/************************************/
//子串的提取
void substr(pstring s,pstring sub,int pos,int len)
{
    int i;
     if(pos<0 || len<0  ||s->lengh<pos || len>s->lengh-pos+1)
         return ;
    sub->base=(char*)malloc(sizeof(char)*len);
    for(i=0;i<len;i++)
    {
        sub->base[i]=s->base[pos+i-1];
    }
    sub->lengh=len;
}
/*****************************************/
//子串位置的判断
int index(pstring s1,pstring s2,int pos)
{
    if(pos<1 || pos>s1->lengh)
        return 0;
    int i=pos-1,j=0;//静态不用减一是因为静态从角标为1开始存入字符而这个是从角标为0
    while(i<s1->lengh && j<s2->lengh)
    {
        if(s1->base[i]==s2->base[j])
        {
            i++;
            j++;
        }
        else
        {
            i=i-j+1;
            j=0;
        }
    }
    if(j>=s2->length)//不要忘记等于号
    {
        return i-s2->lengh;//返回的是位置不是数组的角标
    }else
        return -1;
}
/************************************/
int main()
{
    int k;
    qstring s1,s2;
    init(&s1);
    init(&s2);
    k=index(&s1,&s2,3);
    cout<<k;

}</span>

#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace  std;
typedef struct
{
    char* base;
    int lengh;
}qstring,*pstring;
void create(qstring &s)
{
    int i;
    char str[100];
    cin>>str;
    i=(int)strlen(str);
    s.base=(char*)malloc(i*sizeof(char));
    s.lengh=i;
    for(i=0;i<s.lengh;i++)
    {
        s.base[i]=str[i];
    }
}
int  compare(qstring &s1,qstring &s2)
{
    int i,n=0;
    for(i=0;i<s1.lengh && i<s2.lengh;i++)
    {
        if(s1.base[i]!=s2.base[i])
            return n=s1.base[i]-s2.base[i];
    }
    return n;
}
void substr(qstring &s,qstring &sub,int pos,int len)
{
    int i;
    sub.base=(char*)malloc(len*sizeof(char));
    for(i=0;i<len;i++)
    {
        sub.base[i]=s.base[pos-1+i];
    }
    sub.lengh=len;
}
void concat(qstring &s1,qstring &s2,qstring &s3)
{
    int i=0,j=0;
    s3.base=(char*)malloc((s1.lengh+s2.lengh)*sizeof(char));
    for(i=0;i<s1.lengh;i++)
        s3.base[i]=s1.base[i];
    s3.lengh=s1.lengh;
    for(j=0;j<s2.lengh;j++)
    {
        s3.base[j+i]=s2.base[j];
    }
    s3.lengh+=j;
}
void display(qstring &s)
{
    int i;
    for(i=0;i<s.lengh;i++)
        cout<<s.base[i];
}
void insert(qstring &s1,qstring &s2,int pos)
{
    qstring temp;
    qstring new_;
    substr(s1,temp,1,pos-1);
    concat(temp, s2, new_);
    substr(s1,temp,pos,s1.lengh-pos);//注意与静态进行对比
    concat(new_,temp,s1);
    
}
void delet(qstring &s1,int pos,int len)
{
    qstring temp;
    qstring new_;
    substr(s1,temp,1,pos-1);
    substr(s1,new_,pos+len,s1.lengh-pos-len+1);//注意与静态进行对比
    concat(temp,new_,s1);
}
int main()
{
    qstring s1,s2,s3;
    create(s1);
    delet(s1,2,4);
    display(s1);
}