串定长顺序结构实现

SString.h

#include<stdio.h>
#include<string.h>

#define MAXSTRLEN 20
#define u_char unsigned char

//重定义数组指针类型

typedef u_char SString[MAXSTRLEN+1];

void InitString(SString S);
void PrintString(SString S);

void StrAssign(SString S, char *str);
void StrCopy(SString S, SString T);
bool StrEmpty(SString S);
int  StrCompare(SString S, SString T);
int  StrLength(SString S);
void StrConcat(SString T, SString s1, SString s2);
void SubString(SString S, SString sub,int pos, int len);
void StrInsert(SString S, int pos, SString T);
void StrDelete(SString S, int pos, int len);
void StrClear(SString S);
/
int StrIndex(SString S, SString T, int pos);
void StrReplace(SString S, SString T, SString V);

SString.c

 #include"SString.h"

//初始化一个空串

void InitString(SString S)
{
    S[0] = '\0';
}

//打印字符串

void PrintString(SString S)
{

    //S代表字符数组指针，本身就是地址类型
    printf("%s\n",S);
}

//生成一个值等于str的字符串S

void StrAssign(SString S, char *str)
{
    int len = strlen(str);
    for(int i=0; i<len; ++i)
    {
        S[i] = str[i];
    }
    S[len] = '\0';
}

//字符串拷贝
void StrCopy(SString S, SString T)
{
    int len = StrLength(T);
    for(int i=0; i<len; ++i)
    {
        S[i] = T[i];
    }
    S[len] = '\0';
}

//判断字符串是否为空
bool StrEmpty(SString S)
{
    return S[0] == '\0';
}

//字符串比较，若S>T,返回值>0, S<T，返回值<0, 否则等于0
int  StrCompare(SString S, SString T)
{
    int result = 0;

    int i=0, j=0;
    while(S[i]!='\0' || T[j]!='\0')
    {
        result = *S-*T;
        if(result != 0)
            break;
        i++;
        j++;
    }
    if(result > 0)
        result = 1;
    else if(result < 0)
        result = -1;
    return result;
}

//返回字符串长度，即S的元素个数
int  StrLength(SString S)
{
    int len = 0;

    for(int i=0; S[i]!='\0'; i++)
    {
        len++;
    }
    return len;
}

//字符串拼接
void StrConcat(SString T, SString s1, SString s2)
{
    int len1 = StrLength(s1);
    int len2 = StrLength(s2);

    if(len1+len2 <= MAXSTRLEN)
    {

        //装得下两个子串->直接装入
        for(int i=0; i<len1; ++i)
        {
            T[i] = s1[i];
        }
        for(int j=0; j<len2; ++j)
        {
            T[i+j] = s2[j];
        }
        T[len1+len2] = '\0';
    }
    else if(len1 < MAXSTRLEN)
    {

        //只装得下s1和部分s2->s2需要截断
        for(int i=0; i<len1; ++i)
        {
            T[i] = s1[i];
        }
        for(int j=0; j<MAXSTRLEN-len1; ++j)
        {
            T[i+j] = s2[j];
        }
        T[MAXSTRLEN] = '\0';
    }
    else
    {

       //只装得下s1
        for(int i=0; i<len1; ++i)
        {
            T[i] = s1[i];
        }
        T[MAXSTRLEN] = '\0';
    }
}

//求子串，返回串S的第pos个字符起长度为len的子串，存到sub字符数组中
void SubString(SString S, SString sub,int pos, int len)
{
    int s_len = StrLength(S);
    if(pos<0 || pos>=s_len || len<0 || len>s_len)
        return;
    int j = pos;
    for(int i=0; i<len; ++i)
    {
        sub[i] = S[j+i];
    }
    sub[len] = '\0';
}

//在串S的第pos个字符之前插入串T

//要考虑S串能否装得下的问题，假如装不下则需要截断串T，

//然后从pos位置起的字符往后挪t_len（实际能插入的长度）位，再将t插入
void StrInsert(SString S, int pos, SString T)
{
    int s_len = StrLength(S);
    int t_len = StrLength(T);

    if(s_len+t_len <= MAXSTRLEN)
    {
        for(int i=s_len-1; i>=pos; --i)
        {
            S[i+t_len] = S[i];
        }

        int j = pos;
        for(i=0; i<t_len; ++i)
        {
            S[j+i] = T[i];
        }
        S[s_len+t_len] = '\0';
    }
    else if(s_len < MAXSTRLEN)
    {
        t_len = MAXSTRLEN - s_len;
        for(int i=s_len-1; i>=pos; --i)
        {
            S[i+t_len] = S[i];
        }

        int j = pos;
        for(i=0; i<t_len; ++i)
        {
            S[j+i] = T[i];
        }
        S[s_len+t_len] = '\0';
    }
}

//从串S中删除第pos个字符起长度为len的子串
void StrDelete(SString S, int pos, int len)
{
    int s_len = StrLength(S);

    //pos之后的每个字符前移len长度大小
    for(int i=pos; i<s_len; ++i)
    {
        S[i] = S[i+len];
    }
    S[s_len-len] = '\0';
}
void StrClear(SString S)
{
    S[0] = '\0';
}

//从串S的第pos位置起查找子串T

//BF算法，在串s中从pos位置起寻找子串t，如果找到则返回其第一个字符在s串的位置

int StrIndex(SString S, SString T, int pos)
{
    int i = pos; //串S查找的初始位置，从pos位置开始比较
    int j = 0;
    while(S[i]!='\0' && T[j]!='\0')
    {
        if(S[i] == T[j])
        {
            i++;
            j++;
        }
        else
        {

           //查找失败，i每次继续从下一个位置查找，j从0开始查找
            i = i-j+1;
            j = 0;
        }
    }

    //子串T遍历完成，返回在主串S中第pos位置后第一次出现的位置，否则返回-1
    if(T[j] == '\0')
        return i-j;
    return -1;
}

//字符串替换，用V替换主串S中出现的所有与T相等的不重叠的子串

void StrReplace(SString S, SString T, SString V)
{
    int s_len = StrLength(S);
    int t_len = StrLength(T);
    int v_len = StrLength(V);

    int index = -1;
    int pos = 0;

    //先调用定位方法，找到子串t在串s中的位置pos，

   //然后调用删除方法删除从pos位置起长度为t_len的字符串，

   //最后调用插入方法从pos位置起插入串v。

    while(pos < s_len)
    {
        index = StrIndex(S,T,pos);
        if(index == -1)
            return;
        StrDelete(S,index,t_len);
        StrInsert(S,index,V);

        pos = index + v_len;
    }
}

#include"SString.h"

void main()
{
    SString S;
    InitString(S);
    StrAssign(S,"ababcababcabc");

    SString T;
    InitString(T);
    StrAssign(T,"abc");

    SString V;
    InitString(V);
    StrAssign(V,"xy");

    StrReplace(S,T,V);

    PrintString(S); //abxyabxyab

    //int index = StrIndex(S,T,0);
}

/*
void main()
{
    SString S;
    InitString(S);
    SString T;
    InitString(T);

    StrAssign(S,"abc");
    StrAssign(T,"xyz");

    SString Y;
    InitString(Y);
    StrConcat(Y,S,T);
    PrintString(Y);
}
*/