C++ 可以将std:：对的std:：vector转换为字节数组吗？

我想知道是否有可能将成对向量转换成字节数组

下面是创建成对向量的一个小示例：

int main(int argc, char *argv[])
{
    PBYTE FileData, FileData2, FileData3;
    DWORD FileSize, FileSize2, FileSize3;

    /* Here I read 3 files + their sizes and fill the above variables. */

    //Here I create the vector of std::pairs.
    std::vector<std::pair<PBYTE, DWORD>> DataVector
    {
        { FileData, FileSize }, //Pair contains always file data + file size.
        { FileData2, FileSize2 },
        { FileData3, FileSize3 }
    };

    std::cin.ignore(2);
    return 0;
}

intmain（intargc，char*argv[]）
{
PBYTE FileData、FileData2、FileData3；
DWORD FileSize、FileSize2、FileSize3；
/*在这里，我阅读了3个文件及其大小，并填写了上述变量*/
//这里我创建std:：pairs的向量。
向量数据向量
{
{FileData，FileSize}，//对始终包含文件数据+文件大小。
{FileData2，FileSize2}，
{FileData3，FileSize3}
};
标准：cin忽略（2）；
返回0；
}

是否可以将此向量转换为字节数组（用于压缩和写入磁盘等）

以下是我尝试过的，但我甚至都没有得到正确的尺寸：

PVOID DataVectorArr = NULL;

DWORD DataVectorArrSize = DataVector.size() * sizeof DataVector[0];

if ((DataVectorArr = malloc(DataVectorArrSize)) != NULL)
{
    memcpy(DataVectorArr, &DataVector[0], DataVectorArrSize);
}

std::cout << DataVectorArrSize;

//... Here I tried to write the DataVectorArr to disk, which obviously fails because the size isn't correct. I am not also sure if the DataVectorArr contains the DataVector now.

if (DataVectorArr != NULL) delete DataVectorArr;

PVOID datavectorr=NULL；
DWORD DataVectorArrSize=DataVector.size（）*sizeof DataVector[0]；
如果（（DataVectorArr=malloc（DataVectorArrSize））！=NULL）
{
memcpy（datavectorr和DataVector[0]，datavectorrsize）；
}
std：：cout摆脱malloc

std::vector<BYTE> bytes;
for (auto const& x : DataVector)
    bytes.insert(bytes.end(), x.first, x.first+x.second);

// bytes now contains all images buttressed end-to-end.
std::cout << bytes.size() << '\n';

但如果您只想将这些文件连续转储到磁盘，那么为什么不简单地：

std::ofstream outp("outfile.bin", std::ios::out|std::ios::binary);
for (auto const& x : DataVector)
    outp.write(static_cast<const char*>(x.first), x.second);
outp.close();

std:：of流输出（“outfile.bin”，std:：ios:：out | std:：ios:：binary）；
用于（自动常量&x:DataVector）
输出写入（静态转换（x.first），x.second）；
outp.close（）；

完全跳过中间人

老实说，除非有很好的理由这样做，否则您的DataVector很可能首先作为一个
std:：vector
更好


更新

如果需要恢复，您不能像上面那样做。缺少的最小工件是数据本身的描述。在这种情况下，描述是每对线束段的实际长度。为此，长度必须与数据一起存储。这样做是微不足道的，除非您还需要它可移植到平台独立性

如果最后一句话让你提高了眉毛，考虑一下做一些简单的问题：

std::ofstream outp("outfile.bin", std::ios::out|std::ios::binary);
for (auto const& x : DataVector)
{
    uint64_t len = static_cast<uint64_t>(x.first);
    outp.write(reinterpret_cast<const char *>(&len), sizeof(len));
    outp.write(static_cast<const char*>(x.first), x.second);
}
outp.close();

std:：of流输出（“outfile.bin”，std:：ios:：out | std:：ios:：binary）；
用于（自动常量&x:DataVector）
{
uint64透镜=静态铸造（x第一）；
输出写入（重新解释强制转换（&len），大小（len））；
输出写入（静态转换（x.first），x.second）；
}
outp.close（）；

