<<字符串高级截取和统计>>一文的C语言实现

突然看到首页出现两篇题目极为相似的文章，一看，居然还是不同作者，看了幽梦新影兄的执行结果，突然想起自己好像也有用C语言写过类似代码。（纯属凑热闹了）

《<<字符串高级截取和统计>>一文的看法与正则表达式的实现》

《<<字符串高级截取和统计>>一文的C#正则实现》

《字符串高级截取和统计》（补充一下，尽然又发现一篇～）

不过不知道为什么遇到这样的功能大家就一定要想到“正则实现”呢？曾经参加微软的一个第三方培训的时候得知正则表达式的效率相当的低下，大部分的性能瓶颈均出于此，不过那个培训是高性能培训。

但值得肯定的是这个正则表达式绝对是一个优秀的实践。很多纷繁复杂的查找匹配规则通过正则表达式立刻就能迅速求解了。

下面这个C语言程序是我以前写着玩的程序，刚才突然想到了，就贴出来一同完善这个解决方案。不过不难看出用传统的字符构成字符串的思路，要写完这个类似的功能，工作量还是相当巨大的。但是用正则表达式则能够让代码简洁优美。至于效率，我个人认为其实完全可以忽略不计。

不过我这个代码的实现好像有附加了其它的一些功能，不过没关系，只增不减。

 1 /*
 2  * textsearch.h
 3  *
 4  *  Created on: 
 5  *      Author:        Volnet
 6  *      Website:    http://volnet.cnblogs.com
 7  *                    
 8  */
 9 
 #ifndef TEXTSEARCH_H_
 #define TEXTSEARCH_H_
 
 #include <stdarg.h>
 
 #ifndef INDEX_T_DEFINDED
 typedef int index_t;
 #define INDEX_T_DEFINDED
 #endif
 
 #ifndef COUNT_T_DEFINDED
 typedef unsigned int count_t;
 #define COUNT_T_DEFINDED
 #endif
 
 /*
  * @return
  *     offset: the number of chars that
  *             from you found to the end of the word
  *             after you execute the search_foreach function.
  *         e.g.
  *             if you replace("abcdefgh", "de", "123");//abc45fgh;
  *             you had set offset as 3,
  *             which will let the pointer at the next char 'f';
  * */
 typedef void (*search_foreach)(const char *text,
         const char *found, index_t lengthOfFound,
         index_t *offset,
         va_list *paras);
 typedef void (*search_global)(va_list *paras, void *ret);
 #define UNFINDED (index_t)-1
 #define MAX_INDICES 1000;
 
 /*declartion of functions*/
 
 /*function :To find the first char(c) in text
  * @paras
  * text    :a pointer to the first char of the text to search
  * c    :the char to find.
  * out_indices :(return) an array takes the indices of the tofind in the text.
  *                 (value) if(out_indices == NULL), it without any exceptions.
  * tofind :the word to find in the text.
  * @return    :the index of the char in the text.It will be 'UNFINDED' as no find.
  * */
 index_t indexof(const char *text, char c);
 count_t search_c(const char *text, const char c, index_t *out_indices);
 count_t search_s(const char *text, const char *tofind, index_t *out_indices);
 count_t search_s_foreach(
         /*the full text to search.*/
         const char *text,
         /*the word to find in the text.*/
         const char *tofind,
         /*(return) an array takes the indices of the tofind in the text.
          * (value) if(out_indices == NULL), it without any exceptions.
          * */
         index_t *out_indices,
         /*a function to gfunc() for the text.
          * it will execute at the front of all.
          * */
         search_global gfunc,
         /*the number of gfunc's parameters. */
         const size_t gfunc_paras_count,
         /*a function to func() for each of
          * the word search_s from text.
          * */
         search_foreach func,
         /*if gfunc!=NULL, the first parameter is the {char *ret; }
          * ret is the parameter for return.
          * */
         
         );
 /*
  * function :replace the word 's1' to 's2' in text.
  * @return :
  *     ret: an array who has enough space to load the result.
  *             text != ret
  * */
 void replace(const char *text, const char *s1, const char *s2, char ret[]);
 /* function :remove the word 's' in text.
  * @return :
  *     ret: an array who has enough space to load the result.
  *             text != ret
  * */
 void to_remove(char *text, const char *s, char ret[]);
 
 #endif /* TEXTSEARCH_H_ */
 

  1 /*
  2  * textsearch.c
  3  *
  4  *  Created on: 
  5  *      Author:        Volnet
  6  *      Website:    http://volnet.cnblogs.com
  7  *                   
  8  */
  9 
 10 #include <stdio.h>
 11 #include <stdlib.h>
 12 #include <stdarg.h>
 13 #include "../header/textsearch.h"
 14 
 15 /*
 16  * @return:
 17  *     the first index of which difference char of another string.
 18  * */
 19 static index_t compareTo_n(const char *s1, const char *s2, const count_t n);
 20 static count_t length(const char *s);
 21 static void replace_call(const char *text, const char *found, index_t lengthOfFound,
 22         index_t *offset, va_list *paras);
 23 static void strcpy_gcall(va_list *paras, void *ret);
 24 
 25 index_t indexof(const char *text, char c) {
 26     index_t index;
 27     index = 0;
 28 
 29     if (!sizeof text || !c)
 30         return UNFINDED;
 31 
 32     while (*text) {
 33         if (*text == c)
 34             return index;
 35         index++;
 36         text++;
 37     }
 38     return UNFINDED;
 39 }
 40 
 41 count_t search_c(const char *text, const char c, index_t *out_indices) {
 42     count_t count;
 43     index_t curr;
 44     count = 0;
 45     curr = 0;
 46     while (*text) {
 47         if (*text == c) {
 48             count++;
 49             *out_indices++ = curr;
 50         }
 51         curr++;
 52         text++;
 53     }
 54     return count;
 55 }
 56 
 57 count_t search_s(const char *text, const char *tofind, index_t *out_indices) {
 58     return search_s_foreach(text, tofind, out_indices, NULL, 0, NULL);
 59 }
 60 
 61 count_t search_s_foreach(const char *text, const char *tofind, index_t *out_indices,
 62         search_global gfunc, const size_t gfunc_paras_count,
 63         search_foreach func, ) {
 64     count_t count;
 65     index_t curr;
 66     count_t lengthOfToFind;
 67     count_t offset;
 68     size_t argCount;
 69     va_list ap;
 70     void *ret;
 71     count_t lengthOfText;
 72     char *ttext;
 73 
 74     count = 0;
 75     curr = 0;
 76     ttext = (char *)text;
 77     lengthOfToFind = length(tofind);
 78 
 79     if (gfunc != NULL) {
 80         va_start(ap, func);
 81         ret = va_arg(ap, void *);
 82         gfunc(&ap, ret);
 83         va_end(ap);
 84         ttext = ret;
 85     }
 86 
 87     lengthOfText = length(ttext);
 88     while (*ttext) {
 89         if (*ttext == *tofind) {
 90             if (lengthOfToFind == (offset = compareTo_n(ttext, tofind,
 91                     lengthOfToFind))) {
 92                 /*if found*/
 93                 if (out_indices != NULL)
 94                     *out_indices++ = curr;
 95                 count++;
 96                 if (func != NULL) {
 97                     va_start(ap, func);
 98                     argCount = gfunc_paras_count;
 99                     while (argCount--)
                         va_arg(ap, void *);
                     func(ttext, tofind, lengthOfToFind, &offset, &ap);
                     va_end(ap);
                 }
             }
             curr += offset;
             ttext += offset;
         } else {
             curr++;
             ttext++;
         }
     }
 
     return count;
 }
 
 void replace(const char *text, const char *s1, const char *s2, char ret[]) {
     if (text == ret) {
         perror("warning: the pointer can't equals to the pointer to ret.\n");
         return;
     }
     search_s_foreach(text, s1, NULL, strcpy_gcall, 2, replace_call, ret, text,
         s2);
 }
 
 static void replace_call(const char *text, const char *found, index_t lengthOfFound,
         index_t *offset, va_list *paras) {
     char *s2 = va_arg(*paras, char *);
     index_t off;
     index_t lenS2;
     count_t leaveLenText;
     int inc;
     char *ttext;
 
     lenS2 = length(s2);
     *offset = lenS2;
     inc = 0;
     ttext = (char *)text;
 
     leaveLenText = length(text);
 
     /*move data*/
     off = lengthOfFound - lenS2;
     if (off > 0) {
         /*move to front*/
         while (leaveLenText--) {
             *(ttext + lenS2 + inc) = *(ttext + lengthOfFound + inc);
             inc++;
         }
     } else if (off < 0) {
         /*move to behind*/
         while (leaveLenText) {
             *(ttext + leaveLenText - off) = *(ttext + leaveLenText);
             leaveLenText--;
         }
     }
 
     /*do copy*/
     while (*s2) {
         *ttext++ = *s2++;
     }
 }
 
 void to_remove(char *text, const char *s, char ret[]) {
     replace(text, s, "", ret);
 }
 
 static void strcpy_gcall(va_list *paras, void *ret) {
     char *target = (char *) ret;
     char *text = va_arg(*paras, char *);
 
     while ((*target++ = *text++))
         ;
 }
 
 static index_t compareTo_n(const char *s1, const char *s2, const count_t n) {
     count_t tn;
     tn = n;
     while (tn--)
         if (*s1 || *s2)
             if (*s1++ != *s2++) {
                 return n - tn - 1;
             }
     return n - tn - 1;
 }
 
 static count_t length(const char *s) {
     count_t len;
     len = 0;
     while (*s++)
         len++;
     return len;
 }
 

