使用 std:vector 作为低级缓冲区

这里的用法与直接在 C++ std：vector 中使用 read(( 相同，但需要重新分配。

输入文件的大小未知，因此当文件大小超过缓冲区大小时，缓冲区将通过加倍大小来重新分配。这是我的代码：

#include <vector>
#include <fstream>
#include <iostream>
int main()
{
    const size_t initSize = 1;
    std::vector<char> buf(initSize); // sizes buf to initSize, so &buf[0] below is valid
    std::ifstream ifile("D:\Pictures\input.jpg", std::ios_base::in|std::ios_base::binary);
    if (ifile)
    {
        size_t bufLen = 0;
        for (buf.reserve(1024); !ifile.eof(); buf.reserve(buf.capacity() << 1))
        {
            std::cout << buf.capacity() << std::endl;
            ifile.read(&buf[0] + bufLen, buf.capacity() - bufLen);
            bufLen += ifile.gcount();
        }
        std::ofstream ofile("rebuild.jpg", std::ios_base::out|std::ios_base::binary);
        if (ofile)
        {
            ofile.write(&buf[0], bufLen);
        }
    }
}

程序按预期打印矢量容量，并写入与输入大小相同的输出文件，BUT，在偏移量initSize之前只有与输入相同的字节，之后的所有零...

在read()中使用&buf[bufLen]肯定是一种未定义的行为，但&buf[0] + bufLen得到了正确的写入位置，因为连续分配是有保证的，不是吗？(initSize != 0提供。请注意，std::vector<char> buf(initSize);大小buf到 initSize 。是的，如果initSize == 0，我的环境中会出现一个rumtime致命错误。我错过了什么吗？这也是一个UB吗？标准有没有说明std：：vector的这种用法？

我知道我们可以先计算文件大小并分配完全相同的缓冲区大小，但是在我的项目中，可以预期输入文件几乎总是小于某个SIZE，因此我可以将initSize设置为 SIZE 并期望没有开销(如文件大小计算(，并且仅将重新分配用于"异常处理"。是的，我知道我可以用 resize() 替换reserve()，用 size() 替换capacity()，然后以很少的开销让事情工作(每次调整大小时将缓冲区归零(，但我仍然想摆脱任何多余的操作，只是一种偏执狂......

更新 1：

事实上，我们可以从标准中逻辑地推断出&buf[0] + bufLen得到正确的位置，考虑一下：

std::vector<char> buf(128);
buf.reserve(512);
char* bufPtr0 = &buf[0], *bufPtrOutofRange = &buf[0] + 200;
buf.resize(256); std::cout << "standard guarantees no reallocation" << std::endl;
char* bufPtr1 = &buf[0], *bufInRange = &buf[200]; 
if (bufPtr0 == bufPtr1)
    std::cout << "so bufPtr0 == bufPtr1" << std::endl;
std::cout << "and 200 < buf.size(), standard guarantees bufInRange == bufPtr1 + 200" << std::endl;
if (bufInRange == bufPtrOutofRange)
    std::cout << "finally we have: bufInRange == bufPtrOutofRange" << std::endl;

输出：

standard guarantees no reallocation
so bufPtr0 == bufPtr1
and 200 < buf.size(), standard guarantees bufInRange == bufPtr1 + 200
finally we have: bufInRange == bufPtrOutofRange

在这里，每buf.size() <= i < buf.capacity()都可以替换 200，并且类似的扣除额成立。

更新 2：

是的，我确实错过了一些东西...但问题不在于连续性(见更新1(，甚至不在于写入内存失败(见我的回答(。今天我有一些时间来研究这个问题，程序得到了正确的地址，将正确的数据写入保留内存，但在下一个reserve()中，buf被重新分配，只有范围内的元素[0, buf.size())复制到新内存。所以这就是整个谜语的答案...

最后说明：如果在缓冲区填充了一些数据后不需要重新分配，您绝对可以使用reserve()/capatity()而不是resize()/size()，但如果需要，请使用后者。此外，在此处提供的所有实现(VC++、g++、ICC(下，该示例按预期工作：

const size_t initSize = 1;
std::vector<char> buf(initSize);
buf.reserve(1024*100); // assume the reserved space is enough for file reading
std::ifstream ifile("D:\Pictures\input.jpg", std::ios_base::in|std::ios_base::binary);
if (ifile)
{
    ifile.read(&buf[0], buf.capacity());  // ok. the whole file is read into buf
    std::ofstream ofile("rebuld.jpg", std::ios_base::out|std::ios_base::binary);
    if (ofile)
    {
        ofile.write(&buf[0], ifile.gcount()); // rebuld.jpg just identical to input.jpg
    }
}
buf.reserve(1024*200); // horror! probably always lose all data in buf after offset initSize

这是另一个例子，引用自'TC++PL， 4e' pp 1041，注意函数中的第一行使用reserve()而不是resize()：

void fill(istream& in, string& s, int max)
// use s as target for low-level input (simplified)
{
    s.reserve(max); // make sure there is enough allocated space
    in.read(&s[0],max);
    const int n = in.gcount(); // number of characters read
    s.resize(n);
    s.shrink_to_fit();  // discard excess capacity
}

更新3(8年后(：这些年发生了很多事情，我近6年没有用C++作为我的工作语言，现在我是一名博士生！此外，尽管许多人认为有UB，但他们给出的原因却大不相同(有些已经被证明不是UB(，这表明这是一个复杂的案例。因此，在投票和写答案之前，强烈建议阅读并参与评论。

另一件事是，通过博士培训，我现在可以相对轻松地进入C++标准，这在几年前我不敢。我相信我在自己的答案中表明，基于标准，上述两个代码块应该可以工作。(string示例需要 C++11。由于我的回答仍然有争议(但我相信不是伪造的(，我不接受它，而是对批评性评论和其他答案持开放态度。