标签: stdvector

inline void add(const DataStruct& rhs) {
   using namespace boost::assign;
   vec.reserve(vec.size() + 3);
   vec += rhs.a, rhs.b, rhs.c;
}

上述功能是为约17000倍执行,其执行(据我可以看到.有一些改造涉及)约2个数量级更差与调用载体::储备.

我总是认为保留可以加速push_back,即使是小值,但这似乎不正确,我找不到任何明显的原因,为什么它不应该这样.保留是否会阻止功能的内联？对size()的调用是否过于昂贵？这取决于平台吗？我会尝试编写一些小基准来在干净的环境中确认这一点.

编译器:gcc (GCC) 4.4.2使用-g -O2

我正在查看std :: vector代码,我发现了一些我不太了解的东西.当capacity <size()+ 1时,它需要重新分配缓冲区,以便它可以插入新元素.它的作用(据我能从代码中提取)是:

• 分配新缓冲区
• 复制旧缓冲区的前缀(0 - 插入索引)
• 在新缓冲区中构造新元素
• 复制旧缓冲区的后缀(索引 - 结束)
• 在旧缓冲区中的所有项目上调用析构函数
• 解除分配旧缓冲区

据我所知,前缀和后缀副本是用memmove完成的.是不是memmove数据的纯二进制副本？它不会调用元素的构造函数,是吗？我想知道的是,为什么函数会调用旧缓冲区中元素的析构函数,如果内存刚被移动,而不是在新缓冲区中重新构造？

我一直在尝试用VHDL代码编写一个有限状态机,用于在Altera DE1板上实现的简单16位处理器.在有限状态机中,我有一个CASE语句处理不同的16位指令,这些指令由16位STD_LOGIC_VECTOR引入FSM.但是,我在有限状态机解码指令的解码状态下遇到了一些麻烦.其中一条指令是ADD,它将两个寄存器作为操作数,第三个作为目标寄存器.但是,我还有一个ADD指令,它将寄存器和5位立即数作为操作数,并将第二个寄存器作为目标.我的问题是在CASE声明,我需要能够区分两种不同的ADD指令.所以,我认为如果我在CASE语句中使用" - "或"X"之类的通配符值,我只能用两种情况区分两者,而不是列出所有可能的寄存器/立即值组合.例如:

    CASE IR IS --(IR stands for "Instruction Register")
      WHEN "0001------0-----" => (Go to 3-register add);
      WHEN "0001------1-----" => (Go to 2-register/immediate value add);
      WHEN OTHERS => (Do whatever);
    END CASE;

这些并不是我唯一的两条指令,我只是将这两条指令缩短了一点.当我编译并运行此代码时,处理器在进入"解码"状态时停止执行.此外,Quartus给出了许多警告,说"LC3FSM.vhd(37)中的VHDL选择警告:忽略包含元值的选择""0001 ------ 0 -----"""我在关于如何实现这一目标的损失.我真的不需要也可能不需要定义每个16位组合,我希望有一种方法可以在STD_LOGIC_VECTOR中使用通配符来最小化我必须定义的组合数.

有人知道怎么做到这一点吗？

谢谢

将嵌套std::vector的std::vectors 转换为最优雅有效的方法是cv::Mat什么？嵌套结构保持一个数组,即所有内部std::vectors具有相同的大小并表示矩阵行.我不介意将数据从一个复制到另一个.

我知道单个非嵌套std::vector很容易,有一个构造函数:

std::vector <double> myvec;
cv::Mat mymat;

// fill myvec
bool copy = true;

myMat = cv::Mat(myvec, copy);

嵌套向量怎么样？

可能重复:
移动向量是否会使迭代器失效？

请考虑以下代码:

std::vector<T> prepare(T*& data) {
    std::vector<T> buffer;
    // Fill in buffer.
    data = buffer.data();
    return buffer;
}

...

T* data;
auto vec = prepare(data);
// line 12

vec.data() != data第12行可能吗？同样的,

std::vector<T> buffer;
// ... Fill in buffer ...
T* data = buffer.data();
auto vec = std::move(buffer);
// line 5

vec.data() != data第5行有可能吗？

实际上两者都不可能在libstdc ++和libc ++的实现中,因为移动构造函数实现为简单的指针赋值,但似乎标准没有在其上指定任何内容(类似于移动std时需要保留的容量: :矢量？)."不变的复杂性"可以保证vec.data() == data吗？

为什么std :: vector有2个运算符[] 实现？

