C 用几个分隔符中的一个分隔字符串？

我有这个

A>B

，或

A

，或

A==B

使用

strtok

我将销毁数据，我的目标是获得某种结构，以便检查：

我有什么样的定界符

进入它的两侧（A和B）

因此：

我知道这听起来很简单，但总是很麻烦

编辑：

我所做的是，这项任务似乎太长了：

for (int k=1;k<strlen(p);k++)
{

    char left[4]="" ;
    char right[12]="" ;



    switch(p[k])
    {


        case '>' :
        {
            long num =strstr(p,">") - p ;
            strncpy(left,p,num);
            strncpy(right,p+num+1,strlen(p)-num-1);


            break;
        }



        case '<' :
        {
            long num =strstr(p,"<") - p ;
            strncpy(left,p,num);
            strncpy(right,p+num+1,strlen(p)-num-1);


            break;
        }


        case '=' :

        {
            long num =strstr(p,"=") - p ;
            strncpy(left,p,num);
            strncpy(right,p+num+1,strlen(p)-num-1);


            break;
        }

        case '!' :
        {
            long num =strstr(p,"!") - p ;
            strncpy(left,p,num);
            strncpy(right,p+num+1,strlen(p)-num-1);


            break;
        }

        default :
        {}
    }


}

---

for（int k=1；k对于只想解析由两个操作数和一个运算符组成的简单字符串的简单情况，没有“表达式”可以这样做

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

int
main(void)
{
    const char *string = "A > B";
    char lho[100];
    char op[3];
    char rho[100];
    if (sscanf(string, "%99[^=><]%2[=><]%99[^=><]", lho, op, rho) == 3) {
        fprintf(stdout, "left hand operand: %s\n", lho);
        fprintf(stdout, "operator: %s\n", op);
        fprintf(stdout, "right hand operand: %s\n", rho);
    }
    return 0;
}

#包括
#包括
int
主（空）
{
常量char*string=“A>B”；
charlho[100]；
char-op[3]；
char-rho[100]；
如果（sscanf（string），%99[^=>这是一个通用过程：

对于给定的一组
分隔符
，使用
strstr
检查每个分隔符是否出现在输入字符串中。作为奖励，下面的代码允许“双”输入，例如
strlen（分隔符[best_-fit_-delim]））
最佳拟合度=迭代器；
}
迭代器++；
}
/*我们找到什么了吗*/
如果（最佳拟合度==-1）
返回0；
/*将ptr重置为此已找到的ptr*/
ptr=strstrstr（输入，分隔符[最佳匹配]）；
/*复制左侧*/
迭代器=ptr-输入；
/*在末尾清除空白*/
while（迭代器>0&&isspace（输入[iterator-1]））
迭代器--；
*dest_left=malloc（迭代器+1）；
memcpy（*dest_left，input，iterator）；
（*dest_left）[迭代器]=0；
/*分隔符本身*/
*dest_delim=malloc（strlen（分隔符[最佳匹配]）+1）；
strcpy（*dest_delim，分隔符[最佳匹配]）；
/*更新指向分隔符*结尾*的指针*/
ptr+=strlen（分隔符[最佳匹配]）；
/*开始时跳过空白*/
while（isspace（*ptr））
ptr++；
/*复制右侧*/
*dest_right=malloc（strlen（ptr）+1）；
strcpy（*目的地右侧，ptr）；
返回1；
}
内部主（空）
{
char*source_str=“A B”；
字符*左，*德利姆，*右；
if（！split_string（source_str，&left，&delim，&right））
{
printf（“无效输入\n”）；
}否则
{
printf（“左：\%s\”\n，左）；
printf（“delim:\%s\“\n”，delim）；
printf（“右：\%s\”\n，右）；
自由（左）；
免费（delim）；
自由（权利）；
}
返回0；
}

对于
ab
，结果为

left: "A"
delim: "<>"
right: "B"

