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

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

ru en cn

5787891

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

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

Время

22:56<< 16.11.2021 22:56 (27 д. 20:57) 22:58>>

Обработка

22:56 ... 22:56 (2,23 сек.)

Файл

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

Турнир

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

Задача

F: Code format visitor

Набор тестов

Ограничения

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

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

CE	Ошибка компиляции

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

In file included from main.cpp:121:0:
format_visitor.h: In member function 'std::__cxx11::string FormatVisitor::stringWithPadd(const string&, uint32_t, const string&, char)':
format_visitor.h:28:17: error: unused variable 'start' [-Werror=unused-variable]
       int const start = 0;
                 ^~~~~
format_visitor.h: In member function 'virtual void FormatVisitor::Visit(const ClassDeclarationNode*)':
format_visitor.h:40:55: error: no matching function for call to 'FormatVisitor::stringWithPadd(const char [9], int, uint32_t&, char)'
       tmp = stringWithPadd(" public:", 0, cur_pad, ' ');
                                                       ^
format_visitor.h:25:12: note: candidate: std::__cxx11::string FormatVisitor::stringWithPadd(const string&, uint32_t, const string&, char)
     string stringWithPadd(const string& sourceStr, uint32_t param1,
            ^~~~~~~~~~~~~~
format_visitor.h:25:12: note:   no known conversion for argument 3 from 'uint32_t {aka unsigned int}' to 'const string& {aka const std::__cxx11::basic_string<char>&}'
format_visitor.h:48:61: error: no matching function for call to 'FormatVisitor::stringWithPadd(std::__cxx11::string, int, uint32_t&, char)'
         auto ss = stringWithPadd(string(""), 0, cur_pad, ' ');
                                                             ^
format_visitor.h:25:12: note: candidate: std::__cxx11::string FormatVisitor::stringWithPadd(const string&, uint32_t, const string&, char)
     string stringWithPadd(const string& sourceStr, uint32_t param1,
            ^~~~~~~~~~~~~~
format_visitor.h:25:12: note:   no known conversion for argument 3 from 'uint32_t {aka unsigned int}' to 'const string& {aka const std::__cxx11::basic_string<char>&}'
format_visitor.h:61:63: error: no matching function for call to 'FormatVisitor::stringWithPadd(std::__cxx11::string, int, uint32_t&, char)'
           auto ss = stringWithPadd(string(""), 0, cur_pad, ' ');
                                                               ^
format_visitor.h:25:12: note: candidate: std::__cxx11::string FormatVisitor::stringWithPadd(const string&, uint32_t, const string&, char)
     string stringWithPadd(const string& sourceStr, uint32_t param1,
            ^~~~~~~~~~~~~~
format_visitor.h:25:12: note:   no known conversion for argument 3 from 'uint32_t {aka unsigned int}' to 'const string& {aka const std::__cxx11::basic_string<char>&}'
format_visitor.h:75:63: error: no matching function for call to 'FormatVisitor::stringWithPadd(std::__cxx11::string, int, uint32_t&, char)'
           auto ss = stringWithPadd(string(""), 0, cur_pad, ' ');
                                                               ^
format_visitor.h:25:12: note: candidate: std::__cxx11::string FormatVisitor::stringWithPadd(const string&, uint32_t, const string&, char)
     string stringWithPadd(const string& sourceStr, uint32_t param1,
            ^~~~~~~~~~~~~~
format_visitor.h:25:12: note:   no known conversion for argument 3 from 'uint32_t {aka unsigned int}' to 'const string& {aka const std::__cxx11::basic_string<char>&}'
format_visitor.h:82:60: error: no matching function for call to 'FormatVisitor::stringWithPadd(std::__cxx11::string, int, uint32_t&, char)'
       auto ss = stringWithPadd(string("}"), 0, cur_pad, ' ');
                                                            ^
format_visitor.h:25:12: note: candidate: std::__cxx11::string FormatVisitor::stringWithPadd(const string&, uint32_t, const string&, char)
     string stringWithPadd(const string& sourceStr, uint32_t param1,
            ^~~~~~~~~~~~~~
format_visitor.h:25:12: note:   no known conversion for argument 3 from 'uint32_t {aka unsigned int}' to 'const string& {aka const std::__cxx11::basic_string<char>&}'
cc1plus: all warnings being treated as errors

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

≡

#include <vector>
#include <string>
#include <utility>

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

class FormatVisitor
:
public BaseVisitor{
 private:
    vector < string > code_{};
    uint32_t cur_pad{};
    uint32_t cur_str{};
    int const classSpace = 0;
    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,
    const string& 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_[cur_str] += tmp;

tmp = stringWithPadd(" public:", 0, cur_pad, ' ');
      code_.push_back(std::move(tmp));

cur_str += classSpace;
      cur_pad += classPadding;

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

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

for (auto field : node->ProtectedFields()) {
          cur_str++;
          auto ss = stringWithPadd(string(""), 0, cur_pad, ' ');

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

code_.push_back(std::move(ss))
      cur_str++;
      if (0 == cur_pad)
        code_[cur_str].push_back(';');
    };
    void Visit(const VarDeclarationNode* node) override {
      code_[cur_str] += startDeclaration(node->TypeName(), node->VarName());
    };
    void Visit(const MethodDeclarationNode* node) override {
      string tmp = startDeclaration(node->ReturnTypeName(), node->MethodName());
      tmp += "(";
      code_[cur_str] += tmp;
      for (auto*args : node->Arguments()) {
        Visit(args);
        code_[cur_str] += ", ";
      }

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

(3 142 b)

0.051s 0.009s 10