为什么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和其他集合表现不同？ …假设你有一个有效的起点:
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?
我编写工具来转储和加载二进制文件中的常见对象。在第一个快速实现中，我为std::vector<bool>. 它有效，但显然没有在内存中进行优化。
template <>
void binary_write(std::ofstream& fout, const std::vector<bool>& x)
{
std::size_t n = x.size();
fout.write((const char*)&n, sizeof(std::size_t));
for(std::size_t i = 0; i < n; ++i)
{
bool xati = x.at(i);
binary_write(fout, xati);
}
}
template <>
void binary_read(std::ifstream& fin, std::vector<bool>& x)
{
std::size_t n;
fin.read((char*)&n, sizeof(std::size_t));
x.resize(n);
for(std::size_t i = 0; i < n; ++i)
{
bool xati;
binary_read(fin, xati);
x.at(i) = xati;
}
}
如何std::vector<bool>在我的流中复制 a 的内部存储器？
注意： 我不想用 其他东西替换std::vector<bool> 。
我的目的是将逗号分隔的值列表解析为嵌套向量.这个清单是二维的.基本问题是:
像"牵引"下的表格:
'
' RPM
0,5000,10000,15000,20000,25000
'
' Temp
'
-40.,0.,20.,40.
'
' Traction
200.,175.,170.,165.,160.,150.
200.,175.,170.,165.,160.,150.
165.,165.,160.,155.,145.,145.
160.,155.,150.,145.,145.,140.
'
在接下来的步骤中,我想阅读4维数据,但是现在我正在努力解决第二个问题.数据结构如下:
struct table {
std::vector<double> index;
std::vector<double> index2;
std::vector<std::vector<double> > base;
};
语法是恕我直言,非常简单如下:
comment %= qi::lexeme[ '\'' >> *(qi::standard::char_ - qi::eol)] >> qi::eol;
commentblock = comment >> *(comment);
doublevector = qi::double_ % ',' >> qi::eol ;
vectorblock = *doublevector;
start = commentblock >>
doublevector >>
commentblock >>
doublevector >>
commentblock >>
vectorblock >>
commentblock >>
qi::eoi
;
到目前为止,我解析这两个向量 …
我目前正在学习 vulkan。在其中一个教程中，我看到了一个大致执行以下操作的函数：
#define SOMESTRING "Hello World!"
std::vector<const char*> buildVector() {
std::vector<const char*> vec;
vec.push_back(SOMESTRING);
return vec;
}
当我看到这个时，我想知道：这是定义的行为吗？字符串的内容不是"Hello World!"位于堆栈上，因此一旦函数返回就无效吗？如果这是未定义的行为，那么正确的方法是什么？不幸的是，std::string由于 vulkan API ，使用不是一种选择。
我已经听说std::vector<T>::iterator可以简单地T*代替迭代器类。
但这真的合法吗？
指针算术仅适用于数组，std::vector不创建数组对象 ( T[]) 而是创建连续对象（通过放置 new）。
此外，我认为std::launder甚至需要（C++17）来访问单个元素（正如我们可以在 的static_vector示例注释中阅读的那样std::aligned_storage）。
我认为这大致相当于遵循我认为是未定义的行为。
template <typename T, std::size_t N, typename F>
void test_array(F func)
typename std::aligned_storage<sizeof (T) * N, alignof (T)>::type data;
char* buffer = &data;
for (std::size_t i = 0; i != N; ++i) {
new (buffer + i * sizeof(T)) T;
}
T* array = reinterpret_cast<T*>(buffer);
for (std::size_t i = 0; i != N; …C++ 标准建议 std::vector 呈指数增长，以便在重新分配方面具有“摊销不变成本”。
虽然这种类型的增长适用于大多数场景，但可能有一种情况我发现我需要使用不同的算法来增长向量。
有没有办法自定义 std::vector 的增长方式以及它在重新分配之前检查的条件？
I am learning the behavior of std::vector: how it relocates (copies/moves) objects when reserving more capacity:
#include<vector>
#include<iostream>
using namespace std;
struct A{
A(const A& a){ i=a.i; cerr<<"copied "<<i<<endl; } //(1)
A( A&& a){ i=a.i; cerr<<"moved "<<i<<endl; }
A(int i):i(i){cerr<<"created "<<i<<endl;};
A(){};
private:
int i=0;
};
int main()
{
vector<A> v1;
size_t prevcap=v1.capacity();
for(int i=0; i<10; ++i){
v1.emplace_back(i);
if(prevcap!=v1.capacity()){
cerr<<"capacity increased to "<<v1.capacity()<<endl;
prevcap=v1.capacity();
}
cerr<<"------"<<endl;
}
}
With my g++-10 the output is:
created 0
capacity increased to …