Question

好的，我想创建Point3f类，这是一类包含在3D浮点坐标中的点。

所以，我有两种简单的方法来定义类的属性：

class Point3f
{
    float x;
    float y;
    float z;
};

或

class Point3f
{
    float coord[3];
}

我想知道哪个（通常）效率更高，特别是对于图形程序。 I.E.哪个更适合绘制点：glVertex3f（）或glVertex3v（）？
我不知道我是不对的。我认为第一个需要更多的运行时内存，另一个需要更多的CPU使用。

编辑：那么如果我们谈论更复杂的类型，如三角形包含3个点或四面体包含3个三角形呢？＆gt;属性：数组还是一个一个？

请告诉我哪个更有效率，为什么！

Answer 1

您可以比较为基本功能生成的程序集（我在OS X 10.7.4上使用了GCC 4.8.1）

struct Point3D {
  float m_data[3];
};

struct Point3Ds {
  float x;
  float y;
  float z;
};

double dot(const Point3D& p1, const Point3D& p2) {
  asm("# Dot - Point3D");
  return p1.m_data[0] * p2.m_data[0] +
         p1.m_data[1] * p2.m_data[1] +
         p1.m_data[2] * p2.m_data[2];
}

double dot(const Point3Ds& p1, const Point3Ds&p2) {
  asm("# Dot - Point3Ds");  
  return p1.x * p2.x +
         p1.y * p2.y +
         p1.z * p2.z;
}

Point3D cross(const Point3D& p1, const Point3D& p2) {
  asm("# Cross - Point3D");  
  return { p1.m_data[1] * p2.m_data[2] - p1.m_data[2] * p2.m_data[1],
           p1.m_data[2] * p2.m_data[0] - p1.m_data[0] * p2.m_data[2],
           p1.m_data[0] * p2.m_data[1] - p1.m_data[1] * p2.m_data[0]};
}

Point3D cross(const Point3Ds& p1, const Point3Ds& p2) {
  asm("# Cross - Point3Ds");  
  return { p1.y * p2.z - p1.z * p2.y,
           p1.z * p2.x - p1.x * p2.z,
           p1.x * p2.y - p1.y * p2.x};
}

编译为g++ -O3 -S我获得以下汇编程序（相关部分）：

# 12 "point3f.cpp" 1
    # Dot - Point3D
# 0 "" 2
    movss   (%rdi), %xmm0
    movss   4(%rdi), %xmm1
    mulss   (%rsi), %xmm0
    mulss   4(%rsi), %xmm1
    addss   %xmm1, %xmm0
    movss   8(%rdi), %xmm1
    mulss   8(%rsi), %xmm1
    addss   %xmm1, %xmm0
    unpcklps    %xmm0, %xmm0
    cvtps2pd    %xmm0, %xmm0
    ret
LFE0:
    .align 4,0x90
    .globl __Z3dotRK8Point3DsS1_
__Z3dotRK8Point3DsS1_:
LFB1:
# 19 "point3f.cpp" 1
    # Dot - Point3Ds
# 0 "" 2
    movss   (%rdi), %xmm0
    movss   4(%rdi), %xmm1
    mulss   (%rsi), %xmm0
    mulss   4(%rsi), %xmm1
    addss   %xmm1, %xmm0
    movss   8(%rdi), %xmm1
    mulss   8(%rsi), %xmm1
    addss   %xmm1, %xmm0
    unpcklps    %xmm0, %xmm0
    cvtps2pd    %xmm0, %xmm0
    ret
LFE1:
    .align 4,0x90
    .globl __Z5crossRK7Point3DS1_
__Z5crossRK7Point3DS1_:
LFB2:
# 26 "point3f.cpp" 1
    # Cross - Point3D
# 0 "" 2
    movss   4(%rdi), %xmm3
    movss   8(%rdi), %xmm1
    movss   8(%rsi), %xmm5
    movaps  %xmm3, %xmm2
    movss   4(%rsi), %xmm4
    movaps  %xmm1, %xmm0
    mulss   %xmm5, %xmm2
    mulss   %xmm4, %xmm0
    subss   %xmm0, %xmm2
    movss   (%rdi), %xmm0
    mulss   %xmm0, %xmm5
    movss   %xmm2, -24(%rsp)
    movss   (%rsi), %xmm2
    mulss   %xmm4, %xmm0
    mulss   %xmm2, %xmm1
    mulss   %xmm3, %xmm2
    subss   %xmm5, %xmm1
    subss   %xmm2, %xmm0
    movss   %xmm1, -20(%rsp)
    movss   %xmm0, -16(%rsp)
    movq    -24(%rsp), %xmm0
    movd    -16(%rsp), %xmm1
    ret