下面是调用代码：

 1/**//*
 2 * test.c
 3 *
 4 *  Created on: 
 5 *      Author:        Volnet
 6 *      Website:    http://volnet.cnblogs.com
 7 *                    
 8 */
 9
#include <stdio.h>
#include <stdlib.h>
#include "../header/textsearch.h"

int main(void){
    char *s = "this is a word, who contains \"wh\"!";
    char c = 'w';

    index_t indices_1[100];
    index_t *indices1 = indices_1;
    count_t count1;

    char *tofind = "wh";
    char *toremove = "onson";
    char *fromreplace = "wh";
    char *toreplace = "jonson";
    index_t indices_2[100];
    index_t *indices2;
    count_t count2;
    char ts[1000];
    char rs[1000];

    /**//*e.g:*/
    /**//*index_t indexof(char *text, char c);*/
    printf("the first index of %c is %d.\n",c,indexof(s,c));

    /**//*count_t search(char *text, char c, index_t *out_indices)*/
    count1 = search_c(s,c,indices1);
    printf("the '%c' in the text is in : ",c);
    while(count1--){
        printf("%d ",*indices1++);
    }
    printf(".\n");

    /**//*count_t search_s(char *text, const char *tofind, index_t *out_indices)*/
    indices2 = indices_2;
    count2 = search_s(s,tofind,indices2);
    printf("the \"%s\" in the text is in : ",tofind);
    while(count2--){
        printf("%d ",*indices2++);
    }
    printf(".\n");

    printf("the word is:\n\t%s\n",s);
    replace(s, fromreplace, toreplace,ts);
    printf("the word has be changed as (\"%s\"->\"%s\") :\n\t%s\n",fromreplace, toreplace, ts);

    to_remove(ts,toremove,rs);
    printf("the word remove (remove \"%s\") as : \n\t%s\n",toremove,rs);

    return EXIT_SUCCESS;
}

一条正则表达式可以搞定的东西，我们需要写这么多的代码才能够实现，相形见拙就此体现。

下面是输出结果：

the first index of w is 10.
the 'w' in the text is in : 10 16 30 .
the "wh" in the text is in : 16 30 .
the word is:
        this is a word, who contains "wh"!
the word has be changed as ("wh"->"jonson") :
        this is a word, jonsono contains "jonson"!
the word remove (remove "onson") as :
        this is a word, jo contains "j"!