现在，您可以通过执行以下操作来读取每个文件：


读取
uint64\u t
以获取要跟随的数据的字节长度
读取该长度的数据

但这有其固有的问题。它根本不便于携带。读者平台的endian表示最好与作者平台的endian表示相匹配，否则这是完全失败的。为了适应这一限制，必须以独立于平台的方式编写长度前导，这是冗长乏味的，也是序列化库及其协议首先存在的根本原因

如果到目前为止你还没有猜到你在做什么以及你是如何做的，你可能想再读一遍。
摆脱
malloc
，并利用RAII实现这一点：

std::vector<BYTE> bytes;
for (auto const& x : DataVector)
    bytes.insert(bytes.end(), x.first, x.first+x.second);

// bytes now contains all images buttressed end-to-end.
std::cout << bytes.size() << '\n';

但如果您只想将这些文件连续转储到磁盘，那么为什么不简单地：

std::ofstream outp("outfile.bin", std::ios::out|std::ios::binary);
for (auto const& x : DataVector)
    outp.write(static_cast<const char*>(x.first), x.second);
outp.close();

std:：of流输出（“outfile.bin”，std:：ios:：out | std:：ios:：binary）；
用于（自动常量&x:DataVector）
输出写入（静态转换（x.first），x.second）；
outp.close（）；

完全跳过中间人

老实说，除非有很好的理由这样做，否则您的DataVector很可能首先作为一个
std:：vector
更好


更新

如果需要恢复，您不能像上面那样做。缺少的最小工件是数据本身的描述。在这种情况下，描述是每对线束段的实际长度。为此，长度必须与数据一起存储。这样做是微不足道的，除非您还需要它可移植到平台独立性

如果最后一句话让你提高了眉毛，考虑一下做一些简单的问题：

std::ofstream outp("outfile.bin", std::ios::out|std::ios::binary);
for (auto const& x : DataVector)
{
    uint64_t len = static_cast<uint64_t>(x.first);
    outp.write(reinterpret_cast<const char *>(&len), sizeof(len));
    outp.write(static_cast<const char*>(x.first), x.second);
}
outp.close();

std:：of流输出（“outfile.bin”，std:：ios:：out | std:：ios:：binary）；
用于（自动常量&x:DataVector）
{
uint64透镜=静态铸造（x第一）；
输出写入（重新解释强制转换（&len），大小（len））；
输出写入（静态转换（x.first），x.second）；
}
outp.close（）；

现在，您可以通过执行以下操作来读取每个文件：


读取
uint64\u t
以获取要跟随的数据的字节长度
读取该长度的数据

但这有其固有的问题。它根本不便于携带。读者平台的endian表示最好与作者平台的endian表示相匹配，否则这是完全失败的。为了适应这一限制，必须以独立于平台的方式编写长度前导，这是冗长乏味的，也是序列化库及其协议首先存在的根本原因

如果到目前为止你还没有猜到你在做什么以及你是如何做的，你可能想再读一遍。
摆脱
malloc
，并利用RAII实现这一点：

std::vector<BYTE> bytes;
for (auto const& x : DataVector)
    bytes.insert(bytes.end(), x.first, x.first+x.second);

// bytes now contains all images buttressed end-to-end.
std::cout << bytes.size() << '\n';

但如果您只想将这些文件连续转储到磁盘，那么为什么不简单地：

std::ofstream outp("outfile.bin", std::ios::out|std::ios::binary);
for (auto const& x : DataVector)
    outp.write(static_cast<const char*>(x.first), x.second);
outp.close();

std:：of流输出（“outfile.bin”，std:：ios:：out | std:：ios:：binary）；
用于（自动常量&x:DataVector）
输出写入（静态转换（x.first），x.second）；
outp.close（）；

完全跳过中间人

老实说，除非有很好的理由这样做，否则您的DataVector很可能首先作为一个
std:：vector
更好


更新

如果需要恢复，您不能像上面那样做。缺少的最小工件是数据本身的描述。在里面