C程序中的分支问题

如果发生特定事件，我的C程序需要跳过代码的其余部分。我使用了continue，但是有一些问题。我不确定这个问题是否仅仅是因为这个原因，或者是其他原因，但这是一个逻辑错误

我正在给博伊尔穆尔阳性（ch[I]，斯特伦（ch[I]）发短信用于验证它是否存在于特定单词列表中的函数。如果存在，则增加计数值

对于

skp=BoyerMoore_skip（ch[i]，strlen（ch[i]）如果此函数中存在word，则我希望跳过其余代码并继续使用下一个word。所以我增加了
I

它检查“他就是你她是”这个列表。但是，当word出现在该列表中并在函数中执行操作后返回时，它不会继续下一个word，尽管我已递增了
I
。它在
BoyerMoore_skip（ch[i]，strlen（ch[i]）中不断循环一段时间，然后停止而不处理下一个单词

我知道这对我的项目来说是一个非常具体的问题，但是任何帮助都是非常值得的。我可能会犯一些愚蠢的错误

代码：

一旦你选择跳过，你的
单词就不会改变。你到达
继续
并返回循环的顶部，复制相同的单词，最终遇到相同的逻辑

实际上将
word
前进到下一个令牌（strtok（）
逻辑）的代码位于循环的底部；离将您送回顶部的
continue
不远。我认为在
继续之前，您需要复制该逻辑确定需要跳过并前进到下一个令牌后

