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

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

ru en cn

5411880

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

Морозов Игнат Владимирович

Время

27.09.2021 19:50 (12 д. 10:23) 19:52>>

Обработка

19:50 ... 19:50 (3,23 сек.)

Файл

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

Турнир

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

Задача

F: BufferedReader

Набор тестов

Ограничения

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

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

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

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

buffered_reader.h:3:  private: should be indented +1 space inside class BufferedReader  [whitespace/indent] [3]
buffered_reader.h:8:  public: should be indented +1 space inside class BufferedReader  [whitespace/indent] [3]
buffered_reader.h:8:  "public:" should be preceded by a blank line  [whitespace/blank_line] [3]
buffered_reader.h:22:  An else should appear on the same line as the preceding }  [whitespace/newline] [4]
buffered_reader.h:22:  If an else has a brace on one side, it should have it on both  [readability/braces] [5]
buffered_reader.h:40:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
buffered_reader.h:40:  Missing space after ,  [whitespace/comma] [3]
buffered_reader.h:44:  Missing space after ,  [whitespace/comma] [3]
buffered_reader.h:49:  Lines should be <= 80 characters long  [whitespace/line_length] [2]
buffered_reader.h:51:  At least two spaces is best between code and comments  [whitespace/comments] [2]
buffered_reader.h:44:  Add #include <algorithm> for min  [build/include_what_you_use] [4]
buffered_reader.h:65:  Add #include <string> for string  [build/include_what_you_use] [4]
Done processing buffered_reader.h
Total errors found: 12

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

≡

#include <math.h>
class BufferedReader {
private:
    PackageStream* stream;
    char* buffer_chars;
    std::string buffer_str;
    int cur_pos = 0;
public:
    explicit BufferedReader(PackageStream* stream) :stream(stream) {}
    int32_t Read(char* output_buffer, int32_t buffer_len) {
        int32_t totalwasread = 0;
        cur_pos = 0;
        if (buffer_str.length() != 0) {
            if (buffer_len > buffer_str.length()) {
                char* tmp = new char[buffer_str.length()];
                memcpy(tmp, buffer_str.c_str(), buffer_str.length());
                memcpy(output_buffer, tmp, buffer_str.length());
                buffer_len -= buffer_str.length();
                cur_pos += buffer_str.length();
                totalwasread += buffer_str.length();
            }
            else if (buffer_len < buffer_str.length()) {
                char* tmp = new char[buffer_len];
                memcpy(tmp, buffer_str.c_str(), buffer_len);
                memcpy(output_buffer + 0, tmp, buffer_len);
                cur_pos += buffer_len;
                buffer_str = buffer_str.substr(buffer_len);
                return buffer_len;
            }
        }
        if (buffer_len > stream->PackageLen()) {
            buffer_chars = new char[stream->PackageLen()];
            int32_t diff = buffer_len;
            int32_t last_diff;
            while (diff > 0) {
                int32_t was_readed = stream->ReadPackage(buffer_chars);
                if (was_readed == 0) {
                    break;
                }
                memcpy(output_buffer + cur_pos, buffer_chars, min(was_readed,diff));
                totalwasread += was_readed;
                last_diff = diff;
                cur_pos += min(diff, was_readed);
                diff -= min(diff,was_readed);
                if (diff == 0) {
                    char* new_buffer_char = new char[was_readed - last_diff];
                    totalwasread -= was_readed-last_diff;
                    new_buffer_char[was_readed - last_diff] = '\0';
                    memcpy(new_buffer_char, buffer_chars + diff, was_readed-last_diff);
                    buffer_str = std::string(new_buffer_char);
                    break;// ?
                }
            }
            return totalwasread;
        }
        if (buffer_len < stream->PackageLen()) {
            buffer_chars = new char[stream->PackageLen()];
            int32_t was_readed = stream->ReadPackage(buffer_chars);
            if (was_readed != 0) {
                int diff = stream->PackageLen() - buffer_len;
                memcpy(output_buffer, buffer_chars, buffer_len);
                char* new_buffer_char = new char[diff];
                new_buffer_char[diff] = '\0';
                memcpy(new_buffer_char, buffer_chars + buffer_len, diff);
                buffer_str = std::string(new_buffer_char);
                totalwasread += buffer_len;
            }
            return totalwasread;
        }
        if (buffer_len == stream->PackageLen()) {
            buffer_chars = new char[stream->PackageLen()];
            stream->ReadPackage(buffer_chars);
            memcpy(output_buffer + cur_pos, buffer_chars, buffer_len);
            return buffer_len + totalwasread;
        }
    }
};

(3 342 b)

0.042s 0.010s 10