Question

如果发生特定事件，我的C程序需要跳过其余的代码。我已经使用了继续，但有一些问题。我不确定问题是由于只有不同的东西，但这是逻辑上的错误。

我正在向BoyerMoore_positive(ch[i], strlen(ch[i]) );函数发送信息以验证它是否存在于特定的单词列表中。如果存在则增加计数值。

对于skp = BoyerMoore_skip(ch[i], strlen(ch[i]) );如果此函数中存在单词，那么我想跳过其余代码并继续下一个单词。所以我增加了i。

它会检查“他就是你”，这个清单。但是当这个列表中存在单词并且在执行该函数中的操作后返回时，它不会继续下一个单词，尽管我已经递增i。它会在BoyerMoore_skip(ch[i], strlen(ch[i]) );中循环一段时间，然后在不处理下一个单词的情况下停止。

我知道这是我的计划中非常具体的问题，但任何有用的帮助都非常值得注意。我可能会犯一些愚蠢的错误。

代码：

while ((NULL != word) && (50 > i)) 
{
    ch[i] = strdup(word);
    //printf("%s n", ch[i]);

    skp = BoyerMoore_skip(ch[i], strlen(ch[i]) );
    //  printf("skip is %s \n",skp);
    if(skp != NULL)
    {
        i++;
        printf("in\n");
        continue;
    }
    // I tried with keeping  i++ and continue in seperate if(skp != NULL) but same result.
    printf("\n hi2 \n");
    str = BoyerMoore_positive(ch[i], strlen(ch[i]) );
    str2= BoyerMoore_negative(ch[i], strlen(ch[i]) );
    printf("Str is %s \n",str2);
    if (str == NULL)
        t++;
    else {
        printf("%s \n", ch[i]);
        // puts("true");
        pcount += 1;
        printf("Positive count is: %d \n",pcount);
    }

    if(str2== NULL)
        q++;
    else {
        printf("%s \n", ch[i]);
        //  puts("true");
        ncount += 1;
        printf("Nagative count is: %d \n",ncount);
    }

    i++;
    word = strtok(NULL, " ");
    if(str==NULL && str==NULL and skp !=NULL)
    {
        pcount=0;
        ncount=0;
    }
}

Answer 1

要测试您的论文，请删除continue语句，并添加} else {分支以及结束括号。

如果您的代码有效，那么您就知道继续正在跳过某些必需的逻辑。您可以将缺少的逻辑复制回if的true部分并恢复continue语句。

Answer 2

一旦您选择跳过，您的word 永远不会更改。你到达continue;然后回到循环的顶部，复制相同的单词并最终遇到相同的逻辑。

实际将word提升到下一个标记（strtok()逻辑）的代码位于循环的底部;远离continue的地方，让你回到顶端。我认为您需要在{/ 1}} 之前复制该逻辑您已决定需要跳过并前进到下一个令牌。

事实上，正如我现在所看到的那样，也没有理由把它放在那里。 continue;仅用于填充word一个副本，并且永远不会在其他任何地方使用（我可以看到，无论如何），所以你可以理论上在制作你的欺骗之后立即推进它，从而拥有在你的循环中只有一个代码片段。

Answer 3

实际上不是答案，而是重新设计：

#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;
}

C程序中的分支问题

3 个答案: