给定一个长度未知的字符串，如何使用 cout 输出它，以便整个字符串在控制台上显示为缩进的文本 block ？ (这样即使字符串换行，第二行也会有相同级别的缩进)

例子:

cout << "This is a short string that isn't indented." << endl;
cout << /* Indenting Magic */ << "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..." << endl;

以及所需的输出:

This is a short string that isn't indented.

    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...

编辑:我正在处理的家庭作业已完成。作业与上例中的输出格式无关，因此我可能不应该包含作业标签。这只是我自己的启蒙。

我知道我可以数一数字符串中的字符，看看我何时到达一行的末尾，然后吐出一个换行符并每次输出 -x- 个空格。我很想知道是否有更简单、惯用的 C++ 方法来完成上述任务。

最佳答案

如果您愿意在单词之间舍弃任何多重间距和/或其他空格，这里有一些可行的解决方案。

第一种方法是最直接的，它是将文本读入 istringstream 并从流中提取单词。在打印每个单词之前，检查该单词是否适合当前行，如果不适合则打印一个换行符。此特定实现不会正确处理超过最大行长度的单词，但修改它以拆分长单词并不困难。

#include <iostream>
#include <sstream>
#include <string>

int main() {
    const unsigned max_line_length(40);
    const std::string line_prefix("    ");

    const std::string text(
        "Friends, Romans, countrymen, lend me your ears; I come to bury Caesar,"
        " not to praise him.  The evil that men do lives after them; The good "
        "is oft interred with their bones; So let it be with Caesar.");

    std::istringstream text_iss(text);

    std::string word;
    unsigned characters_written = 0;

    std::cout << line_prefix;
    while (text_iss >> word) {

        if (word.size() + characters_written > max_line_length) {
            std::cout << "\n" << line_prefix;
            characters_written = 0;
        }

        std::cout << word << " ";
        characters_written += word.size() + 1;
    }
    std::cout << std::endl;
}

第二个更“高级”的选项是编写自定义 ostream_iterator，按照您期望的方式格式化行。我将这个 ff_ostream_iterator 命名为“有趣的格式”，但如果您想使用它，您可以将其命名为更合适的名称。此实现确实正确地拆分了长单词。

虽然迭代器的实现有点复杂，但用法非常简单:

int main() {
    const std::string text(
        "Friends, Romans, countrymen, lend me your ears; I come to bury Caesar,"
        " not to praise him.  The evil that men do lives after them; The good "
        "is oft interred with their bones; So let it be with Caesar. ReallyLong"
        "WordThatWontFitOnOneLineBecauseItIsSoFreakinLongSeriouslyHowLongIsThis"
        "Word");

    std::cout << "    ========================================" << std::endl;

    std::copy(text.begin(), text.end(), 
              ff_ostream_iterator(std::cerr, "    ", 40));
}

迭代器的实际实现如下:

#include <cctype>
#include <iostream>
#include <iterator>
#include <memory>
#include <sstream>
#include <string>

class ff_ostream_iterator 
    : public std::iterator<std::output_iterator_tag, char, void, void, void>
{
public:

    ff_ostream_iterator() { }

    ff_ostream_iterator(std::ostream& os,
                        std::string line_prefix, 
                        unsigned max_line_length)
        : os_(&os),
          line_prefix_(line_prefix), 
          max_line_length_(max_line_length),
          current_line_length_(),
          active_instance_(new ff_ostream_iterator*(this))
    { 
        *os_ << line_prefix;
    }

    ~ff_ostream_iterator() {
        if (*active_instance_ == this)
            insert_word();
    }

    ff_ostream_iterator& operator=(char c) {
        *active_instance_ = this;
        if (std::isspace(c)) {
            if (word_buffer_.size() > 0) {
                insert_word();
            }
        }
        else {
            word_buffer_.push_back(c);
        }
        return *this;
    }

    ff_ostream_iterator& operator*()     { return *this; }
    ff_ostream_iterator& operator++()    { return *this; }
    ff_ostream_iterator  operator++(int) { return *this; }


private:

    void insert_word() {
        if (word_buffer_.size() == 0)
            return; 

        if (word_buffer_.size() + current_line_length_ <= max_line_length_) {
            write_word(word_buffer_);
        }
        else { 
            *os_ << '\n' << line_prefix_;

            if (word_buffer_.size() <= max_line_length_) {
                current_line_length_ = 0;
                write_word(word_buffer_);
            }
            else {
                for (unsigned i(0);i<word_buffer_.size();i+=max_line_length_) 
                {
                    current_line_length_ = 0;
                    write_word(word_buffer_.substr(i, max_line_length_));
                    if (current_line_length_ == max_line_length_) {
                        *os_ << '\n' << line_prefix_;
                    }
                }
            }
        }

        word_buffer_ = "";
    }

    void write_word(const std::string& word) {
        *os_ << word;
        current_line_length_ += word.size();
        if (current_line_length_ != max_line_length_) {
            *os_ << ' ';
            ++current_line_length_;
        }
    }

    std::ostream* os_;
    std::string word_buffer_;

    std::string line_prefix_;
    unsigned max_line_length_;
    unsigned current_line_length_;

    std::shared_ptr<ff_ostream_iterator*> active_instance_;
};

[如果您从上面复制并粘贴此代码片段和 main，如果您的编译器支持 C++0x std::shared_ptr，它应该可以编译并运行>;如果您的编译器尚不支持 C++0x，您可以将其替换为 boost::shared_ptr 或 std::tr1::shared_ptr。]

这种方法有点棘手，因为迭代器必须是可复制的，而且我们必须确保任何剩余的缓冲文本只打印一次。我们这样做的依据是，任何时候输出迭代器被写入时，它的任何拷贝都不再可用。

关于c++ - 使用 cout 缩进段落，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/5280858/