LFE2:
    .align 4,0x90
    .globl __Z5crossRK8Point3DsS1_
__Z5crossRK8Point3DsS1_:
LFB3:
# 33 "point3f.cpp" 1
    # Cross - Point3Ds
# 0 "" 2
    movss   4(%rdi), %xmm3
    movss   8(%rdi), %xmm1
    movss   8(%rsi), %xmm5
    movaps  %xmm3, %xmm2
    movss   4(%rsi), %xmm4
    movaps  %xmm1, %xmm0
    mulss   %xmm5, %xmm2
    mulss   %xmm4, %xmm0
    subss   %xmm0, %xmm2
    movss   (%rdi), %xmm0
    mulss   %xmm0, %xmm5
    movss   %xmm2, -24(%rsp)
    movss   (%rsi), %xmm2
    mulss   %xmm4, %xmm0
    mulss   %xmm2, %xmm1
    mulss   %xmm3, %xmm2
    subss   %xmm5, %xmm1
    subss   %xmm2, %xmm0
    movss   %xmm1, -20(%rsp)
    movss   %xmm0, -16(%rsp)
    movq    -24(%rsp), %xmm0
    movd    -16(%rsp), %xmm1
    ret

所以组装是一样的。但我同意将静态数组（即float m_data[3]）存储更为实际，因为我可以充分利用这两个世界：在需要时传递一个参数，并且级别，惯用x，y，z来自getters。从这个意义上讲，我相信我会以类似于：

的方式实现这样的类

class MyPoint3S {
 public:
  MyPoint3S(float x, float y, float z)
      : m_data{x, y, z} { }

  // the following getters will be inlined
  float x() const {
    return m_data[0];
  }

  float y() const {
    return m_data[1];
  }

  float z() const {
    return m_data[2];
  }

  // in case you want to use the pointer --- some would advice against
  // offering a hook to a private member.
  float* data() {
    return m_data;
  }

 private:
  float m_data[3];
};

并使用它：

MyPoint3S p(1.0f, 2.0f, 3.0f);
std::cout<<"p = "<<p.x()<<", "<<p.y()<<", "<<p.z()<<std::endl;

获得：

p = 1, 2, 3

或者以您喜欢的方式调用OpenGL函数：

glVertex3fv(p.data());

或

glVertex3f(p.x(), p.y(), p.z());

Answer 2

如何使用union？使用结构，现在您可以双向访问它们。在性能方面，它应该与一个体面的编译器没有任何区别。

struct Point3F {
union {
  float data[3];
  struct {float x, float y, float z};
}
};

Point3F a;
a.x = 21;
a.data[1] == 42;
assert(a.data[0] == 21); // Same data
assert(a.y == 42); // Same data

Answer 3

我自己找到了答案。摘自openGL的红皮书（It can be read here）：

在某些机器上，glVertex *（）的矢量形式更有效，因为只需要将一个参数传递给图形子系统和特殊硬件可能会发送整个系列一批中的坐标。如果您的机器是这样的，那就是为了您的优势，安排您的数据，使顶点坐标按顺序打包在内存中。

但是我仍然想知道哪个更好，例如，对于三角形类：一个点数组或每个单独的点一个接一个。同样的问题可以扩展到更复杂的类型。

Answer 4

我认为第一个需要更多的运行时内存，而另一个需要更多 cpu用法。

两个类都具有完全相同的存储大小。如果你的编译器说float是4个字节，那么你的整个类总共有12个字节。第二个示例将它们组合在一起作为单个内存块，其中第一个示例将它们视为单独的4字节块。

就效率而言，这些都是恒定的时间访问。没关系。

我认为你应该使用第一个。 point.x比point.coord[0]更具描述性。

什么属性对于Point类更有效？

4 个答案: