158 用 Read4 读取 N 个字符 II

题目描述：
给你一个文件，并且该文件只能通过给定的 read4 方法来读取，请实现一个方法使其能够读取 n 个字符。注意：你的 read 方法可能会被调用多次。
read4 的定义：

read4 API 从文件中读取 4 个连续的字符，然后将这些字符写入缓冲区数组 buf4 。

返回值是读取的实际字符数。

请注意，read4() 有其自己的文件指针，类似于 C 中的 FILE * fp 。

参数类型: char[] buf4
返回类型: int

注意: buf4[] 是目标缓存区不是源缓存区，read4 的返回结果将会复制到 buf4[] 当中。
下列是一些使用 read4 的例子：

File file(“abcde”); // 文件名为 “abcde”， 初始文件指针 (fp) 指向 ‘a’
char[] buf4 = new char[4]; // 创建一个缓存区使其能容纳足够的字符
read4(buf4); // read4 返回 4。现在 buf4 = “abcd”，fp 指向 ‘e’
read4(buf4); // read4 返回 1。现在 buf4 = “e”，fp 指向文件末尾
read4(buf4); // read4 返回 0。现在 buf4 = “”，fp 指向文件末尾
read 方法：

通过使用 read4 方法，实现 read 方法。该方法可以从文件中读取 n 个字符并将其存储到缓存数组 buf 中。您 不能 直接操作文件。

返回值为实际读取的字符。

read 的定义：

参数: char[] buf, int n
返回值: int

注意: buf[] 是目标缓存区不是源缓存区，你需要将结果写入 buf[] 中。

示例 1：
File file(“abc”);
Solution sol;
// 假定 buf 已经被分配了内存，并且有足够的空间来存储文件中的所有字符。
sol.read(buf, 1); // 当调用了您的 read 方法后，buf 需要包含 “a”。 一共读取 1 个字符，因此返回 1。
sol.read(buf, 2); // 现在 buf 需要包含 “bc”。一共读取 2 个字符，因此返回 2。
sol.read(buf, 1); // 由于已经到达了文件末尾，没有更多的字符可以读取，因此返回 0。

示例 2：
File file(“abc”);
Solution sol;
sol.read(buf, 4); // 当调用了您的 read 方法后，buf 需要包含 “abc”。 一共只能读取 3 个字符，因此返回 3。
sol.read(buf, 1); // 由于已经到达了文件末尾，没有更多的字符可以读取，因此返回 0。

提示：
你 不能 直接操作该文件，文件只能通过 read4 获取而 不能 通过 read。
read 函数可以被调用 多次。
请记得 重置 在 Solution 中声明的类变量（静态变量），因为类变量会 在多个测试用例中保持不变，影响判题准确。请 查阅 这里。
你可以假定目标缓存数组 buf 保证有足够的空间存下 n 个字符。
保证在一个给定测试用例中，read 函数使用的是同一个 buf。方法

方法1：
主要思路：
（1）使用一个缓存存储每次从read4中读取的字符，并使用一个变量统计每次实际读取出来的字符；
（2）每次使用read读取字符时，需要先判断之前缓存中存储的字符的影响，是否缓存中的字符就已经够返回了，若不能，先把缓存中的字符存储到输出数组中，再接着使用read4去读取更多的字符；
（3）知道读到满足要求数量的字符，或者把文件中的字符全部读取完了；

/**
 * The read4 API is defined in the parent class Reader4.
 *     int read4(char *buf4);
 */

class Solution {
public:
    /**
     * @param buf Destination buffer
     * @param n   Number of characters to read
     * @return    The number of actual characters read
     */
     int count;
     char* tmp_buf;
    Solution(){
        count=0;//统计当前缓存中有效字符的数量
        tmp_buf=new char[4];//缓存每次从read4中读取的字符
    }
    int read(char *buf, int n) {
        int pos=0;//将字符存储到buf的索引
        if(n<=count){//若缓存中的字符数量够输出使用，则直接将缓存中的字符输出
            while(pos<n){//将缓存中的字符存储到输出数组中
                buf[pos]=tmp_buf[pos];
                ++pos;
            }
            //将没有输出完的字符移到缓存的前面
            int i=0;
            while(pos<count){
                tmp_buf[i]=tmp_buf[pos];
                ++i;
                ++pos;
            }
            count=i;//更新有效字符的个数
            return pos-count;//返回实际输出的字符的个数
        }
		//若现在缓存中的字符不够输出的数量，则先将缓存中的字符输出
        while(pos<count){
            buf[pos]=tmp_buf[pos];
            ++pos;
        }
        n-=count;//更新还需要输出的字符的数量
        count=0;//此时缓存中的有效字符的个数为0
        //知道满足所有的输出字符的数量
        while(n){
            count=read4(tmp_buf);//将文件中的字符读入到换出中，并返回了实际读入的字符的数量
            //若实际读入的数量为0，说明此时文件中的字符已经全部读出了，直接跳出循环
            if(count==0){
                break;
            }
            //若需要的字符的数量大于缓存中的字符的数量
            if(n>=count){
            	//将缓存中的全部字符存储到输出数组中
                for(int i=0;i<count;++i){
                    buf[pos]=tmp_buf[i];
                    ++pos;
                }
                //更新还需要的字符的数量
                n-=count;
                count=0;//缓存中实际的有效字符数量归零
            }
            else{
            	//将有效的全部的缓存中的字符全部存储到输出数组中
                int i=0;
                while(i<n){
                    buf[pos]=tmp_buf[i];
                    ++i;
                    ++pos;
                }
                i=0;//更新缓存中有效的字符的位置
                while(n<count){
                    tmp_buf[i]=tmp_buf[n];
                    ++i;
                    ++n;
                }
                count=i;//更新有效字符的数量
                n=0;//还需要的字符的数量为 0，便于跳出循环
            }
        }
        return pos;//返回实际读入到输出数组中的字符的数量
    }
};