2 курс. Программирование на C++. Турнир 2, осень 2021

вход курсы / турниры задачи участники консоль модули компиляторы ключевые слова результаты

ru en cn

5787939

Пользователь

Акуленко Валерий Васильевич

Время

23:01<< 16.11.2021 23:03 (27 д. 21:04) 23:05>>

Обработка

23:03 ... 23:03 (2,94 сек.)

Файл

5787939.cpp (CLang++ 5.0.0 + Address Sanitizer)

Турнир

2 курс. Программирование на C++. Турнир 2, осень 2021

Задача

F: Code format visitor

Набор тестов

Ограничения

Время: 1с Память: 4000Мб

Состояние [?]

LI	Ошибка проверки исходного кода

код | результаты

format_visitor.h:9:  public: should be indented +1 space inside class VarDeclarationNode  [whitespace/indent] [3]
format_visitor.h:20:  public: should be indented +1 space inside class MethodDeclarationNode  [whitespace/indent] [3]
format_visitor.h:47:  Is this a non-const reference? If so, make const or use a pointer: uint32_t& param2  [runtime/references] [2]
format_visitor.h:60:  Should have a space between // and comment  [whitespace/comments] [4]
format_visitor.h:83:  Should have a space between // and comment  [whitespace/comments] [4]
format_visitor.h:98:  Should have a space between // and comment  [whitespace/comments] [4]
format_visitor.h:105:  Should have a space between // and comment  [whitespace/comments] [4]
format_visitor.h:110:  Redundant blank line at the end of a code block should be deleted.  [whitespace/blank_line] [3]
format_visitor.h:106:  Add #include <utility> for move  [build/include_what_you_use] [4]
Done processing format_visitor.h
Total errors found: 9

[печатать | | ]

≡

#include <vector>
#include <string>

class VarDeclarationNode
:
public BaseNode{
    public:
    const std::string& VarName() const;
    const std::string& TypeName() const;
    void Visit(BaseVisitor* visitor) const override {
      visitor->Visit(this);
    }
};

class MethodDeclarationNode
:
public BaseNode{
    public:
    const std::string& MethodName() const;
    const std::string& ReturnTypeName() const;
    const std::vector<BaseNode*>& Arguments() const;
    void Visit(BaseVisitor* visitor) const override {
      visitor->Visit(this);
    }
};

using std::vector;
using std::string;

class FormatVisitor
:
public BaseVisitor{
 private:
    vector < string > code_{};
    uint32_t padding_{};
    uint32_t workingStr_{};
    int const classSpace = 1;
    int const classPadding = 4;
    string startDeclaration(const string& type, const string& name) {
      string
      str(type + " " + name);
      return str;
    }
    string stringWithPadd(const string& sourceStr, uint32_t param1,
    uint32_t& param2, char param3) {
      string str = sourceStr;
      int const start = 0;
      str.insert(param1, param2, param3);
      return str;
    }
 public:
    void Visit(const BaseNode* node) override {
      node->Visit(this);
    }
    void Visit(const ClassDeclarationNode* node) override {
      auto tmp = startDeclaration("class", node->ClassName()) + " {";
      code_[workingStr_] += tmp;
      //tmp = std::string(" public:").insert(0, cur_pad, ' ');  // ?
      tmp = stringWithPadd(string(" public:"), 0, padding_, ' ');
      code_.push_back(std::move(tmp));

workingStr_ += classSpace;
      padding_ += classPadding;

for (auto field : node->PublicFields()) {
        workingStr_++;
        auto ss = stringWithPadd(string(""), 0, padding_, ' ');
        code_.push_back(std::move(ss));
        Visit(field);
        code_[workingStr_].push_back(';');
      }

if (!node->ProtectedFields().empty()) {
        code_.push_back("");
        code_.push_back(" protected:");
        workingStr_ += 2;

for (auto field : node->ProtectedFields()) {
          workingStr_++;
          auto ss = stringWithPadd(string(""), 0, padding_, ' ');
          //code_.push_back(std::string("").insert(0, cur_pad, ' '));
          code_.push_back(std::move(ss));
          Visit(field);
          code_[workingStr_].push_back(';');
        }
      }
      if (node->PrivateFields().size() != 0) {
        code_.push_back("");
        code_.push_back(" private:");
        workingStr_++;
        workingStr_++;
        for (auto field : node->PrivateFields()) {
          workingStr_++;
          auto ss = stringWithPadd(string(""), 0, padding_, ' ');
          code_.push_back(std::move(ss));
          //code_.push_back(std::string("").insert(0, cur_pad, ' '));
          Visit(field);
          code_[workingStr_].push_back(';');
        }
      }
      padding_ -= classPadding;
      auto ss = stringWithPadd(string("}"), 0, padding_, ' ');
      //code_.push_back(std::string("}").insert(0, cur_pad, ' '));
      code_.push_back(std::move(ss))
      cur_str++;
      if (0 == padding_)
        code_[workingStr_].push_back(';');

};
    void Visit(const VarDeclarationNode* node) override {
      code_[workingStr_] += startDeclaration(node->TypeName(), node->VarName());
    };
    void Visit(const MethodDeclarationNode* node) override {
      string tmp = startDeclaration(node->ReturnTypeName(), node->MethodName());
      tmp += "(";
      code_[workingStr_] += tmp;
      for (auto*args : node->Arguments()) {
        Visit(args);
        code_[workingStr_] += ", ";
      }

if (!node->Arguments().empty()) {
        code_[workingStr_].pop_back();
        code_[workingStr_].pop_back();
      }
      code_[workingStr_].push_back(')');
    };
    const std::vector<std::string>& GetFormattedCode() const {
      return code_;
    }
};

(4 031 b)

0.152s 0.073s 10