在书里游戏编码完成，第三版， https://rads.stackoverflow.com/amzn/click/com/1584506806作者提到了一种减少数据结构大小的技术and提高访问性能。本质上，它依赖于当成员变量内存对齐时获得性能的事实。这是编译器可以利用的明显的潜在优化，但通过确保每个变量对齐，最终会导致数据结构的大小膨胀。

或者至少这是他的说法。

他表示，真正的性能提升是通过使用你的大脑并确保你的结构经过正确设计，以利用速度的提高，同时防止编译器膨胀。他提供了以下代码片段：

#pragma pack( push, 1 )

struct SlowStruct
{
    char c;
    __int64 a;
    int b;
    char d;
};

struct FastStruct
{
    __int64 a;
    int b;
    char c;
    char d;  
    char unused[ 2 ]; // fill to 8-byte boundary for array use
};

#pragma pack( pop )

使用上面的struct在一项未指定的测试中，他报告的对象性能提高了15.6% (222ms相比192ms）和较小的尺寸FastStruct。这对我来说在纸面上是有意义的，但在我的测试中却站不住脚：

同一时间结果and尺寸（计算char unused[ 2 ])!

现在如果#pragma pack( push, 1 )仅孤立于FastStruct（或完全删除）我们确实看到了差异：

所以，最后，这里存在一个问题：现代编译器（特别是 VS2010）是否已经针对位对齐进行了优化，因此缺乏性能提升（但增加了结构大小作为副作用，如 Mike Mcshaffry 所说）？或者我的测试不够密集/不确定，无法返回任何显着的结果？

对于测试，我在未对齐的矩阵上执行了各种任务，包括数学运算、列主多维数组遍历/检查、矩阵运算等__int64成员。对于这两种结构，它们都没有产生不同的结果。

最后，即使性能没有提高，这仍然是一个需要记住的有用的技巧，可以将内存使用量保持在最低限度。但如果有我没有看到的性能提升（无论多么微小），我会很高兴。

它高度依赖于硬件。

让我演示一下：

#pragma pack( push, 1 )

struct SlowStruct
{
    char c;
    __int64 a;
    int b;
    char d;
};

struct FastStruct
{
    __int64 a;
    int b;
    char c;
    char d;  
    char unused[ 2 ]; // fill to 8-byte boundary for array use
};

#pragma pack( pop )

int main (void){

    int x = 1000;
    int iterations = 10000000;

    SlowStruct *slow = new SlowStruct[x];
    FastStruct *fast = new FastStruct[x];



    //  Warm the cache.
    memset(slow,0,x * sizeof(SlowStruct));
    clock_t time0 = clock();
    for (int c = 0; c < iterations; c++){
        for (int i = 0; i < x; i++){
            slow[i].a += c;
        }
    }
    clock_t time1 = clock();
    cout << "slow = " << (double)(time1 - time0) / CLOCKS_PER_SEC << endl;
    
    //  Warm the cache.
    memset(fast,0,x * sizeof(FastStruct));
    time1 = clock();
    for (int c = 0; c < iterations; c++){
        for (int i = 0; i < x; i++){
            fast[i].a += c;
        }
    }
    clock_t time2 = clock();
    cout << "fast = " << (double)(time2 - time1) / CLOCKS_PER_SEC << endl;



    //  Print to avoid Dead Code Elimination
    __int64 sum = 0;
    for (int c = 0; c < x; c++){
        sum += slow[c].a;
        sum += fast[c].a;
    }
    cout << "sum = " << sum << endl;


    return 0;
}

酷睿 i7 920 @ 3.5 GHz

slow = 4.578
fast = 4.434
sum = 99999990000000000

好吧，差别不大。但在多次运行中它仍然保持一致。
因此，对齐方式在 Nehalem Core i7 上产生了微小的差异。

英特尔至强 X5482 Harpertown @ 3.2 GHz（Core 2 - 代 Xeon）

slow = 22.803
fast = 3.669
sum = 99999990000000000

现在看一下...

6.2 倍快！！！

结论：

您会看到结果。您可以决定是否值得花时间进行这些优化。

EDIT :

相同的基准，但没有#pragma pack:

酷睿 i7 920 @ 3.5 GHz

slow = 4.49
fast = 4.442
sum = 99999990000000000

英特尔至强 X5482 Harpertown @ 3.2 GHz

slow = 3.684
fast = 3.717
sum = 99999990000000000

• Core i7 的数字没有变化。显然它可以处理 对于这个基准测试来说，错位没有问题。
• 现在，Core 2 Xeon 的两个版本显示相同的时间。这证实了 Core 2 架构上存在未对齐问题。

摘自我的评论：

如果您省略#pragma pack，编译器将使所有内容保持一致，这样您就不会看到这个问题。所以这实际上是一个例子，如果你misuse #pragma pack.