左：“A”
德里姆：“我的朋友。”
右：“B”

如果只需要检查
列表，代码可能会小一些；然后可以对单个字符使用
strchr
（如果找到
=
，请检查下一个字符）。您还可以忘记
最佳匹配长度检查，因为只有一个匹配

代码仅删除比较运算符周围的空格。为保持一致性，您可能希望删除输入开始和结束处的所有空格；然后，返回长度为
0
的
left
或
right
变量可检测到无效输入–即，它们仅包含
0
字符串minator。您仍然需要
释放那些零长度字符串

为了好玩，您可以将
“GT”、“LT”、“GE”、“LE”
添加到分隔符中，并查看它如何处理字符串，例如
A GT B
、
ALLEQUAL
和
FAULTY@mik1904它不能与“==”一起使用，它不是一个字符。因为可能有也可能没有空格分隔符（或者看起来是这样），仅仅指针是不够的。您需要一个
结果
结构，其中至少包含一个指向每个标记开头及其长度的指针，或者，将每个标记复制到一个新字符串中。代码可以非常简单；到目前为止，您有什么？以下是文档项目中的
strcspn
示例：@MarkPlotnick I关于strpbrk（）的思考
所有的解决方案都有一个问题，
=
。编写将字符串拆分为标记的C代码总是有点麻烦。如果这是一个赋值，并且要求您只使用C，那么这是不可避免的。但是解析算术表达式是很多程序都会做的事情，而且他们通常使用
lex或
flex
和
yacc
或
bison
生成C代码。这里有一个页面显示了它有多简单：哇，这看起来很聪明！：）你为什么不使用它？因为它不可靠。我不能立即想到一个明显失败的案例。但我不能
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

const char *delimiters[] = {
    "<", ">", "==", "<>", NULL
};

int split_string (const char *input, char **dest_left, char **dest_delim, char **dest_right)
{
    int iterator;
    int best_fit_delim;
    char *ptr;

    /* (optionally) clean whitespace at start */
    while (isspace(*input))
        input++;

    /* look for the longest delimiter we can find */
    best_fit_delim = -1;
    iterator = 0;
    while (delimiters[iterator])
    {
        ptr = strstr (input, delimiters[iterator]);
        if (ptr)
        {
            if (best_fit_delim == -1 || strlen(delimiters[iterator]) > strlen(delimiters[best_fit_delim]))
                best_fit_delim = iterator;
        }
        iterator++;
    }

    /* did we find anything? */
    if (best_fit_delim == -1)
        return 0;

    /* reset ptr to this found one */
    ptr = strstr (input, delimiters[best_fit_delim]);

    /* copy left hand side */
    iterator = ptr - input;
    /* clean whitespace at end */
    while (iterator > 0 && isspace(input[iterator-1]))
        iterator--;
    *dest_left = malloc (iterator + 1);
    memcpy (*dest_left, input, iterator);
    (*dest_left)[iterator] = 0;

    /* the delimiter itself */
    *dest_delim = malloc(strlen(delimiters[best_fit_delim])+1);
    strcpy (*dest_delim, delimiters[best_fit_delim]);

    /* update the pointer to point to *end* of delimiter */
    ptr += strlen(delimiters[best_fit_delim]);
    /* skip whitespace at start */
    while (isspace(*ptr))
        ptr++;

    /* copy right hand side */
    *dest_right = malloc (strlen(ptr) + 1);
    strcpy (*dest_right, ptr);

    return 1;
}

int main (void)
{
    char *source_str = "A <> B";
    char *left, *delim, *right;

    if (!split_string (source_str, &left, &delim, &right))
    {
        printf ("invalid input\n");
    } else
    {
        printf ("left: \"%s\"\n", left);
        printf ("delim: \"%s\"\n", delim);
        printf ("right: \"%s\"\n", right);

        free (left);
        free (delim);
        free (right);
    }
    return 0;
}

left: "A"
delim: "<>"
right: "B"