出于好奇，我以 3 种方式实现了 vector3 实用程序:数组(使用 typedef)、类和结构

这是数组实现:

typedef float newVector3[3];

namespace vec3{
    void add(const newVector3& first, const newVector3& second, newVector3& out_newVector3);
    void subtract(const newVector3& first, const newVector3& second, newVector3& out_newVector3);
    void dot(const newVector3& first, const newVector3& second, float& out_result);
    void cross(const newVector3& first, const newVector3& second, newVector3& out_newVector3);
    }

    // implementations, nothing fancy...really

     void add(const newVector3& first, const newVector3& second, newVector3& out_newVector3)

    {
        out_newVector3[0] = first[0] + second[0];
        out_newVector3[1] = first[1] + second[1];
        out_newVector3[2] = first[2] + second[2];
    }

    void subtract(const newVector3& first, const newVector3& second, newVector3& out_newVector3){
        out_newVector3[0] = first[0] - second[0];
        out_newVector3[1] = first[1] - second[1];
        out_newVector3[2] = first[2] - second[2];
    }

    void dot(const newVector3& first, const newVector3& second, float& out_result){
        out_result = first[0]*second[0] + first[1]*second[1] + first[2]*second[2];
    }

    void cross(const newVector3& first, const newVector3& second, newVector3& out_newVector3){
        out_newVector3[0] = first[0] * second[0];
        out_newVector3[1] = first[1] * second[1];
        out_newVector3[2] = first[2] * second[2];
    }
}

还有一个类实现:

class Vector3{
private:
    float x;
    float y;
    float z;

public:
    // constructors
    Vector3(float new_x, float new_y, float new_z){
        x = new_x;
        y = new_y;
        z = new_z;
    }

    Vector3(const Vector3& other){
        if(&other != this){
            this->x = other.x;
            this->y = other.y;
            this->z = other.z;
        }
    }
}

当然，它包含通常出现在 Vector3 类中的其他功能。

最后，一个结构实现:

struct s_vector3{
    float x;
    float y;
    float z;

    // constructors
    s_vector3(float new_x, float new_y, float new_z){
        x = new_x;
        y = new_y;
        z = new_z;
    }

    s_vector3(const s_vector3& other){
        if(&other != this){
            this->x = other.x;
            this->y = other.y;
            this->z = other.z;
        }
    }

同样，我省略了一些其他常见的 Vector3 功能。 现在，我让他们三个都创建了 9000000 个新对象，并做了 9000000 次叉积(我在其中一个完成后写入了一大块数据数据缓存，以避免缓存帮助他们)。

测试代码如下:

const int K_OPERATION_TIME = 9000000;
const size_t bigger_than_cachesize = 20 * 1024 * 1024;

void cleanCache()
{
    // flush the cache
    long *p = new long[bigger_than_cachesize];// 20 MB
    for(int i = 0; i < bigger_than_cachesize; i++)
    {
       p[i] = rand();
    }
}

int main(){

    cleanCache();
    // first, the Vector3 struct
    std::clock_t start;
    double duration;

    start = std::clock();

    for(int i = 0; i < K_OPERATION_TIME; ++i){
        s_vector3 newVector3Struct = s_vector3(i,i,i);
        newVector3Struct = s_vector3::cross(newVector3Struct, newVector3Struct);
    }

    duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;
    printf("The struct implementation of Vector3 takes %f seconds.\n", duration);

    cleanCache();
    // second, the Vector3 array implementation
    start = std::clock();

    for(int i = 0; i < K_OPERATION_TIME; ++i){
        newVector3 newVector3Array = {i, i, i};
        newVector3 opResult;
        vec3::cross(newVector3Array, newVector3Array, opResult);
    }

    duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;
    printf("The array implementation of Vector3 takes %f seconds.\n", duration);

    cleanCache();
    // Third, the Vector3 class implementation
    start = std::clock();

    for(int i = 0; i < K_OPERATION_TIME; ++i){
        Vector3 newVector3Class = Vector3(i,i,i);
        newVector3Class = Vector3::cross(newVector3Class, newVector3Class);
    }

    duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;
    printf("The class implementation of Vector3 takes %f seconds.\n", duration);


    return 0;
}

结果令人吃惊。

struct 和 class 实现在 0.23 秒左右完成任务， 而 array 的实现只需要 0.08 秒!

如果数组确实有这样显着的性能优势，虽然它的语法会很丑陋，但它在很多情况下都值得使用。

所以我真的很想确定，这是应该发生的事情吗？谢谢!

最佳答案

简短回答:视情况而定。正如您所观察到的，如果在没有优化的情况下进行编译，则会有所不同。

当我在 (-O2 或 -O3) 上进行优化编译(所有内联函数)时，没有区别(继续阅读，它不像看起来很容易)。