事实上，在我现在看来，也没有理由把它放在那里
word
仅用于使用副本填充
c[i]
，并且从未在其他任何地方使用过（无论如何，我可以看到），因此理论上，您可以在制作副本后立即将其推进，因此，循环中只有一段代码。
要测试论文，请删除
continue
语句，并添加
}else{
分支和结束括号

如果代码正常工作，则您知道continue跳过了某些必需的逻辑。您可以将缺少的逻辑复制回If的
true
部分，并恢复
continue
语句。
实际上不是答案，而是重新设计：

#include <cstring>
#include <array>
#include <iostream>

class BoyerMooreSearch
{
    public:
    typedef std::size_t size_type;

    private:
    static const size_type SkipTableSize = (std::size_t((unsigned char)(-1))) + 1;
    static const size_type Threshold = 5;
    typedef std::array<std::size_t, SkipTableSize> SkipTable;

    public:
    BoyerMooreSearch(const char* substr, size_type substrlen)
    :   m_substr(substr), m_substrlen(substrlen)
    {
        m_skip.fill(m_substrlen);
        size_type n = m_substrlen - 1;
        const char* s = m_substr + 1;
        while(n) m_skip[*s++] = n--;
    }

    BoyerMooreSearch(const char* substr)
    :   BoyerMooreSearch(substr, std::strlen(substr))
    {}

    BoyerMooreSearch(const std::string& substr)
    :   BoyerMooreSearch(substr.c_str(), substr.size())
    {}

    // No copy
    BoyerMooreSearch(const BoyerMooreSearch&) = delete;
    BoyerMooreSearch& operator = (const BoyerMooreSearch&) = delete;

    private:
    inline bool test_size(size_type strlen) const {
        return (m_substrlen && m_substrlen < strlen);
    }

    inline bool brute(size_type strlen) const {
        return m_substrlen < Threshold || strlen - m_substrlen <= m_substrlen;
    }

    public:
    const char* find(const char* str, const size_type strlen) const
    {
        if( ! test_size(strlen)) return 0;
        else {
            const char* end = str + strlen - m_substrlen;

            if( ! brute(strlen)) {

                // Boyer-Moore
                // ===========

                while(str <= end) {
                    if(std::strncmp(str, m_substr, m_substrlen) == 0) return str;
                    str += m_skip[*(str + m_substrlen)];
                }
            }
            else {

                // Brute search
                // ============

                while(str <= end) {
                    if(std::strcmp(str, m_substr) == 0) return str;
                    ++str;
                }
            }
            return 0;
        }
    }

    const char* find(const char* str) const {
        return find(str, std::strlen(str));
    }

    const char* find(const std::string str) const {
        return find(str.c_str(), str.size());
    }

    size_type count(const char* str, const size_type strlen) const
    {
        size_type result = 0;
        if(test_size(strlen))  {
            const char* end = str + strlen - m_substrlen;
            if( ! brute(strlen)) {

                // Boyer-Moore
                // ===========

                while(str <= end) {
                    if(std::strncmp(str, m_substr, m_substrlen) == 0) {
                        ++result;
                        str += m_substrlen;
                    }
                    else str += m_skip[*(str + m_substrlen)];
                }
            }
            else {

                // Brute search
                // ============

                while(str <= end) {
                if(std::strncmp(str, m_substr, m_substrlen) == 0) {
                    ++result;
                    str += m_substrlen;
                }
                else ++str;

                }
            }
        }
        return result;
    }

    size_type count(const char* str) const  {
        return count(str, std::strlen(str));
    }

    size_type count(const std::string str) const {
        return count(str.c_str(), str.size());
    }

    private:
    const char* m_substr;
    const size_type m_substrlen;;
    SkipTable m_skip;
};

int main()
{
    BoyerMooreSearch bms("Hello");
    const char* str = "Hello World and Hello People";
    std::cout << "Count: " << bms.count(str) << std::endl;
    return 0;
}

#包括
#包括
#包括
班级研究
{
公众：
typedef std:：size\u t size\u type；
私人：
静态常量size_type SkipTableSize=（std:：size_t（（无符号字符）（-1））+1；
静态常量大小\u类型阈值=5；
typedef std:：数组可跳过；
公众：
BoyerMooreSearch（常量字符*子字符串，大小\类型子字符串）
：m_substr（substr），m_substrlen（substrlen）
{
m_跳过填充（m_substrlen）；
尺寸类型n=m\u substrlen-1；
常量char*s=m_substr+1；
而（n）m_skip[*s++]=n--；
}
BoyerMooreSearch（常量字符*子字符）
：BoyerMooreSearch（substr，std:：strlen（substr））
{}
BoyerMooreSearch（常量标准：：字符串和子字符串）
：BoyerMooreSearch（substr.c_str（），substr.size（））
{}
//没有副本
BoyerMooreSearch（const BoyerMooreSearch&）=删除；
BoyerMooreSearch&运算符=（const BoyerMooreSearch&）=删除；
私人：
内联布尔测试尺寸（尺寸类型strlen）常数{
返回（m_substrlen和&m_substrlen返回m|substrlenword=strtok（NULL，””；
@Karimkhan紧跟在
ch[I]=strdup（word）之后放在哪里
。别忘了移除底部的那一个。谢谢，我花了将近一天的时间！我会检查这个，但Craig有指针更正错误的想法！这是个好主意，Jack。我经常在调试OPC时使用它，使用看似奇怪的
continue
语句。
#include <cstring>
#include <array>
#include <iostream>

class BoyerMooreSearch
{
    public:
    typedef std::size_t size_type;

    private:
    static const size_type SkipTableSize = (std::size_t((unsigned char)(-1))) + 1;
    static const size_type Threshold = 5;
    typedef std::array<std::size_t, SkipTableSize> SkipTable;

    public:
    BoyerMooreSearch(const char* substr, size_type substrlen)
    :   m_substr(substr), m_substrlen(substrlen)
    {
        m_skip.fill(m_substrlen);
        size_type n = m_substrlen - 1;
        const char* s = m_substr + 1;
        while(n) m_skip[*s++] = n--;
    }

    BoyerMooreSearch(const char* substr)
    :   BoyerMooreSearch(substr, std::strlen(substr))
    {}

    BoyerMooreSearch(const std::string& substr)
    :   BoyerMooreSearch(substr.c_str(), substr.size())
    {}

    // No copy
    BoyerMooreSearch(const BoyerMooreSearch&) = delete;
    BoyerMooreSearch& operator = (const BoyerMooreSearch&) = delete;

    private:
    inline bool test_size(size_type strlen) const {
        return (m_substrlen && m_substrlen < strlen);
    }

    inline bool brute(size_type strlen) const {
        return m_substrlen < Threshold || strlen - m_substrlen <= m_substrlen;
    }

    public:
    const char* find(const char* str, const size_type strlen) const
    {
        if( ! test_size(strlen)) return 0;
        else {
            const char* end = str + strlen - m_substrlen;

            if( ! brute(strlen)) {

                // Boyer-Moore
                // ===========

                while(str <= end) {
                    if(std::strncmp(str, m_substr, m_substrlen) == 0) return str;
                    str += m_skip[*(str + m_substrlen)];
                }
            }
            else {

                // Brute search
                // ============

                while(str <= end) {
                    if(std::strcmp(str, m_substr) == 0) return str;
                    ++str;
                }
            }
            return 0;
        }
    }

    const char* find(const char* str) const {
        return find(str, std::strlen(str));
    }

    const char* find(const std::string str) const {
        return find(str.c_str(), str.size());
    }

    size_type count(const char* str, const size_type strlen) const
    {
        size_type result = 0;
        if(test_size(strlen))  {
            const char* end = str + strlen - m_substrlen;
            if( ! brute(strlen)) {

                // Boyer-Moore
                // ===========

                while(str <= end) {
                    if(std::strncmp(str, m_substr, m_substrlen) == 0) {
                        ++result;
                        str += m_substrlen;
                    }
                    else str += m_skip[*(str + m_substrlen)];
                }
            }
            else {

                // Brute search
                // ============

                while(str <= end) {
                if(std::strncmp(str, m_substr, m_substrlen) == 0) {
                    ++result;
                    str += m_substrlen;
                }
                else ++str;

                }
            }
        }
        return result;
    }

    size_type count(const char* str) const  {
        return count(str, std::strlen(str));
    }

    size_type count(const std::string str) const {
        return count(str.c_str(), str.size());
    }

    private:
    const char* m_substr;
    const size_type m_substrlen;;
    SkipTable m_skip;
};

int main()
{
    BoyerMooreSearch bms("Hello");
    const char* str = "Hello World and Hello People";
    std::cout << "Count: " << bms.count(str) << std::endl;
    return 0;
}