标签: stdvector

我有一个函数将一个向量复制到另一个向量（以及许多其他东西）。代码的简化版本如下。

void Fun(std::vector<double> &in, std::vector<double> &out) {
    out = in;
}

我关心最大化效率，因为该函数将运行多次。因此，我想尽可能避免重新分配内存。向量“in”可能已经为其保留了大量内存。因此，如果我进行手动实施，我确信我可以完成此任务。例如：

void Fun(std::vector<double> &in, std::vector<double> &out) {
    out.resize(in.size());//note - if the capacity of out is greater than in.size(), this will involve no memory release or allocation
    for (unsigned int i = 0;i<in.size();i++) {
        out[i] = in[i];
    }
}

如果 in.size() 小于 out 的现有容量，则后一个实现将不会释放或分配任何新的堆内存。

问题是 - 我原来的实现会做同样的事情吗？即，如果我简单地执行“out = in;”，std::vector 会知道以内存有效的方式自动执行此操作吗？

我尤其担心也许“out = in;” 行可能会执行一些操作，例如释放当前分配给 out 的所有堆内存，然后重新分配它。与此有效等效的东西：

void Fun(std::vector<double> &in, std::vector<double> &out) {
    out.clear();
    out.shrink_to_fit();//releasing memory from heap
    out.resize(in.size());//reallocating memory from …

我有一个奇怪的问题.我有一个矢量,我想把对象推到这样:

vector<DEMData>* dems = new vector<DEMData>();
DEMData* demData = new DEMData();
// Build DEMDATA

dems->push_back(*demData);

向量中将有几百个DEMData对象.问题是当这段代码完成后,所有项目都等于最后一项"推回"到矢量？

为什么在向量中覆盖其他对象？

编辑:

DemData类很简单,只是一个带有setter和getter的数据结构:

    class DEMData
{
private:
    int bitFldPos;
    int bytFldPos;
    const char* byteOrder;
    const char* desS;
    const char* engUnit;
    const char* oTag;
    const char* valType;
    int index;
public:
    void SetIndex(int index);
    int GetIndex() const;
    void SetValType(const char* valType);
    const char* GetValType() const;
    void SetOTag(const char* oTag);
    const char* GetOTag() const;
    void SetEngUnit(const char* engUnit);
    const char* GetEngUnit() const;
    void SetDesS(const char* desS);
    const …

在一个类中,我试图通过传递同一个类的方法对向量进行排序.但它在编译时会出错.谁能说出问题是什么？谢谢!

它给出以下错误:bool (Sorter::)(D&, D&)' does not matchbool 类型的参数(Sorter ::*)(D&,D&)'

我也试过用 sortBynumber(D const& d1, D const& d2)

#include<vector>
#include<stdio.h>
#include<iostream>
#include<algorithm>

class D {
      public:                   
             int getNumber();            
             D(int val);
             ~D(){};
      private:
              int num;
};

D::D(int val){
         num = val;
         };

int D::getNumber(){
    return num;
};


class Sorter {
      public:                   
             void doSorting();  
             bool sortByNumber(D& d1, D& d2);
             std::vector<D> vec_D;          
             Sorter();
             ~Sorter(){};
      private:
              int num;
};

Sorter::Sorter(){                 
        int i;
        for ( i = 0; i < 10; i++){
            vec_D.push_back(D(i));
           }
         }; …

我正在寻找一个像std :: multimap一样工作的STL容器,但是对随机的第n个元素有不断的访问时间.我需要这个,因为我在内存中有这样的结构std :: multimap有很多原因,但是存储在其中的项必须在列表框中呈现给用户.由于数据量巨大,我正在使用带有虚拟项目的列表框(即列表控制轮询X行的值).

作为一种解决方法,我目前正在使用额外的std :: vector将"索引"存储到std :: map中,我将其填充如下:

std::vector<MMap::data_type&> vec;
for (MMap::iterator it = mmap.begin(); it != mmap.end(); ++it)
    vec.push_back((*it).second);

但这不是很优雅的解决方案.

有一些这样的包装？

我有一个具有向量成员变量的类,我填写如下:

class Foo {
vector<int> v;
void g() {
  vector<int> w;
  // fill w
  v = w;
}

};

我的问题:临时矢量w可能变得很大,我不想付出复制结构的代价.我应该使用std :: swap而不是复制吗？我的理解是std :: swap由于vector的特化而更有效率(它只是将指针交换到堆).

我有一个奇怪的问题.有一个结构向量.使用临时结构,我push_back到结构向量.但是当我检查第一个成员时cnt,我发现它变了.任何的想法？(下面的代码是简化版,但代表性的一个)

struct Vector
{
  float *dim;

  Vector ()
  {
    dim = new float [3];
  }
};

struct Face
{
  float an_N, an_P;
  int P, N;
  Vector Af;
  float Ad;
  Vector cnt;
  float ifac;
  float mf;
};

std::vector <Face> face;

Face temp_face;

for (;;)
{
    temp_face.cnt.dim[0] = 0.f;
    temp_face.cnt.dim[1] = 0.f;
    temp_face.cnt.dim[2] = 0.f;

    for (int q=0; q<n_vtx_2D; ++q)
    {
        temp_face.cnt = temp_face.cnt + pt[vtx[q]] / n_vtx_2D;                
    }                 

    face.push_back(temp_face);
}

std::cout << face[0].cnt.dim[0] << std::endl;

产量

0.25

0

为什么要求我超载运算符=？我以前迭代过一个std :: list,我没有遇到过这样的问题.

class Grup : public Shape {

private:

    std::vector<Shape*> continut;

public:

    static const std::string identifier;

    Grup();
    ~Grup();

    void add(Shape *shape);
    void remove(Shape *shape);
    void output(std::ostream &outs) const;
    void readFrom(std::istream &ins);
    void moveBy(int x, int y);

    friend std::ostream &operator<<(std::ostream &outs, const Grup &grup);
};


std::ostream &operator<<(std::ostream &outs, const Grup &grup)
{

 std::vector<Shape*>::iterator it;

    outs << "Grupul este format din: " << std::endl;

    for (it = continut.begin(); it != continut.end(); it++)
    {

    }    

    return outs;
}

错误:"没有可行的过载'='."

假设我有以下代码:

#include <iostream>
#include <vector>
using namespace std;

class X {
public:
  int x[1000];
  X(int y) { for (int i = 0; i < 1000; i++) x[i] = y; }
};

int main() {
  vector<X> v;
  X x0(0);
  X x1(1);
  X x2(2);
  v.push_back(x0);
  v.push_back(x1);
  v.push_back(x2);
  cout << v[2].x[33] << endl;
  return 0;
}

如果我理解正确的话,在我的代码,我栈上分配内存x0,x1并且x2,然后通过复制分配给我的那些内容到内存vector.此外,据我所知,移动语义在这里无济于事,因为它并不完全像是X指向位于其他地方的资源的指针.

我可以直接调用分配给我的原始内存块上的构造函数vector吗？如果没有,处理这类情况的正确方法是什么？

我有一个游戏，检查子弹与敌人之间的碰撞，并将其存储为2个矢量容器。人们说，如果您要删除for循环中的元素，则最好使用迭代器，所以我做到了。但是现在我有一个将迭代器传递给函数的问题。问题是我不必删除元素，因此它必须更复杂一些。

这是我检查碰撞的方法。“ CircularCollision”工作正常，没有错误。

void ResolveColision(Weapon &weap, Map &map)
{
    std::vector<Bullet> bullets = weap.GetBullets();

    if (!bullets.empty())
    {
        for (std::vector<Bullet>::iterator i = bullets.begin(); i != bullets.end(); ++i)
        {
            std::vector<Enemy> enemies = map.GetEnemies();

            if (!enemies.empty())
            {
                for (std::vector<Enemy>::iterator j = enemies.begin(); j != enemies.end(); ++j)
                {
                    if (CircularCollision((*i), (*j)))
                    {
                        weap.DeleteByIndex(i);
                        map.TakeDamageByIndex(j, weap.GetDamage());
                        std::cout << "HIT!\n";
                    }
                }
            }
        }
    }
}

这是应该减少敌人生命值的方法：

void Map::TakeDamageByIndex(std::vector<Enemy>::iterator &itr, int damage)
{
   (*itr).SetHealth((*itr).GetHealth() - damage);
}

这是删除项目符号的方法：

void Weapon::DeleteByIndex(std::vector<Bullet>::iterator &itr)
{
    destroySprite((*itr).GetSprite());
    bullets.erase(itr);
}

我敢肯定它看起来很可怕并且不起作用，但我不知道如何正确执行。请帮忙！同样，当for循环使用索引（例如bullets [i]）操作时，这两种方法都可以正常工作，在这种情况下，问题出在“向量下标超出范围”错误。

我想对元素进行排序。

例如：最初，我获取5元素并对其进行排序。问题是，下一个5元素应添加到先前的5元素中，然后再执行排序。

在向量中执行的任何内置函数吗？