C中字符串中间的子串

我需要提取我知道的字符串之间的子字符串

我有一些类似于char string=“abcdefg” 我知道我需要的是介于

“c”

和

“f”

之间，那么我的报税表应该是

“de”

我知道<代码> StrncPy*（）/Case>函数，但不知道如何在字符串中间应用它。

---

谢谢。

由于人们似乎不理解我在评论中的做法，这里有一个快速拼凑的存根

const char* string = "abcdefg";
const char* b = "c";
const char* e = "f";
//look for the first pattern
const char* begin = strstr(string, b);
if(!begin)
  return NULL;
//look for the end pattern
const char* end = strstr(begin, e);
if(!end)
  return NULL;
end -= strlen(e);

char result[MAXLENGTH];
strncpy(result, begin, end-begin);

#包括
#包括
#包括
char*between（常量char*str、char from、char to）{
而（*str&&*str！=from）
++str；//跳过
如果（*str=='\0'）
返回NULL；
其他的
++str；
char*ret=malloc（strlen（str）+1）；
char*p=ret；
while（*str&&*str！=to）{
*p++=*str++；//如果“To”不存在，则结束
}
*p=0；
返回ret；
}
内部主（空）{
const char*string=“abcdefg”；
char*substr=between（字符串'c'，'f'）；
if（substr！=NULL）{
put（substr）；
免费（substr）；
}
返回0；
}

TY-guys，使用以下表格工作：

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

char *between_substring(char *str, char from, char to){
while(*str && *str != from)
    ++str;//skip
if(*str == '\0')
    return NULL;
else
    ++str;

char *ret = malloc(strlen(str)+1);
char *p = ret;
while(*str && *str != to){
    *p++ = *str++;//To the end if `to` do not exist
}
*p = 0;
return ret;
}

int main (void){
char source[] = "abcdefg";
char *target;
target = between(source, 'c', 'f');
printf("%s", source);
printf("%s", target);

return 0;   
}

#包括
#包括
#包括
char*between_子字符串（char*str、char-from、char-to）{
而（*str&&*str！=from）
++str；//跳过
如果（*str=='\0'）
返回NULL；
其他的
++str；
char*ret=malloc（strlen（str）+1）；
char*p=ret；
while（*str&&*str！=to）{
*p++=*str++；//如果“To”不存在，则结束
}
*p=0；
返回ret；
}
内部主（空）{
char source[]=“abcdefg”；
字符*目标；
目标=介于（源'c'，f'）之间；
printf（“%s”，来源）；
printf（“%s”，目标）；
返回0；
}

以下是一个完整的工作示例：

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

int main(void) {
    char string[] = "abcdefg";

    char from[] = "c";
    char to[]   = "f";

    char *first = strstr(string, from);

    if (first == NULL) {
        first = &string[0];
    } else {
        first += strlen(from);
    }

    char *last = strstr(first, to);

    if (last == NULL) {
        last = &string[strlen(string)];
    }

    char *sub = calloc(strlen(string) + 1, sizeof(char));

    strncpy(sub, first, last - first);

    printf("%s\n", sub);

    free(sub);

    return 0;
}

字符串声明：要检查的主字符串、开始分隔符、结束分隔符。注意，这些也是数组，因此

from

和

to

可以分别是

cd

和

fg

2.

    char string[] = "abcdefg";

    char from[] = "c";
    char to[]   = "f";

    char *first = strstr(string, from);

    if (first == NULL) {
        first = &string[0];
    } else {
        first += strlen(from);
    }

    char *last = strstr(first, to);

    if (last == NULL) {
        last = &string[strlen(string)];
    }

    char *sub = calloc(last - first + 1, sizeof(char));

    strncpy(sub, first, last - first);

    printf("%s\n", sub);

在主字符串中查找开始分隔符的位置。请注意，它会查找第一个实例-如果您需要查找最后一个实例（例如，如果您有字符串

abcabc

，并且希望从第二个

a

）中找到一个子字符串，则可能需要不同的实例

3.

    char string[] = "abcdefg";

    char from[] = "c";
    char to[]   = "f";

    char *first = strstr(string, from);

    if (first == NULL) {
        first = &string[0];
    } else {
        first += strlen(from);
    }

    char *last = strstr(first, to);

    if (last == NULL) {
        last = &string[strlen(string)];
    }

    char *sub = calloc(last - first + 1, sizeof(char));

    strncpy(sub, first, last - first);

    printf("%s\n", sub);

