Отступ абзаца с cout

Для этого все еще может потребоваться немного работы (например, indent действительно должен быть реализован как манипулятор, но манипуляторы с аргументами трудно написать переносимо-стандарт на самом деле не поддерживает/определяет их). я считаю, что ему также нужно немного поработать над тем, как он обрабатывает новые строки, и[Edit:я думаю, что исправил проблемы, которые я там увидел.] Вероятно, есть, по крайней мере, пара угловых случаев, которые не идеальны [Edit: например, прямо сейчас он рассматривает заднее пространство, как если бы это был нормальный персонаж].

#include <iostream>
#include <streambuf>
#include <iomanip>

class widthbuf: public std::streambuf {
public:
    widthbuf(int w, std::streambuf* s): indent_width(0), def_width(w), width(w), sbuf(s), count(0) {}
    ~widthbuf() { overflow('\n'); }
    void set_indent(int w) { 
        if (w == 0) {
            prefix.clear();
            indent_width = 0;
            width = def_width;
        }
        else {
            indent_width += w; 
            prefix = std::string(indent_width, ' ');
            width -= w; 
        }
    }
private:
    typedef std::basic_string<char_type> string;

    // This is basically a line-buffering stream buffer.
    // The algorithm is: 
    // - Explicit end of line ("\r" or "\n"): we flush our buffer 
    //   to the underlying stream's buffer, and set our record of
    //   the line length to 0.
    // - An "alert" character: sent to the underlying stream
    //   without recording its length, since it doesn't normally
    //   affect the a appearance of the output.
    // - tab: treated as moving to the next tab stop, which is
    //   assumed as happening every tab_width characters. 
    // - Everything else: really basic buffering with word wrapping. 
    //   We try to add the character to the buffer, and if it exceeds
    //   our line width, we search for the last space/tab in the 
    //   buffer and break the line there. If there is no space/tab, 
    //   we break the line at the limit.
    int_type overflow(int_type c) {
        if (traits_type::eq_int_type(traits_type::eof(), c))
            return traits_type::not_eof(c);
        switch (c) {
        case '\n':
        case '\r': {
                        buffer += c;
                        count = 0;
                        sbuf->sputn(prefix.c_str(), indent_width);
                        int_type rc = sbuf->sputn(buffer.c_str(), buffer.size());
                        buffer.clear();
                        return rc;
                   }
        case '\a':
            return sbuf->sputc(c);
        case '\t':
            buffer += c;
            count += tab_width - count % tab_width;
            return c;
        default:
            if (count >= width) {
                size_t wpos = buffer.find_last_of(" \t");
                if (wpos != string::npos) {
                    sbuf->sputn(prefix.c_str(), indent_width);
                    sbuf->sputn(buffer.c_str(), wpos);
                    count = buffer.size()-wpos-1;
                    buffer = string(buffer, wpos+1);
                }
                else {
                    sbuf->sputn(prefix.c_str(), indent_width);
                    sbuf->sputn(buffer.c_str(), buffer.size());
                    buffer.clear();
                    count = 0;
                }
                sbuf->sputc('\n');
            }
            buffer += c;
            ++count;
            return c;
        }
    }

    size_t indent_width;
    size_t width, def_width;
    size_t count;
    size_t tab_count;
    static const int tab_width = 8;
    std::string prefix;

    std::streambuf* sbuf;

    string buffer;
};

class widthstream : public std::ostream {
    widthbuf buf;
public:
    widthstream(size_t width, std::ostream &os) : buf(width, os.rdbuf()), std::ostream(&buf) {}
    widthstream &indent(int w) { buf.set_indent(w); return *this; }
};

int main() {
    widthstream out(30, std::cout);
    out.indent(10) << "This is a very long string that will wrap to the next line because it is a very long string that will wrap to the next line.\n";
    out.indent(0) << "This is\tsome\tmore text that should not be indented but should still be word wrapped to 30 columns.";
}

Обратите внимание, что indent(0) является частным случаем. Обычно отступ начинается с 0. вызов yourstream.indent(number), где number является положительным или отрицательным, регулирует отступ относительно предыдущего значения. yourstream.indent(0) я бы ничего не сделал, но я специально сделал это, чтобы сбросить отступ до 0 (как абсолют). Если это будет серьезно использовано, я не уверен, что это сработает наилучшим образом в долгосрочной перспективе, но, по крайней мере, для демо-версии это выглядит довольно удобный.

Я не уверен, что это способ сделать это, но если вы знаете или можете предположить ширину экрана, моя первая мысль-удалить первые символы screenWidth - indent из строки и распечатать их с предыдущими пробелами, и продолжать делать это, пока вы не сделаете всю строку.

Вы всегда можете использовать '\t' для отступа строки вместо заданного числа символов, но я не знаю более простого способа реализации логики без введения внешних библиотек.

Эту задачу можно свести к задаче минимизации количества потраченного впустую пространства на каждой строке. Предположим, что у нас есть слова следующей длины

{ 6,7,6,8,10,3,4,10 }

Если мы вычислим количество пространства, которое будет потрачено впустую, когда мы расположим последние n слов, не разбивая их, и поместим его в таблицу, то мы сможем найти оптимальное количество слов для печати на текущей строке вперед.

Вот пример для 20-символьного широкого экрана. В этой таблице первый столбец-это количество последних слов, второй столбец-это длина n-го слова от конца и третьего-это минимальное потраченное пространство:

8 6 1
7 7 7
6 5 14
5 8 2
4 10 11
3 3 1 
2 4 5
1 10 10

Например, когда у нас есть только одно последнее слово из 10 букв 10 букв пропадают впустую, если у нас есть 2 слова со вторым от конца 4 символов длиной мы будем иметь 5 букв впустую (один пробел между словами) дополнительные 3 буквы слово оставит только один пробел впустую. Добавление еще 10 букв слова оставляет нас с 11 буквами впустую всего на 2 строчки и так далее.

Пример

6, 7, 5 (0)
8, 10 (1)
3, 4, 10 (1) 

Если мы решим напечатать 2 слова на первой строке пустого места действительно 14. Числа в () показывают потерянное пространство.

6, 7 (6)
5, 8 (6)
10, 3, 4 (2)
4, 10 (6)

Я думаю, что это хорошо известная проблема, и алгоритм, который я описал, является примером динамического программирования.