Indentifiant paragraphe avec cout

Ce problème peut être réduit à une tâche de minimiser la quantité d'espace gaspillé sur chaque ligne. Supposons que nous ayons des mots de longueurs suivants xxx pré>

si nous calculons la quantité d'espace qui sera gaspillée lorsque nous organiserons les nords derniers sans les casser et la mettre dans une table, nous pouvons trouver un nombre optimal de mots à imprimer sur la ligne actuelle à l'avenir. p>

Voici un exemple de 20 caractères de caractères. Dans ce tableau, la première colonne est le nombre de derniers mots, la deuxième colonne est la longueur du mot N'th de l'extrémité et de la troisième est l'espace minimum gaspillé: p> xxx pré>

par exemple lorsque nous Avoir un dernier mot de 10 lettres 10 lettres 10 lettres sont gaspillés, si nous avons 2 mots avec deuxièmes de la fin de la fin de 4 caractères, nous aurons 5 lettres gaspillées (un espace entre les mots), un mot supplémentaire de 3 lettres ne laissera que des espaces gaspillés. Ajout d'un autre mot de 10 lettres nous laisse avec 11 lettres gaspillées sur 2 lignes et ainsi de suite. P>

exemple p> xxx pré>

Si nous choisissons d'imprimer 2 mots sur La première ligne gaspille de l'espace est en effet 14. Nombres dans () Afficher l'espace gaspillé. P>

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

Ceci pourrait toujours utiliser un peu de travail (par exemple, le indent code> devrait probablement être implémenté comme manipulateur, mais les manipulateurs avec des arguments sont durs em> pour écrire de manière portante - La norme ne supporte pas vraiment / les définir). Il y a probablement au moins deux cas de coin qui ne sont pas parfaits (par exemple, il traite le dos comme s'il s'agissait d'un caractère normal).

#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.";
}