这表明我可以从数组构造一个向量,如下所示:
// the iterator constructor can be used to construct from arrays:
int myints[] = {16,2,77,29};
vector<int> myvector (myints, myints + sizeof(myints) / sizeof(int) );
为什么构造函数的第二个参数myints + sizeof(myints) / sizeof(int)？
可能重复:
移动向量是否会使迭代器失效？
请考虑以下代码:
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<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());
}
总结问题:
std::vector和其他集合表现不同？ …我不知道该怎么做 - 请告诉我下面的代码有什么问题.我修改了我的代码,将其简化为最简单的术语.有一个带有一堆MyNode对象的std :: vector.第一步是获取对这些节点之一(Data m_data)的一个数据元素的常量引用 - 在下面的示例中,在插入第二个节点之前只有一个节点,如下所示:
const cv::Data& currData = m_nodesVector[currIndex].GetData();
MyNode node(...);
m_nodesVector.push_back(node);
正好在vector :: push_back调用中,currData的值发生了变化!我只是不明白.如何将新节点插入向量会将值引用更改为第一个节点的数据？!! 请注意,在"创建"第二个节点时,该值不会更改 - 但是在插入到std :: vector中的操作时.我的意思是,我认为std :: vector可能会重新调整一些内存,但这不应该改变引用权吗？
编译器= VS 2012
多谢你们.非常感激.
假设你有一个有效的起点:
std::vector<UINT32> host = {1,2,3,4,5};
当您尝试使用迭代器构造另一个向量时:
std::vector<UINT32> client(host.begin(),host.end());
// client.size() is 5. Elements begin -> end look just like host.
但是如果迭代器倒退会发生什么呢？如果开始是在结束之后怎么办？
std::vector<UINT32> backwardsClient(host.end(), host.begin());
// What happens?
我正在学习c ++ 11,我对移动语义和右值引用有疑问.我的示例代码如下(C++ Shell URL是cpp.sh/8gt):
#include <iostream>
#include <vector>
void aaa(std::vector<int>&& a)
{
std::cout << "size of a before move: " << a.size() << std::endl;
std::vector<int> v;
v = a; /*std::move(a)*/
std::cout << "size of a after move: " << a.size() << std::endl;
}
int main ()
{
std::vector<int> foo (3,0);
aaa(std::move(foo));
return 0;
}
结果是:
Run Code Online (Sandbox Code Playgroud)size of a before move: 3 size of a after move: 3
这似乎性病::向量的线,则不会调用的移动赋值运算符v = a的功能aaa,否则a将有大小为0,而不是3.
但是,如果我改变 …
此代码是否会导致未定义的行为:
#include <vector>
struct S
{
S() {}
int x;
};
int main()
{
std::vector<S> vec(5, S());
}
由于S()默认初始化自动对象,因此其内容不会首先归零,因此x将是不确定的.然后将包含不确定值的对象复制到每个向量位置.
动机:我们可能期望这个行为与std::vector<S> vec(5);不是UB的行为相同(因为C++ 11),所以这是一个容易犯的错误.
正如Praetorian在评论中所提到的,在C++之前,11可以std::vector<S> vec(5);自由地进行5次默认初始化,或者对部分或全部项目使用复制构造函数.
我有std::vector一些数据(在我的情况下是点),我想循环遍历所有不同的元素对.对的顺序并不重要(因为我只对点的距离感兴趣).使用经典for循环,我想要做的是:
std::vector<double> vec{-1., 3., 5., -8., 123., ...};
for (std::vector<double>::size_type first = 0; first < vec.size(); ++first) {
for (std::vector<double>::size_type second = first+1; second < vec.size();
++second) {
// Compute something using std::fabs(vec.at(first)-vec.at(second))
}
}
我现在的问题是,如果使用基于范围的循环可以更优雅地实现这一点.