我正在编写一段代码，旨在对CLSID结构进行一些数据压缩。我将它们存储为128位整数的压缩流。但是，有问题的代码必须能够将无效的CLSID放入流中。为了做到这一点，我把它们留作一个大字符串。在磁盘上，它看起来像这样：
+--------------------------+-----------------+------------------------+
| | | |
| Length of Invalid String | Invalid String | Compressed Data Stream |
| | | |
+--------------------------+-----------------+------------------------+
要对字符串的长度进行编码，我需要输出32位整数，该整数是一次一个字节的字符串长度。这是我目前的代码：
std::vector<BYTE> compressedBytes;
DWORD invalidLength = (DWORD) invalidClsids.length();
compressedBytes.push_back((BYTE) invalidLength & 0x000000FF);
compressedBytes.push_back((BYTE) (invalidLength >>= 8) & 0x000000FF));
compressedBytes.push_back((BYTE) (invalidLength >>= 8) & 0x000000FF));
compressedBytes.push_back((BYTE) (invalidLength >>= 8));
此代码不会经常调用，但在解码阶段需要有类似的结构，称为数千次。我很好奇这是否是最有效的方法，或者有人能想出更好的方法吗？
全部谢谢！
Billy3
编辑： 在查看了一些答案之后，我创建了这个迷你测试程序，看看哪个是最快的：
// temp.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <windows.h>
#include <ctime>
#include <iostream>
#include <vector>
void testAssignedShifts();
void testRawShifts();
void testUnion();
int _tmain(int argc, _TCHAR* argv[])
{
std::clock_t startTime = std::clock();
for (register unsigned __int32 forLoopTest = 0; forLoopTest < 0x008FFFFF; forLoopTest++)
{
testAssignedShifts();
}
std::clock_t assignedShiftsFinishedTime = std::clock();
for (register unsigned __int32 forLoopTest = 0; forLoopTest < 0x008FFFFF; forLoopTest++)
{
testRawShifts();
}
std::clock_t rawShiftsFinishedTime = std::clock();
for (register unsigned __int32 forLoopTest = 0; forLoopTest < 0x008FFFFF; forLoopTest++)
{
testUnion();
}
std::clock_t unionFinishedTime = std::clock();
std::printf(
"Execution time for assigned shifts: %08u clocks\n"
"Execution time for raw shifts: %08u clocks\n"
"Execution time for union: %08u clocks\n\n",
assignedShiftsFinishedTime - startTime,
rawShiftsFinishedTime - assignedShiftsFinishedTime,
unionFinishedTime - rawShiftsFinishedTime);
startTime = std::clock();
for (register unsigned __int32 forLoopTest = 0; forLoopTest < 0x008FFFFF; forLoopTest++)
{
testAssignedShifts();
}
assignedShiftsFinishedTime = std::clock();
for (register unsigned __int32 forLoopTest = 0; forLoopTest < 0x008FFFFF; forLoopTest++)
{
testRawShifts();
}
rawShiftsFinishedTime = std::clock();
for (register unsigned __int32 forLoopTest = 0; forLoopTest < 0x008FFFFF; forLoopTest++)
{
testUnion();
}
unionFinishedTime = std::clock();
std::printf(
"Execution time for assigned shifts: %08u clocks\n"
"Execution time for raw shifts: %08u clocks\n"
"Execution time for union: %08u clocks\n\n"
"Finished. Terminate!\n\n",
assignedShiftsFinishedTime - startTime,
rawShiftsFinishedTime - assignedShiftsFinishedTime,
unionFinishedTime - rawShiftsFinishedTime);
system("pause");
return 0;
}
void testAssignedShifts()
{
std::string invalidClsids("This is a test string");
std::vector<BYTE> compressedBytes;
DWORD invalidLength = (DWORD) invalidClsids.length();
compressedBytes.push_back((BYTE) invalidLength);
compressedBytes.push_back((BYTE) (invalidLength >>= 8));
compressedBytes.push_back((BYTE) (invalidLength >>= 8));
compressedBytes.push_back((BYTE) (invalidLength >>= 8));
}
void testRawShifts()
{
std::string invalidClsids("This is a test string");
std::vector<BYTE> compressedBytes;
DWORD invalidLength = (DWORD) invalidClsids.length();
compressedBytes.push_back((BYTE) invalidLength);
compressedBytes.push_back((BYTE) (invalidLength >> 8));
compressedBytes.push_back((BYTE) (invalidLength >> 16));
compressedBytes.push_back((BYTE) (invalidLength >> 24));
}
typedef union _choice
{
DWORD dwordVal;
BYTE bytes[4];
} choice;
void testUnion()
{
std::string invalidClsids("This is a test string");
std::vector<BYTE> compressedBytes;
choice invalidLength;
invalidLength.dwordVal = (DWORD) invalidClsids.length();
compressedBytes.push_back(invalidLength.bytes[0]);
compressedBytes.push_back(invalidLength.bytes[1]);
compressedBytes.push_back(invalidLength.bytes[2]);
compressedBytes.push_back(invalidLength.bytes[3]);
}
运行几次会导致：
Execution time for assigned shifts: 00012484 clocks
Execution time for raw shifts: 00012578 clocks
Execution time for union: 00013172 clocks
Execution time for assigned shifts: 00012594 clocks
Execution time for raw shifts: 00013140 clocks
Execution time for union: 00012782 clocks
Execution time for assigned shifts: 00012500 clocks
Execution time for raw shifts: 00012515 clocks
Execution time for union: 00012531 clocks
Execution time for assigned shifts: 00012391 clocks
Execution time for raw shifts: 00012469 clocks
Execution time for union: 00012500 clocks
Execution time for assigned shifts: 00012500 clocks
Execution time for raw shifts: 00012562 clocks
Execution time for union: 00012422 clocks
Execution time for assigned shifts: 00012484 clocks
Execution time for raw shifts: 00012407 clocks
Execution time for union: 00012468 clocks
看起来是指定班次和工会之间的关系。因为我以后需要这个值，所以联合它！谢谢！
Billy3
答案 0 :(得分：8)
这可能会像您一样优化。 Bit-twiddling操作是处理器上最快的一些操作。
＆gt;＆gt;可能会更快16，＆gt;＆gt; 24而不是＆gt;＆gt; = 8＆gt;＆gt; = 8 - 你减少了一项任务。
此外，我认为你不需要＆amp; - 因为你要转换为BYTE（ 应该是一个8位字符），所以无论如何它都会被适当地截断。 （如果我错的话，是吗？纠正我）
总而言之，这些都是微不足道的变化。对其进行剖析以确定它是否确实有所不同：P
答案 1 :(得分：6)
只需使用联盟：
assert(sizeof (DWORD) == sizeof (BYTE[4])); // Sanity check
union either {
DWORD dw;
struct {
BYTE b[4];
} bytes;
};
either invalidLength;
invalidLength.dw = (DWORD) invalidClsids.length();
compressedBytes.push_back(either.bytes.b[0]);
compressedBytes.push_back(either.bytes.b[1]);
compressedBytes.push_back(either.bytes.b[2]);
compressedBytes.push_back(either.bytes.b[3]);
注意：与原始问题中的位移方法不同，此代码生成依赖于字节序的输出。仅当在一台计算机上运行的程序的输出将在具有计算机的计算机上读取时，这才重要。不同的字节顺序 - 但由于使用这种方法似乎没有可测量的速度增加，你可以使用更便携的位移方法，以防万一。
答案 2 :(得分：2)
你应该测量而不是猜测任何潜在的改进，但我首先想到的是可能更快地进行联合，如下所示：
typedef union {
DWORD d;
struct {
BYTE b0;
BYTE b1;
BYTE b2;
BYTE b3;
} b;
} DWB;
std::vector<BYTE> compBytes;
DWB invLen;
invLen.d = (DWORD) invalidClsids.length();
compBytes.push_back(invalidLength.b.b3);
compBytes.push_back(invalidLength.b.b2);
compBytes.push_back(invalidLength.b.b1);
compBytes.push_back(invalidLength.b.b0);
可能是回退的正确顺序，但检查以防万一 - 它取决于CPU的字节顺序。
答案 3 :(得分：1)
一种快速的方法是将DWORD *（单个元素数组）视为BYTE *（4个元素数组）。代码也更具可读性。
警告：我还没有编译这个
警告：这使您的代码依赖于字节排序
std::vector<BYTE> compressedBytes;
DWORD invalidLength = (DWORD) invalidClsids.length();
BYTE* lengthParts = &invalidLength;
static const int kLenghtPartsLength = sizeof(DWORD) / sizeof(BYTE);
for(int i = 0; i < kLenghtPartsLength; ++i)
compressedBytes.push_back(lengthParts[i]);
答案 4 :(得分：1)
compressedBytes.push_back(either.bytes.b[0]);
compressedBytes.push_back(either.bytes.b[1]);
compressedBytes.push_back(either.bytes.b[2]);
compressedBytes.push_back(either.bytes.b[3]);
有一种更聪明，更快的方式！让我们看看这段代码在做什么，以及我们如何改进它。
此代码序列化整数，一次一个字节。对于每个字节，它调用push_back，它正在检查内部向量缓冲区中的可用空间。如果我们没有其他字节的空间，将发生内存重新分配（提示，慢！）。当然，重新分配不会经常发生（通常通过将现有缓冲区加倍来重新分配）。然后，复制新字节并将内部大小增加一。
矢量＆lt;＆GT;标准要求规定内部缓冲区是连续的。矢量＆lt;＆GT;也碰巧有一个运算符＆amp; （）和 operator []（）。
所以，这是您可以提出的最佳代码：
std::string invalidClsids("This is a test string");
std::vector<BYTE> compressedBytes;
DWORD invalidLength = (DWORD) invalidClsids.length();
compressedBytes.resize(sizeof(DWORD)); // You probably want to make this much larger, to avoid resizing later.
// compressedBytes is as large as the length we want to serialize.
BYTE* p = &compressedBytes[0]; // This is valid code and designed by the standard for such cases. p points to a buffer that is at least as large as a DWORD.
*((DWORD*)p) = invalidLength; // Copy all bytes in one go!
上述演员表可以使用＆amp; compressedBytes [0] 语句一次完成，但速度不会更快。这更具可读性。
请注意！以这种方式序列化（甚至使用UNION方法）依赖于字节序。也就是说，在Intel / AMD处理器上，最不重要的字节将首先出现，而一个大端机器（PowerPC，Motorola ......）将是最重要的字节。如果你想保持中立，你必须使用数学方法（轮班）。
答案 5 :(得分：0)
你有一次一个字节吗？有没有办法你可以一次memcpy（）整个32位进入流？如果你有要写入流的缓冲区的地址，你可以复制到那个吗？
答案 6 :(得分：0)
也许有可能获得32位变量指针，将其转换为char指针并读取char，然后将+1添加到指针并读取下一个char ..只是理论:)我不知道它是否正常工作