处理第一个分隔符不出现在字符串中的情况。在这种情况下，我们将从整个字符串的开头创建一个子字符串。但是，如果确实出现，我们将指针从字符串中移动

长度，因为我们需要提取第一个分隔符后开始的子字符串（由于@dau_sama的更正）。
根据您的规格，可能需要也可能不需要，或者可能会出现其他结果

4.

    char string[] = "abcdefg";

    char from[] = "c";
    char to[]   = "f";

    char *first = strstr(string, from);

    if (first == NULL) {
        first = &string[0];
    } else {
        first += strlen(from);
    }

    char *last = strstr(first, to);

    if (last == NULL) {
        last = &string[strlen(string)];
    }

    char *sub = calloc(last - first + 1, sizeof(char));

    strncpy(sub, first, last - first);

    printf("%s\n", sub);

在主字符串中查找结束分隔符的位置。请注意，它会找到第一次出现

正如@dau_sama所指出的，最好从
开头搜索结束分隔符，而不是从整个字符串的开头。这可以防止出现这样的情况：
到
出现的时间早于
从

5.

    char string[] = "abcdefg";

    char from[] = "c";
    char to[]   = "f";

    char *first = strstr(string, from);

    if (first == NULL) {
        first = &string[0];
    } else {
        first += strlen(from);
    }

    char *last = strstr(first, to);

    if (last == NULL) {
        last = &string[strlen(string)];
    }

    char *sub = calloc(last - first + 1, sizeof(char));

    strncpy(sub, first, last - first);

    printf("%s\n", sub);

处理第二个分隔符不出现在字符串中的情况。在这种情况下，我们将创建一个子字符串，直到字符串结束，因此我们将获得指向最后一个字符的指针。
同样，根据您的规格，这可能需要也可能不需要，或者可能会出现另一个结果

6.

    char string[] = "abcdefg";

    char from[] = "c";
    char to[]   = "f";

    char *first = strstr(string, from);

    if (first == NULL) {
        first = &string[0];
    } else {
        first += strlen(from);
    }

    char *last = strstr(first, to);

    if (last == NULL) {
        last = &string[strlen(string)];
    }

    char *sub = calloc(last - first + 1, sizeof(char));

    strncpy(sub, first, last - first);

    printf("%s\n", sub);

根据前面找到的指针分配足够的内存并提取子字符串。我们复制
last-first
（子字符串的长度）字符，从
first
字符开始

7.

    char string[] = "abcdefg";

    char from[] = "c";
    char to[]   = "f";

    char *first = strstr(string, from);

    if (first == NULL) {
        first = &string[0];
    } else {
        first += strlen(from);
    }

    char *last = strstr(first, to);

    if (last == NULL) {
        last = &string[strlen(string)];
    }

    char *sub = calloc(last - first + 1, sizeof(char));

    strncpy(sub, first, last - first);

    printf("%s\n", sub);

这是结果

我希望它确实提供了足够详细的问题。根据您的具体规格，您可能需要以某种方式对此进行更改。例如，如果您需要查找所有子字符串，而不仅仅是第一个子字符串，则可能需要循环查找
first
和
last
显示您已尝试过的内容，以便我们可以更正您的代码此定义是错误的
char string=“abcdefg”
。我们需要确切了解您的定义，检查函数：const char*strstr（const char*str1，const char*str2）；这基本上就是你所需要的。我们将等待您的代码的更新版本：-）请阅读
strchr
。和/或
strpos
。为什么
end-=strlen（e）
？因为第二个模式可能超过1个字符，并且strstr在匹配整个字符串后返回指针。如果您有：const char*e=“fad”并且字符串中有：“fadeee”，它将返回指向第一个“e”的指针，但是如果您想剪切whle字符串，则需要将其向左移动。如果您查看我的存根答案，从中您获得了灵感，您会发现您的方法存在问题。char*first=strstrstr（字符串，from）；char*last=strstrstr（字符串，to）；最后一个可以<第一个，具体取决于模式。我建议您调用char*last=strstrstr（第一，to）；相反，您不需要分配这么大的字符串：char*sub=calloc（strlen（string）+1，sizeof（char））；（最后-第一）+1是正确的。此外，如果模式长度超过一个字符，您的代码将无法工作，strstrstr将在匹配字符串后返回指针！：-）