字符串分割

描述
•连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。

输入描述：
连续输入字符串(输入多次,每个字符串长度小于100)

输出描述：
输出到长度为8的新字符串数组

看到这道题，首先想到的解法肯定是通过双重循环，一重循环解决输入的问题，一重循环解决分割字符串的问题。为什么呢？

1. 题目表述连续输入字符串，也就是说，我们并不知道应该输入多少，那就只能用循环来表示，愿意输入多少就输入多少吧。
2. 以8为长度，分割字符串，因为我们不知道前面输入的字符串的长度，所以，只能以循环的方式进行字符串的截取。
3. 因为是不同的字符串，所以，两个字符串的输入之间肯定是有回车键进行分割的，也就是说，我们并不关心怎么输入。
4. 字符串的长度是有限制的，每个字符串的最大长度为100，也就是说，我们上面的第二重循环在每个字符串最多能循环12次。

按照上面的思路，我们就有了下面的写法：

#include <iostream>
#include <string>

int main(int argc, char* argv[])
{
    std::string str;
    
    while(std::cin >> str)
    {
        while(str.size() > 8)
        {
           std::cout << str.substr(0, 8) << std::endl;
            str = str.substr(8);
        }
        str.resize(8, '0');
        std::cout << str << std::endl;
    }
    
    return 0;
}

上面的代码运行成果如下：

上面的代码虽然运行正确并且很简洁，但如果我们对上面的代码进行分析，就会发现，第二重循环中，多次调用了std::string的赋值运算符：

basic_string& operator=(const basic_string& __s) {
	if (&__s != this) 
	  assign(__s.begin(), __s.end());
	return *this;
}

下面是在赋值运算符调用前面的截取字符串的原型：

basic_string substr(size_type __pos = 0, size_type __n = npos) const {
	if (__pos > size())
	  _M_throw_out_of_range();
	return basic_string(_M_start + __pos, 
	                    _M_start + __pos + min(__n, size() - __pos));
}

所以在这个过程中，函数多次调用了string的构造函数以及赋值运算。

我们换一种思路，看能不能节省以下时间和空间。

1. 对每次输入的字符串先进行长度的判断，如果不能被8整除，则在末尾补0；补够能被整除为止；
2. 输出，遍历输出，每输出8个字符的时候输出结尾符 endl

则有了下面的代码：

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string str;
    while (cin >> str)
    {
        int len = str.length();
        if (len % 8 != 0)
        {
            str.append((8 - len % 8), '0');
        }
        len = str.length();
        for (int i = 0; i < len; ++i)
        {
            if(i % 8 == 0 && i != 0)
            {
                cout << endl;
            }
            cout << str[i];
        }
        cout << endl;
    }
    return 0;
}

运行结果如下：