reference       operator[]( size_type pos );
const_reference operator[]( size_type pos ) const;

所以我有一个这样的矢量:

std::vector<std::unique_ptr<SomeClass>> myVector;

然后我有另一个包含原始指针的向量SomeClass:

std::vector<SomeClass*> myOtherVector;

如果里面有一个元素,myOtherVector它也会在里面myVector,所以我想遍历每个元素myOtherVector并从中删除相同的元素myVector.然后清除矢量.这就是我想出的:

for(size_t i = 0; i < myOtherVector.size(); i++)
{
    myVector.erase(std::remove(myVector.begin(), myVector.end(), myOtherVector[i]), myVector.end());
}
myOtherVector.clear();

这会产生编译时错误,因为它myVector保存了唯一的指针,但我给remove()函数一个原始指针.这是我需要帮助的地方,因为我不知道解决这个问题的正确方法是什么.我把线改为:

myVector.erase(std::remove(myVector.begin(), myVector.end(), std::unique_ptr<SomeClass>(myOtherVector[i])), myVector.end());

所有这一切都是不正确的,因为现在我有两个std::unique_ptr引用相同的对象.里面的元素myVector包含一个引用,上面一行中唯一指针的构造是另一个引用.我甚至不知道构造一个新的指针来获得相同类型在概念上是否正确的方法去做这件事.然后我将唯一指针更改为共享指针:

std::vector<std::shared_ptr<SomeClass>> myVector;
std::vector<SomeClass*> myOtherVector;

for(size_t i = 0; i < myOtherVector.size(); i++)
{
    myVector.erase(std::remove(myVector.begin(), myVector.end(), std::shared_ptr<SomeClass>(myOtherVector[i])), myVector.end());
}
myOtherVector.clear();

当我运行应用程序时,该myVector.erase()行导致运行时错误,表示"ApplicationName.exe已触发断点".点击继续,我得到一个调试断言失败.

显然我做错了什么,但我不知道是什么.使用原始指针从矢量中擦除智能指针的正确方法是什么？

我打算使用缓冲区std::vector<size_t> buffer(100),在循环并行化的每个线程中使用一个缓冲区,如此代码所示:

std::vector<size_t> buffer(100);
#pragma omp parallel for private(buffer)
for(size_t j = 0; j < 10000; ++j) {
    // ... code using the buffer ...
}

此代码不起作用.虽然每个线程都有一个缓冲区,但它们的大小为0.

如何在每个线程的开头分配缓冲区？我还能用#pragma omp parallel for吗？我可以比这更优雅地做到这一点:

std::vector<size_t> buffer;
#pragma omp parallel for private(buffer)
for(size_t j = 0; j < 10000; ++j) {
    if(buffer.size() != 100) {
        #pragma omp critical
        buffer.resize(100);
    }
    // ... code using the buffer ...
}

下面的代码按预期工作(测试通过)但我想知道如果以这种方式使用迭代器在c ++中被认为是一种不好的做法,或者它是否正常.

也许这是特定的std::vector,其他集合表现不同,最佳实践在集合(甚至他们的实现)之间有所不同？

在其他语言中肯定不行,并且大多数情况下更改集合将使迭代器无效并抛出异常.

BOOST_AUTO_TEST_CASE (ReverseIteratorExample) {
    std::vector<int> myvector;
    for(int i = 0; i < 5; i++)
    {
        myvector.push_back(i);
    }

    // is this generally a bad idea to change the vector while iterating?
    // is it okay in this specific case?
    myvector.reserve(myvector.size() + myvector.size() - 2 );
    myvector.insert(myvector.end(), myvector.rbegin() + 1, myvector.rend() -1);

    int resultset [8] = { 0,1,2,3,4,3,2,1 };
    std::vector<int> resultVector( resultset, resultset + sizeof(resultset)/sizeof(resultset[0]) );
    BOOST_CHECK_EQUAL_COLLECTIONS(myvector.begin(), myvector.end(), resultVector.begin(), resultVector.end());
}

总结问题:

1. 在迭代时更改向量通常是个坏主意吗？
2. 在这种特殊情况下可以吗？
3. 这是特定的std::vector和其他集合表现不同？ …

我想编写一个带有一个参数的C++函数,以便可以传入以下任何一种类型:

std::vector<int>
std::array<int>
int array[numElements]
int *ptr = new int[numElements]
etc

模板是实现这一目标的最佳方式吗？