如何在文本文件中计算分配运算符？

Question

我的任务是在C ++中创建一个程序，该程序以顺序模式处理文本文件。数据必须一次从文件一行中读取。请勿将文件的全部内容备份到RAM。文本文件包含句法正确的C ++代码，我必须计算其中有多少个分配运算符。

我唯一能想到的是制作一个搜索模式的功能，然后计算出它们出现的次数。我将每个分配操作员插入模式，然后将所有计数总结在一起。但这是不起作用的，因为如果我插入模式“ =”许多操作员，例如“％=”或“+=”，也被计数。甚至诸如“！=”或“ = =”之类的操作员被计数，但它们都被计数不应该是因为它们是比较操作员。

我的代码给出了答案7，但真正的答案应为5。

#include <iostream>
#include <fstream>

using namespace std;

int patternCounting(string pattern, string text){
    int x = pattern.size();
    int y = text.size();
    int rez = 0;

    for(int i=0; i<=y-x; i++){
        int j;
        for(j=0; j<x; j++)
            if(text[i+j] !=pattern[j]) break;

        if(j==x) rez++;
    }
    return rez;
}

int main()
{
    fstream file ("test.txt", ios::in);
    string rinda;
    int skaits=0;
    if(!file){cout<<"Nav faila!"<<endl; return 47;}

    while(file.good()){
        getline(file, rinda);
        skaits+=patternCounting("=",rinda);
        skaits+=patternCounting("+=",rinda);
        skaits+=patternCounting("*=",rinda);
        skaits+=patternCounting("-=",rinda);
        skaits+=patternCounting("/=",rinda);
        skaits+=patternCounting("%=",rinda);
    }

    cout<<skaits<<endl;

    return 0;
}

文本文件的内容：

#include <iostream>

using namespace std;

int main()
{
    int z=3;
    int x=4;

    for(int i=3; i<3; i++){
        int f+=x;
        float g%=3;

    }

}

---

请注意，作为酷刑测试，以下代码在较旧的C ++标准上具有0个作业，而在较新的标准上，由于取消了Trigraphs，因此具有0个作业。

// = Torture test
int a = 0; int b = 1;

int main()
{
    // The next line is part of this comment until C++17 ??/
    a = b;
    struct S
    {
        virtual void foo() = 0;
        void foo(int, int x = 1);
        S& operator=(const S&) = delete;
        int m = '==';
        char c = '=';
    };
    const char* s = [=]{return "=";}();
    sizeof(a = b);
    decltype(a = b) c(a);
}

Answer 1

代码有多个问题。

第一个相当平凡的问题是您对文件读数的处理。诸如之类的循环while（file.good（））…实际上是始终一个错误：您需要测试getline而不是测试返回值呢

std::string line;
while (getline(file, line)) {
    // Process `line` here.
}

接下来，您的patterncounting函数从根本上起作用，因为它不考虑注释和字符串（也没有C ++的其他特点，但这些似乎不符合您的作业范围）。分别计算不同的分配运算符也是没有意义的。

第三个问题是您的测试案例会错过许多边缘案例（并且是无效的C ++）。这是一个更好的测试案例，即（我认为）从您的作业中练习所有有趣的边缘案例：

int main()
{
    int z=3; // 1
    int x=4; // 2

    // comment with = in it
    "string with = in it";
    float f = 3; // 3
    f = f /= 4; // 4, 5

    for (int i=3; i != 3; i++) { // 6
        int f=x += z; // 7, 8
        bool g=3 == 4; // 9
    }
}

我已经注释了每一行，并注明了我们现在应该计算多少事件。

现在我们有了测试用例，我们可以开始实现实际的计数逻辑。请注意，对于可读性，功能名称通常遵循模式“动词主题”。因此，代替staterscounting更好的函数名称将是countpattern。但是我们不会计算任意模式，我们将计算任务。因此，我将使用count Assignments（或者，使用我首选的C ++命名约定：count_assignments）。

现在，此功能需要做什么？

1. 它需要计算任务（包括初始化），duh。
2. 它需要打折=的出现不是分配：
   1. 内部字符串
   2. 内部注释
   3. 内部比较操作员

没有专用的C ++解析器，这是一个相当艰巨的任务！您将需要实现基本的词汇分析仪 ）对于C ++。

首先，您将需要表示我们关心的每种情况：

enum class state {
    start,
    comment,
    string,
    comparison
};

借助此情况，我们可以开始编写count_assignments函数的轮廓：

int count_assignments(std::string const& str) {
    auto count = 0;
    auto state = state::start;
    auto prev_char = '\0';

    for (auto c : str) {
        switch (state) {
            case state::start:
                break;
            case state::comment:
                break;
            case state::string:
                break;
            case state::comparison:
                break;
        }
        prev_char = c;
    }

    // Useful for debugging:
    // std::cerr << count << "\t" << str << "\n";

    return count;
}

您可以看到，我们迭代了在字符串的字符上（for（c：str））。接下来，我们处理当前可能处于的每个状态

。 ，但是/=是我们要计算的分配！）。这有点有些黑客 - 对于真正的Lexer，我会将这些案例分为不同的状态。

对于功能骨架而言，这么多。现在，我们需要实现实际逻辑 - 即，我们需要根据当前（和先前的）字符和当前状态来决定该做什么。

为了让您开始，这是案例状态::开始：

switch (c) {
    case '=':
        ++count;
        state = state::comparison;
        break;
    case '<': case '>': case '!':
        state = state::comparison;
        break;
    case '"' :
        state = state::string;
        break;
    case '/' :
        if (prev_char == '/') {
            state = state::comment;
        }
        break;
}

非常小心：以上将超过比较==，因此我们需要调整计数一旦我们在案例状态::比较中，请看到当前和上一个字符都是=。

我会让您对其余的实施。

请注意，与您的初始尝试不同，此实现不会区分单独的分配运算符（=，+=等），因为没有必要： '所有人都自动计数。

Answer 2

Clang编译器具有倾倒语法树（也称为AST）的功能。如果您具有句法正确的C ++代码（您没有），则可以计算分配运算符的数量，例如使用以下命令行（在Unixoid OS上）：

clang++ -Xclang -ast-dump -c my_cpp_file.cpp | egrep "BinaryOperator.*'='" | wc -l

请注意，这只会匹配真实的评估，而不是复制初始化，也可以使用=字符，但在句法上是不同的（例如，在这种情况下未调用Overloaded =运算符）。

如果要计算复合分配和/或复制初始化，则可以尝试在输出AST中查找相应的行，并将它们添加到egrep搜索模式中。

Answer 3

实际上，您的任务非常困难。

想想例如c ++ 原始字符串文字源线，内部有任意=）。或asm语句做一些添加的语句。...

也要考虑（对于某些声明的int x;）a x ++（哪个对于简单变量，相当于x = x+1;，而语义上是一个分配运算符 - 但不是语法）。

我的建议：选择一个开源C ++编译器。我碰巧知道 gcc 内部。

使用GCC，您可以编写自己的 gcc plugin gimple sistions。

还要想想 quine nore programs 编码 c ++

... 。