1

如果发生特定事件，我的 C 程序需要跳过其余代码。我已经使用 continue 了，但是有一些问题。我不确定问题是由于那个原因还是其他原因，但这是逻辑错误。

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

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

它检查“他是你她是”这个列表。但是，当 word 出现在此列表中并在函数中执行操作后返回时，尽管我已递增，但它不会继续执行下一个 word 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;
    }
}
4

3 回答 3

2

要测试您的论文，请删除该continue语句并添加} else {带有右括号的分支。

如果您的代码有效，那么您就知道 continue 跳过了一些必需的逻辑。您可以将缺少的逻辑复制回trueif 的部分并恢复该continue语句。

于 2013-08-18T05:22:09.423 回答
1

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

实际上进入word下一个标记（strtok()逻辑）的代码位于循环的底部；远不及continue将您送回顶部的地方。我认为您需要continue; 在您决定需要跳过并前进到下一个令牌之前复制该逻辑。

事实上，当我现在看到它时，也没有理由把它放在那里。word仅用于填充c[i]重复项，并且从未在其他任何地方使用（无论如何我都可以看到），因此理论上您可以在进行欺骗后立即推进它，从而在您的循环中只有一个代码片段。

于 2013-08-18T05:01:46.163 回答
0

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

#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;
}
于 2013-08-18T09:00:24.830 回答