我是新人,所以我很可能错过了一些关键.
我正在使用std :: vector来存储来自ReadFile操作的数据.
目前我有一个名为READBUFF的结构,它包含一个byte向量.然后,READBUFF通过名为Reader的类中的私有类型进行实例化.
class Reader{
public:
void Read();
typedef struct {
std::vector<byte> buffer;
} READBUFF;
private:
READBUFF readBuffer;
}
在Read()中,我当前将数组的大小调整为我想要的大小,因为默认分配器创建了一个非常大的向量[4292060576]
void Reader::Read()
{
readBuffer.buffer.resize(8192);
}
这一切都很好,但后来我想我宁愿动态新建矢量内联,所以我控制指针的分配管理.我将缓冲区更改为:std :: vector*buffer.当我尝试执行以下操作时,未将缓冲区设置为新缓冲区.从调试器中可以清楚地看出它没有被初始化.
void Reader::Read()
{
key.buffer = new std::vector<byte>(bufferSize);
}
所以我尝试了,但这与上面的行为相同.
void Reader::Read()
{
std::vector<byte> *pvector = new std::vector<byte>(8192);
key.buffer = pvector;
}
主要的第一个问题是为什么这不起作用？为什么我不能将缓冲区指针分配给有效指针？另外,我如何定义内联分配的大小与必须调整大小？
我的最终目标是"新建"缓冲区,然后将它们存储在双端队列中.现在我这样做是为了重用上面的缓冲区,但我本质上是将缓冲区复制到另一个新的缓冲区,当我想要的是存储一个指向创建的原始缓冲区的指针.
std::vector<byte> newBuffer(pKey->buffer);
pKey->ptrFileReader->getBuffer()->Enqueue(newBuffer);
提前致谢.我发现,当我发布这篇文章时,我错过了一些基本但我不知所措.
我有以下代码为整数向量的向量(即整数矩阵..)
vector<vector<int> > scores (3, vector<int>(2,0));
cout<<scores[1][5];
这不会给出EXC_BAD_ACCESS,但这样做:
cout<<scores[5][1];
为什么行为不同？
只是为了澄清:这并不是特定于给出的示例数字.当内部维度超出界限时,永远不会出现错误,外部则不然!
我想有一个向量z,并能够访问它z[i]或*pz[i],其中*pz[i]指出z[i].所以有一组值,但有两种方法可以访问它.
这是我的代码:
std::vector<double> z;
std::vector<double*> pz;
for (int i = 0; i < 5; i++) {
z.push_back(7+0.01*i);
std::cout << i << " z = " << z << std::endl;
pz.push_back(&z.back());
std::cout << i << " pz = " << pz << std::endl;
std::cout << i << " *pz = " ;
for (int j = 0; j < pz.size(); j++) {
std::cout << " " << *pz[j];
}
std::cout << std::endl;
} …我有一个非常大的std :: vector std :: vectors,它包含固定数量的无符号整数.
所有uint向量都按升序排序.
我目前消除重复向量的方法是
unsigned int i = 0;
while ( i < new_combs.size() )
{
unsigned int j = i + 1;
while ( j < new_combs.size() )
{
unsigned int k = 0;
while ( k < new_combs.at(i).size() && new_combs.at(i).at(k) == new_combs.at(j).at(k) )
++k;
if ( k == new_combs.at(j).size() )
new_combs.erase(new_combs.begin() + j);
else
++j;
}
++i;
}
这里,new_combs是包含如上所述的向量的向量.
如果向量矢量未排序,是否有更有效的方法来消除重复？
所以我有一个向量,初始是空的,但肯定会被填满.它包含结构实例:
struct some {
int number;
MyClass classInstance;
}
/*Meanwhile later in the code:*/
vector<some> my_list;
当它发生时,我想为向量添加值,我需要将其放大一个.但是,当然,我不想创建任何变量来做到这一点.没有这个请求,我会这样做:
//Adding new value:
some new_item; //Declaring new variable - stupid, ain't it?
my_list.push_back(new_item); //Copying the variable to vector, now I have it twice!
所以,相反,我想new_item通过增加它的大小来创建矢量 - 看看:
int index = my_list.size();
my_list.reserve(index+1); //increase the size to current size+1 - that means increase by 1
my_list[index].number = 3; //If the size was increased, index now contains offset of last item
但这不起作用!似乎空间没有分配 - 我得到 …
int main()
{
vector<int> vi;
vi.reserve(10);
// back_insert_iterator<vector<int> > iter(vi);
vector<int>::iterator iter = vi.begin();
*iter = 1;
++iter;
*iter = 2;
++iter;
*iter = 3;
back_insert_iterator<std::__1::vector<int> > iterb(vi);
back_inserter(vi) = 4;
back_inserter(vi) = 5;
vi.reserve(vi.size() * 2);
copy(vi.begin(), vi.end(), vi.end());
ostream_iterator<int> os(cout, " ");
copy(vi.begin(), vi.end(), os);
}
问题1,为什么cout打印4 5,我预计会打印1 2 3 4 5 1 2 3 4 5？问题2,当我更换它时copy(vi.begin(), vi.end(), back_insert(vi)),它会打印4 5 4 5,为什么？
我已经提出了一个解释现象的理论,但我希望有一个知识渊博的人来承担我.
在客户端代码中,我有:
vector<bool> candidates;
fillCandidates(candidates);
在被叫方,我有:
void fillCandidates(vector<bool>& candidates)
{
// reserve space for two elements
candidates.reserve(2);
candidates[0] = true;
candidates[1] = false;
// here, candidates.size() == 0
}
当我在函数返回后检查候选人的大小时,它是0!发生了什么？我正在使用64位Ubuntu 12.04上的CMake脚本调用gcc 4.6.3(但我认为所有这些实际上都是无关紧要的).
注意:我提供了我的解释作为答案.
编辑:接受的答案和评论在时间上打败了我,所以我的解释不会添加任何东西.
给定一个C ++向量（假设它是双精度数，我们称它为unsorted），最有效的方法是创建一个新的向量sorted，该向量包含一个排序的副本unsorted？
考虑以下简单的解决方案：
std::vector<double> sorted = unsorted;
std::sort(sorted.begin(), sorted.end());
此解决方案有两个步骤：
unsorted。但是，在步骤1的初始副本中可能会浪费很多精力，尤其是对于（例如）已经被大量排序的大型矢量而言。
如果我用手编写此代码，则可以通过将第一遍读取unsorted向量中的值，同时将它们（根据需要进行部分排序）写入向量中，从而将排序算法的第一遍与步骤1结合起来sorted。根据算法，随后的步骤可能仅适用于中的数据sorted。
有没有办法使用C ++标准库，Boost或第三方跨平台库来执行此操作？
重要的一点是要确保sorted在排序开始之前，不必将C ++向量的内存不必要地初始化为零。许多排序算法将要求立即对sorted向量进行随机写入访问，因此使用，reserve()并且push_back()对于该第一遍将不起作用，但resize()会浪费时间初始化向量。
编辑：由于答案和评论不一定了解为什么“单纯的解决方案”效率低下，请考虑以下情况：unsorted数组实际上已经按排序顺序排序（或者只需要一次交换就可以排序）。在那种情况下，无论采用哪种排序算法，使用朴素的解决方案，每个值都至少需要读取两次-复制时一次，排序时一次。但是使用分时复制解决方案，读取次数可能减半，因此性能大约翻倍。unsorted当使用性能更高的排序算法std::sort（可能是O（n）而不是O（n log n））时，不管中的数据如何，都会出现类似的情况。
如果在将对象移至std :: vector时内存分配失败，并且抛出bad_alloc，std :: vector是否保证从对象移出的对象不变/仍然有效？
例如：
std::string str = "Hello, World!";
std::vector<std::string> vec;
vec.emplace_back(std::move(str));
/* Is str still valid and unaltered if the previous line throws? */
我编码很有趣。我创建了一个地图矢量来查看我可以使用容器做什么。当我遍历矢量时，只有Alfred和Angela出现。如何显示所有名称？可能吗 这是我到目前为止的内容：
#include <map>
#include <iostream>
#include <conio.h>
#include <vector>
#include <string>
int main()
{
//create a map
std::map<std::string, unsigned int> mySuperCoolMap;
mySuperCoolMap["Edward"] = 39;
mySuperCoolMap["Daniel"] = 35;
mySuperCoolMap["Carlos"] = 67;
mySuperCoolMap["Bobby"] = 8;
mySuperCoolMap["Alfred"] = 23;
std::cout << "\n\n";
//Ranged based for loop to display the names and age
for (auto itr : mySuperCoolMap)
{
std::cout << itr.first << " is: " << itr.second << " years old.\n";
}
//create another map
std::map<std::string, …