 Optimization    Times (struct vs. array)
    -O0              0.27 vs. 0.12
    -O1              0.14 vs. 0.04
    -O2              0.00 vs. 0.00
    -O3              0.00 vs. 0.00

无法保证您的编译器可以/将会做什么优化，所以完整的答案是“这取决于您的编译器”。起初我会相信我的编译器会做正确的事情，否则我应该开始编程汇编。只有当这部分代码是一个真正的瓶颈时，才值得考虑帮助编译器。

如果使用 -O2 编译，您的代码对于两个版本都需要 0.0 秒，但这是因为优化器发现这些值根本没有被使用，所以它只是丢弃了整个代码!

让我们确保这不会发生:

#include <ctime>
#include <cstdio>

const int K_OPERATION_TIME = 1000000000;

int main(){
    std::clock_t start;
    double duration;

    start = std::clock();

    double checksum=0.0;
    for(int i = 0; i < K_OPERATION_TIME; ++i){
        s_vector3 newVector3Struct = s_vector3(i,i,i);
        newVector3Struct = s_vector3::cross(newVector3Struct, newVector3Struct);
        checksum+=newVector3Struct.x +newVector3Struct.y+newVector3Struct.z; // actually using the result of cross-product!
    }

    duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;
    printf("The struct implementation of Vector3 takes %f seconds.\n", duration);

    // second, the Vector3 array implementation
    start = std::clock();

    for(int i = 0; i < K_OPERATION_TIME; ++i){
        newVector3 newVector3Array = {i, i, i};
        newVector3 opResult;
        vec3::cross(newVector3Array, newVector3Array, opResult);
        checksum+=opResult[0] +opResult[1]+opResult[2];  // actually using the result of cross-product!
    }

    duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;
    printf("The array implementation of Vector3 takes %f seconds.\n", duration);

    printf("Checksum: %f\n", checksum);
}

您将看到以下变化:

1. 不涉及缓存(没有缓存未命中)，所以我只是删除了负责刷新它的代码。
2. class和struct从性能上看没有区别(编译后真的没有区别，整个public-private语法糖的区别只是表面的)，所以我只看struct。
3. 叉积的结果是实际使用的，不能优化掉。
4. 现在有 1e9 次迭代，以获得有意义的时间。

通过此更改，我们看到以下计时(英特尔编译器):

 Optimization    Times (struct vs. array)
    -O0              33.2 vs. 17.1
    -O1              19.1 vs. 7.8
    -Os              19.2 vs. 7.9
    -O2              0.7 vs. 0.7
    -O3              0.7 vs. 0.7

我有点失望，-Os 有这么差的性能，但除此之外你可以看到，如果优化，结构和数组之间没有区别!

我个人很喜欢-Os，因为它会产生我能看懂的汇编，所以我们来看看，为什么这么慢。

最明显的事情，无需查看生成的程序集:s_vector3::cross 返回一个 s_vector3 对象，但我们将结果分配给一个已经存在的对象，所以如果优化器看不到旧对象不再使用，他可能无法执行 RVO。所以让替换

newVector3Struct = s_vector3::cross(newVector3Struct, newVector3Struct);
checksum+=newVector3Struct.x +newVector3Struct.y+newVector3Struct.z;

与:

s_vector3 r = s_vector3::cross(newVector3Struct, newVector3Struct);
checksum+=r.x +r.y+r.z; 

现在有结果:2.14 (struct) vs. 7.9 - 这是相当大的改进!

我的收获:优化器做得很好，但如果需要，我们可以提供一点帮助。

关于c++ - 对于 C++ Vector3 实用程序类实现，数组是否比结构和类快？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/46417117/