Question

我有一个C函数，它接受一个名为'buffer'的字符串，并解析它，它将匹配关键字并使用它来为结构中的值赋值。

但是，我想完全忽略一些关键字。

该程序解析VCard文件（.vcf，虚拟名片）。

以下是可能提供的示例行缓冲区：

FN;CHARSET=UTF-8:David Celery

FN是我感兴趣的关键词，而David Celery是与FN相关的值。

然而，CHARSET = UTF-8是我根本不关心的事情。

所以我的问题是，有没有办法让我扫描我的缓冲区，只需用“”替换'CHARSET = UTF-8'，这样我就不用担心解析它（和其他类似的关键词我只是想忽略）。

谢谢，

Answer 1

查看一个简单的ANSI C解决方案，如：

void removeSubstring(char *s,const char *toremove)
{
  while( s=strstr(s,toremove) )
    memmove(s,s+strlen(toremove),1+strlen(s+strlen(toremove)));
}

Answer 2

其他人有一个C字符串查找和替换您可能觉得有用的函数here。

编辑：根据评论请求

，在下面的链接中包含代码段

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
 * Description:
 *   Find and replace text within a string.
 *
 * Parameters:
 *   src  (in) - pointer to source string
 *   from (in) - pointer to search text
 *   to   (in) - pointer to replacement text
 *
 * Returns:
 *   Returns a pointer to dynamically-allocated memory containing string
 *   with occurences of the text pointed to by 'from' replaced by with the
 *   text pointed to by 'to'.
 */
char *replace(const char *src, const char *from, const char *to)
{
   /*
    * Find out the lengths of the source string, text to replace, and
    * the replacement text.
    */
   size_t size    = strlen(src) + 1;
   size_t fromlen = strlen(from);
   size_t tolen   = strlen(to);
   /*
    * Allocate the first chunk with enough for the original string.
    */
   char *value = malloc(size);
   /*
    * We need to return 'value', so let's make a copy to mess around with.
    */
   char *dst = value;
   /*
    * Before we begin, let's see if malloc was successful.
    */
   if ( value != NULL )
   {
      /*
       * Loop until no matches are found.
       */
      for ( ;; )
      {
         /*
          * Try to find the search text.
          */
         const char *match = strstr(src, from);
         if ( match != NULL )
         {
            /*
             * Found search text at location 'match'. :)
             * Find out how many characters to copy up to the 'match'.
             */
            size_t count = match - src;
            /*
             * We are going to realloc, and for that we will need a
             * temporary pointer for safe usage.
             */
            char *temp;
            /*
             * Calculate the total size the string will be after the
             * replacement is performed.
             */
            size += tolen - fromlen;
            /*
             * Attempt to realloc memory for the new size.
             */
            temp = realloc(value, size);
            if ( temp == NULL )
            {
               /*
                * Attempt to realloc failed. Free the previously malloc'd
                * memory and return with our tail between our legs. :(
                */
               free(value);
               return NULL;
            }
            /*
             * The call to realloc was successful. :) But we'll want to
             * return 'value' eventually, so let's point it to the memory
             * that we are now working with. And let's not forget to point
             * to the right location in the destination as well.
             */
            dst = temp + (dst - value);
            value = temp;
            /*
             * Copy from the source to the point where we matched. Then
             * move the source pointer ahead by the amount we copied. And
             * move the destination pointer ahead by the same amount.
             */
            memmove(dst, src, count);
            src += count;
            dst += count;
            /*
             * Now copy in the replacement text 'to' at the position of
             * the match. Adjust the source pointer by the text we replaced.
             * Adjust the destination pointer by the amount of replacement
             * text.
             */
            memmove(dst, to, tolen);
            src += fromlen;
            dst += tolen;
         }
         else /* No match found. */
         {
            /*
             * Copy any remaining part of the string. This includes the null
             * termination character.
             */
            strcpy(dst, src);
            break;
         }
      }
   }
   return value;
}
void test(const char *source, const char *search, const char *repl)
{
   char *after;
   after = replace(source, search, repl);
   printf("\nsearch = \"%s\", repl = \"%s\"\n", search, repl);
   if ( after != NULL )
   {
      printf("after  = \"%s\"\n", after);
      free(after);
   }
}
int main(void)
{
   const char before[] = "the rain in Spain falls mainly on the plain";
   printf("before = \"%s\"\n", before);
   test(before, "the", "THEE");
   test(before, "the", "A");
   test(before, "cat", "DOG");
   test(before, "plain", "PLANE");
   test(before, "ain", "AINLY");
   return 0;
}
/* my output
before = "the rain in Spain falls mainly on the plain"
search = "the", repl = "THEE"
after  = "THEE rain in Spain falls mainly on THEE plain"
search = "the", repl = "A"
after  = "A rain in Spain falls mainly on A plain"
search = "cat", repl = "DOG"
after  = "the rain in Spain falls mainly on the plain"
search = "plain", repl = "PLANE"
after  = "the rain in Spain falls mainly on the PLANE"
search = "ain", repl = "AINLY"
after  = "the rAINLY in SpAINLY falls mAINLYly on the plAINLY"
*/

希望这有帮助。

Answer 3

查看string.h中的方法。

示例:(和CodePad）

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

int main()
{
    const char * source = "FN;CHARSET=UTF-8:David Celery";
    const char * newBegin = strrchr(source, ':');
    if (!newBegin)
    {
        puts("Error!");
        return -1;
    }
    newBegin++;
    puts(newBegin);
    return 0;
}

Answer 4

您可以忽略它们，而不是删除它们，例如：

#define KEY_TO_IGNORE "CHARSET=UTF-8"

char key[80];
char value[80];
char *text = "FN;CHARSET=UTF-8:David Celery";

sscanf(text, "%2s;" KEY_TO_IGNORE ":%s", key, value);

printf("key: %s, value: %s\n", key, value);

从字符串中删除子字符串？

4 个答案: