C 언어 데이터 구조의 직렬 삽입 작업

/*           */
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -2
typedef int Status;
typedef struct
{
  char *ch; //      ，         ，  ch NULL
  int length; //   
}HString;

/*******************************    ****************************************/

Status StrAssign(HString *T,char *chars);
//           chars  T
Status StrInsert (HString *S,int pos,HString T);
//1<=pos<=StrLength(S)+1.  S  pos        T
int StrLength(HString S);
//  S     ，      
int StrCompare(HString S,HString T);
// S>T，    >0, S=T，     = 0， S<T，    <0
Status ClearString(HString *S);
// S  
Status Concat(HString *T,HString S1,HString S2);
// T   S1 S2       
Status SubString(HString *Sub,HString S,int pos,int len);
// Sub   S  pos       len   
//  ,1<= pos<= StrLength(S)   0<= len <= StrLength(S)-pos+1
Status StrCopy(HString *T, HString S);
/*******************************    ****************************************/

Status StrAssign(HString *T,char *chars)
{
  if((*T).ch){ //     
    free((*T).ch);
  }
  int i = strlen(chars);
  if(!i){ // chars  
    (*T).ch = NULL;
    (*T).length = 0;
  }
  else{ //chars  
    if(!((*T).ch = (char *)malloc(i * sizeof(char)))) // T  chars       
      exit(OVERFLOW);
    int count;
    for(count = 0;count <= i-1;count++){ // chars  T 
      (*T).ch[count] = chars[count];
      (*T).length = i;
    } //for
  } //else
  return OK;
}

int StrLength(HString S)
{
  return S.length;
}

int StrCompare(HString S,HString T)
{
  int count;
  for(count = 0;count < S.length && count < T.length;count++){
    if(S.ch[count] != T.ch[count])
      return S.ch[count] - T.ch[count];
  }
  return S.length - T.length;
}

Status ClearString(HString *S)
{
  if((*S).ch){
    free((*S).ch);
    (*S).ch = NULL;
  }
  (*S).length = 0;
  return OK;
}

Status Concat(HString *T,HString S1,HString S2)
{
  if((*T).ch){ //     
    free((*T).ch);
  }
  if(!((*T).ch = (char *)malloc((S1.length+S2.length)* sizeof(char))))
    exit(OVERFLOW);
  int count,cnt;
  for(count = 0;count <= S1.length;count++){ // S1  T 
    (*T).ch[count] = S1.ch[count];
  }
  (*T).length = S1.length + S2.length; //  T        
  for(count = S1.length,cnt = 0;count <= (*T).length;count++,cnt++){
    (*T).ch[count] = S2.ch[cnt]; // S2  T 
  }
  return OK;
}

Status SubString(HString *Sub,HString S,int pos,int len)
{
  if(pos<1 || pos>S.length || len<0 || len >S.length-pos+1)
    return ERROR;
  if((*Sub).ch){ //     
    free((*Sub).ch);
  }
  if(!len){
    (*Sub).ch = NULL;
    (*Sub).length = 0; //   
  }
  else{ //    
    (*Sub).ch = (char *)malloc(len*sizeof(char));
    int count,cnt;
    for(count = 0,cnt = pos-1;count <= len-1;count++,cnt++){
      (*Sub).ch[count] = S.ch[cnt];
    }
    (*Sub).length = len;
  }//else
  return OK;
}

Status StrInsert (HString *S,int pos,HString T)
{
  if(pos<1 || pos >(*S).length+1)
    return ERROR; //pos   
  if(T.length){
    if(!((*S).ch = (char*)realloc((*S).ch,((*S).length + T.length)*sizeof(char))))
      exit(OVERFLOW);
    int count,cnt;
    for(count = (*S).length-1;count>= pos-1;count--){
      (*S).ch[count+T.length-1] = (*S).ch[count]; //   T    
    }
    for(count = pos-1,cnt = 0;cnt<= T.length-1;count++,cnt++)
    (*S).ch[count] = T.ch[cnt]; //  T
    (*S).length += T.length;
  }//if
  return OK;
}

Status StrCopy(HString *T, HString S){
  int j;
  if((*T).ch)
    free((*T).ch);
  (*T).ch = (char*)malloc(S.length * sizeof(char));
  if(!(*T).ch)
    exit(OVERFLOW);
  for(j = 0; j < S.length; j++)
    (*T).ch[j] = S.ch[j];
  (*T).length = S.length;
  return OK;
}

/*******************************     **************************************/

int main()
{
  HString T,S,S1,S2,Sub;
  char *charsT = "abcd";
  char *chars1 = "abc";
  char *chars2 = "AAAA";

  StrAssign(&T,charsT);
  StrAssign(&S,chars1);
  StrAssign(&S1,chars1);
  StrAssign(&S2,chars2);
  int count;
  printf("T    ：%d
",T.length);
  printf("T    ：");
  for(count = 0;count <T.length;count++){
    printf("%c",T.ch[count]);
  }
  printf("
");

  printf("
StrCompare(S,T) = %d
",StrCompare(S,T));

  Concat(&T,S1,S2);
  printf("
  S1，S2 T  
");
  printf("T    ：%d
",T.length);
  printf("T    ：");
  for(count = 0;count <T.length;count++){
    printf("%c",T.ch[count]);
  }
  printf("
");

  printf("
S    ：%d
",S.length);
  printf("S    ：");
  for(count = 0;count <S.length;count++){
    printf("%c",S.ch[count]);
  }
  printf(" Sub  S  1       2   
");
  SubString(&Sub,S,1,2);
  printf("Sub    ：%d
",Sub.length);
  printf("Sub    ：");
  for(count = 0;count <Sub.length;count++){
    printf("%c",Sub.ch[count]);
  }
  printf("
");

  printf("
  S  1        T
");
  StrInsert(&S,1,T);
  printf("S    ：%d
",S.length);
  printf("S    ：");
  for(count = 0;count <S.length;count++){
    printf("%c",S.ch[count]);
  }
  return 0;
}