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

Have vector<object>; return vector<object.member> without copying

本文关键字：gt object lt vector 复制 返回 member      更新时间：2023-10-16

我有一个对象的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);

因为我不认为经常复制元素有什么意义，尤其是当有很多元素的时候。

如果您关心性能，即当只需要一个小对象（Vector）时缓存大对象（如Character）的开销，您应该考虑将您的设计从结构的阵列（AoS）更改为结构:

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

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

class Character {
  Characters* const C;
  std::size_t       I;
public:
  Vector const&position() const { return C->positions[I]; }
  Vector &position() { return C->positions[I]; }
  ...
};

这确实会加快速度。

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

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;
}
相关文章：