Question

我有一个std ::对象向量：

std::vector<Character>

其中

class Character{
....
Vector position;
Vector velocity;
Vector force;
double mass;
};

我只需要特定的成员值（位置）来绘制我的场景。有没有快速的方法来访问对象向量中的某个成员？我宁愿避免像

这样的循环

std::vector<Vector> tmp;
for(int i=0; i<vect.size(); i++)
    tmp.push_back(vect[i].position);

因为我没有看到经常复制元素的重点，特别是在有很多元素时。

Answer 1

如果您关注性能，即只需要一个小对象（Character）来缓存大对象（例如Vector）的开销，您应该考虑从更改您的设计结构数组（AoS）到数组结构（SoA）：

class Characters {
  std::vector<Vector> positions;
  std::vector<Vector> velocities
  std::vector<Vector> forces;
  std::vector<double> masses;
  ...
};

并定义一些类似迭代器的类来表示单个字符（当然这必须是friend的{{1}}）

Characters

这确实可以加快速度。

Answer 2

通过引用调用函数不会生成副本：

void Draw(vector<Character>& characters) {
  // Render from the referenced vector, no copies made
}

int main(int argc, char* argv[]) {
  vector<Character> characters;

  // Generate characters in vector

  Draw(characters);

  return 0;
}

评论后编辑：

class GraphicalContext {
  // Add needed stuff
};

class Drawable {
  virtual ~Drawable() {}
  virtual void Draw(GraphicalContext& gc) = 0;
};

class Tree : public Drawable {
  void Draw(GraphicalContext& gc) {
    // Draw the tree
  }
};

class Character : public Drawable {
  void Draw(GraphicalContext& gc) {
    // Draw the character
  }
};

typedef vector<Drawable*> Objects_t;

void RenderWorld(GraphicalContext& gc, Objects_t& objects) {
  Objects_t::iterator iter = objects.begin();
  for(; iter != objects.end(); ++iter) {
    (*iter)->Draw(gc);
  }
}

int main(int argc, char* argv[]) {
  Objects_t objects;

  // Insert objects into objects vector

  GraphicalContext gc;

  RenderWorld(gc, objects);

  return 0;
}

有vector <object>;返回向量<object.member>而不复制</object.member> </object>

2 个答案: