Question

我使用缓冲区从串口接收数据。缓冲区的长度固定为100，当我收到数据时，我将这些数据的长度存储在一个变量（索引）中。

我想检查从0到索引1的缓冲区是否包含子字符串。

我已经读过，我可以使用strstr和strdup来做，但我有两个问题。首先，我不知道如何从缓冲区中提取字符串，其次，如果我不需要复制字符串只是为了在以后查找子字符串时将其删除一行，那就更好了。

我的变量如下：

char output[100];
int index = 0;
char* substring;

我想要一个函数，如果substring在输出[0：index]中则返回true，否则返回false。

非常感谢任何帮助或领导！

编辑：我正在为atmelμC编写一段代码，因此我似乎只限于those functions。

编辑2：实际上我似乎可以使用标准string.h中的所有函数

编辑3：我在我的依赖项中检查了肯定，以及我可以调用的所有函数。

extern int ffs (int __val) __ATTR_CONST__;
extern int ffsl (long __val) __ATTR_CONST__;
extern int ffsll (long long __val) __ATTR_CONST__;
extern void *memccpy(void *, const void *, int, size_t);
extern void *memchr(const void *, int, size_t) __ATTR_PURE__;
extern int memcmp(const void *, const void *, size_t) __ATTR_PURE__;
extern void *memcpy(void *, const void *, size_t);
extern void *memmem(const void *, size_t, const void *, size_t) __ATTR_PURE__;
extern void *memmove(void *, const void *, size_t);
extern void *memrchr(const void *, int, size_t) __ATTR_PURE__;
extern void *memset(void *, int, size_t);
extern char *strcat(char *, const char *);
extern char *strchr(const char *, int) __ATTR_PURE__;
extern char *strchrnul(const char *, int) __ATTR_PURE__;
extern int strcmp(const char *, const char *) __ATTR_PURE__;
extern char *strcpy(char *, const char *);
extern int strcasecmp(const char *, const char *) __ATTR_PURE__;
extern char *strcasestr(const char *, const char *) __ATTR_PURE__;
extern size_t strcspn(const char *__s, const char *__reject) __ATTR_PURE__;
extern char *strdup(const char *s1);
extern size_t strlcat(char *, const char *, size_t);
extern size_t strlcpy(char *, const char *, size_t);
extern size_t strlen(const char *) __ATTR_PURE__;
extern char *strlwr(char *);
extern char *strncat(char *, const char *, size_t);
extern int strncmp(const char *, const char *, size_t) __ATTR_PURE__;
extern char *strncpy(char *, const char *, size_t);
extern int strncasecmp(const char *, const char *, size_t) __ATTR_PURE__;
extern size_t strnlen(const char *, size_t) __ATTR_PURE__;
extern char *strpbrk(const char *__s, const char *__accept) __ATTR_PURE__;
extern char *strrchr(const char *, int) __ATTR_PURE__;
extern char *strrev(char *);
extern char *strsep(char **, const char *);
extern size_t strspn(const char *__s, const char *__accept) __ATTR_PURE__;
extern char *strstr(const char *, const char *) __ATTR_PURE__;
extern char *strtok(char *, const char *);
extern char *strtok_r(char *, const char *, char **);
extern char *strupr(char *);

Answer 1

从您发布的链接中我会选择memmem()。

void *memmem(const void *s1, 
             size_t len1, 
             const void *s2, 
             size_t len2);

memmem()函数在长度为s2的内存区域len2中查找长度为s1的子串len1的第一次出现的开始。< / p>

Answer 2

正如迈克尔所说，你应该看看strnstr。

文档中的代码段：

 #include <string.h>

 char *
 strnstr(const char *s1, const char *s2, size_t n);

strnstr（）函数定位字符串s1中第一次出现以null结尾的字符串s2，其中不超过n个字符搜索。

所以看起来你想要的是

char* found = strnstr(output,substring,100);

如果您的C-lib有限，代码非常简单：

char* strnstr(char* s, char* find, size_t slen)
{
    char c, sc;
    size_t len;

    if ((c = *find++) != '\0') {
        len = strlen(find);
        do {
            do {
                if ((sc = *s++) == '\0' || slen-- < 1)
                    return (NULL);
            } while (sc != c);
            if (len > slen)
                return (NULL);
        } while (strncmp(s, find, len) != 0);
        s--;
    }
    return ((char *)s);
}

Answer 3

鉴于你的微控制器lib没有strstr或strnstr ....

char* string_first_of(char* s, char* sub)
{
    int n;
    if(s == NULL) return NULL;
    if(sub == NULL) return s;
    n =  strlen(sub);
    while(*s != 0)
    {
        if(strncmp(s, sub, n) == 0)
        {
            return s;
        }
        s++;
    }
    return NULL;    
}

bool string_contains(char* s, char* sub)
{
    return string_first_of(s, sub) != NULL;
}

检查缓冲区中的子字符串

3 个答案: