#include <iostream>
#include <vector>

class Writer {
public:
    virtual void Write(const char *data, size_t len) {
        std::cout << "(flush) ";
        for (size_t i = 0; i < len; ++i)
            std::cout << data[i];
        std::cout << std::endl;
    }
};

class BufferedWriter : public Writer {
public:
    explicit BufferedWriter(size_t size) : bufsize_(size) {
        buffer_.resize(bufsize_);
    }

    void Write(const char *data, size_t len) override {
        if (!bufsize_) {
            printer_.Write(data, len);
            return;
        }

        for (int i = 0; i < len; ++i) {
            flush();
            buffer_[cursize_++] = data[i];
        }
    }

    ~BufferedWriter() {
        if (cursize_) {
            char *last_data = new char[cursize_];
            for (size_t i = 0; i < cursize_; ++i)
                last_data[i] = buffer_[i];
            printer_.Write(last_data, cursize_);
            delete[] last_data;
        }
    }

private:
    void flush() {
        if (cursize_ < bufsize_)
            return;
        char *data = new char[bufsize_];

        for (size_t i = 0; i < bufsize_; ++i)
            data[i] = buffer_[i];

        printer_.Write(data, bufsize_);
        cursize_ = 0;
        delete[] data;
    }

    size_t bufsize_;
    std::vector<char> buffer_;
    size_t cursize_ = 0;
    Writer printer_;
};

int main() {
    char data[100] = "a";
    char data1[14] = "helloworl";
    BufferedWriter wrt(2);
    wrt.Write(data, 1);
    wrt.Write(data1, 9);
    wrt.Write("fuck", 4);
}