ストリングのヒープ割当てストレージ


 /* c4-2.h         */
 typedef struct
 {
   char *ch; /*      ,         ,  ch NULL */
   int length; /*     */
 }HString;

 
 /* bo4-2.c           ( c4-2.h  )     (15 ) */
 /*     4.1、4.4 */
 Status StrAssign(HString *T,char *chars)
 { /*            chars  T */
   int i,j;
   if((*T).ch)
     free((*T).ch); /*   T     */
   i=strlen(chars); /*  chars   i */
   if(!i)
   { /* chars    0 */
     (*T).ch=NULL;
     (*T).length=0;
   }
   else
   { /* chars     0 */
     (*T).ch=(char*)malloc(i*sizeof(char)); /*       */
     if(!(*T).ch) /*         */
       exit(OVERFLOW);
     for(j=0;j<i;j++) /*     */
       (*T).ch[j]=chars[j];
     (*T).length=i;
   }
   return OK;
 }

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

 Status StrEmpty(HString S)
 { /*     :  S  。    :  S   ,   TRUE,    FALSE */
   if(S.length==0&&S.ch==NULL)
     return TRUE;
   else
     return FALSE;
 }

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

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

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

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

 Status SubString(HString *Sub, HString S,int pos,int len)
 { /*  Sub   S  pos       len   。 */
   /*   ,1≤pos≤StrLength(S) 0≤len≤StrLength(S)-pos+1 */
   int i;
   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));
     if(!(*Sub).ch)
       exit(OVERFLOW);
     for(i=0;i<=len-1;i++)
       (*Sub).ch[i]=S.ch[pos-1+i];
     (*Sub).length=len;
   }
   return OK;
 }

 void InitString(HString *T)
 { /*    (    )   T。   */
   (*T).length=0;
   (*T).ch=NULL;
 }

 int Index(HString S,HString T,int pos) /*   4.1 */
 { /* T    。   S  pos        T     , */
   /*             S    ,    0 */
   int n,m,i;
   HString sub;
   InitString(&sub);
   if(pos>0)
   {
     n=StrLength(S);
     m=StrLength(T);
     i=pos;
     while(i<=n-m+1)
     {
       SubString(&sub,S,i,m);
       if(StrCompare(sub,T)!=0)
	 ++i;
       else
	 return i;
     }
   }
   return 0;
  }

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

 Status StrDelete(HString *S,int pos,int len)
 { /*   S    pos       len    */
   int i;
   if((*S).length<pos+len-1)
     exit(ERROR);
   for(i=pos-1;i<=(*S).length-len;i++)
     (*S).ch[i]=(*S).ch[i+len];
   (*S).length-=len;
   (*S).ch=(char*)realloc((*S).ch,(*S).length*sizeof(char));
   return OK;
 }

 Status Replace(HString *S,HString T,HString V)
 { /*     :  S,T V  ,T    (            ) */
   /*     :  V    S       T          */
   int i=1; /*   S          T */
   if(StrEmpty(T)) /* T    */
     return ERROR;
   do
   {
     i=Index(*S,T,i); /*   i     i       T    */
     if(i) /*  S    T */
     {
       StrDelete(S,i,StrLength(T)); /*     T */
       StrInsert(S,i,V); /*    T      V */
       i+=StrLength(V); /*      V       T */
     }
   }while(i);
   return OK;
 }

 void DestroyString()
 { /*               */
 }

 void StrPrint(HString T)
 { /*   T   。   */
   int i;
   for(i=0;i<T.length;i++)
     printf("%c",T.ch[i]);
   printf("
"); }

 
 /* main4-2.c   bo4-2.c     */
 #include"c1.h"
 #include"c4-2.h"
 #include"bo4-2.c"
 void main()
 {
   int i;
   char c,*p="God bye!",*q="God luck!";
   HString t,s,r;
   InitString(&t); /* HString        */
   InitString(&s);
   InitString(&r);
   StrAssign(&t,p);
   printf(" t : ");
   StrPrint(t);
   printf("   %d    ?%d(1:  0: )
",StrLength(t),StrEmpty(t)); StrAssign(&s,q); printf(" s : "); StrPrint(s); i=StrCompare(s,t); if(i<0) c='<'; else if(i==0) c='='; else c='>'; printf(" s%c t
",c); Concat(&r,t,s); printf(" t s r : "); StrPrint(r); StrAssign(&s,"oo"); printf(" s : "); StrPrint(s); StrAssign(&t,"o"); printf(" t : "); StrPrint(t); Replace(&r,t,s); printf(" r t s , r :
"); StrPrint(r); ClearString(&s); printf(" s , %d ?%d(1: 0: )
",StrLength(s),StrEmpty(s)); SubString(&s,r,6,4); printf(" s r 6 4 , %d s : ",s.length); StrPrint(s); StrCopy(&t,r); printf(" t r, t : "); StrPrint(t); StrInsert(&t,6,s); printf(" t 6 s , t : "); StrPrint(t); StrDelete(&t,1,5); printf(" t 1 5 , t : "); StrPrint(t); printf("%d t 1 , s 1
",Index(t,s,1)); printf("%d t 2 , s 1
",Index(t,s,2)); }