标签: stdvector

我需要从Java传递

List< List<MyPoint> > points;

从jni到C++并转换为

std::vector< std::vector<MyPoint> >

处理此向量并返回

List< List<MyPoint> >

1. 如何正确传递和返回列表清单？
2. 如何转换对象向量向量中的对象列表列表并向后转换？

编辑:我特别比较std::vector的线性搜索操作的std::map 二进制搜索行动,因为这是香草的要求似乎涉及到.我知道使用二进制搜索会将性能从O(N)移到O(log N),但这不会测试Herb的声明

Bjarne Stroustrup和Herb Sutter最近都谈到了std::vector在人们期望std::list使用的情况下有多棒,这是由于链表遍历期间缓存未命中的代价.(见48分钟后http://channel9.msdn.com/Events/Build/2014/2-661)

Herb做了进一步的声明,然而对有序矢量的操作甚至更快std::map(参见http://i.imgur.com/zX07TZR.png取自上述channel9视频的51:30标记),我发现很难捉摸.所以我创建了一个小测试来证明这一点并且很难再现这些结果:https://ideone.com/MN7DYK

这是测试代码:

template <typename C>
void test(std::string name, std::vector<int> shuffledInputValues, C & c)
{
   // fill container 'c' with values from 'shuffledInputValues' then erase them all
   {
      std::cout << "testing " << name << "..." << std::endl;
      timer t;

      for (auto val : shuffledInputValues) insert(c, val);
      for (auto val : shuffledInputValues) remove(c, val);
  }
} …

我有一个偶数大小的向量，我想将其转换为成对的向量，其中每对始终包含两个元素。我知道我可以使用简单的循环来做到这一点，但我想知道是否有一个很好的标准库工具可以做到这一点？可以假设原始向量始终包含偶数个元素。

例子：

vector<int> origin {1, 2, 3, 4, 5, 6, 7, 8};

vector<pair<int, int>> goal { {1, 2}, {3, 4}, {5, 6}, {7, 8} };

我似乎无法想到一个可靠的方法(也压缩内存)从std :: vector中删除前N个元素.怎么会这样做呢？

我正在做的事情:

我试图将一个矢量分成两个独立的数组.当前int向量包含文本文件中每行的元素.文本文件是随机整数列表.

我打算怎么做:

我目前的想法是创建两个常规int数组,然后迭代整个向量并将n/2个元素复制到每个数组.

我想知道的是:

完成任务的最优雅方式是什么？我有一种感觉,我可以做到这一点,而无需多次迭代矢量.

码:

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

vector<int> ifstream_lines(ifstream& fs)
{
  vector<int> out;
  int temp;
  while(fs >> temp)
  {
    out.push_back(temp);
  }
  return out;
}

vector<int> MergeSort(vector<int>& lines)
{
  int split = lines.size() / 2;
  int arrayA[split];
  int arrayB[split];
}

int main(void) 
{
  ifstream fs("textfile.txt");
  vector<int> lines;
  lines = ifstream_lines(fs);

  return 0;
}

谢谢 :)

我正在设计一个具有std::vector<int>实例变量的类.我正在使用a,std::vector因为我需要在运行时设置它的大小.以下是我的代码的相关部分:

my_class.h:

#include <vector>
using std::vector;
class MyClass {
    int size;
    vector<int> vec;
}

my_class.cc:

#include "my_class.h"
using std::vector
MyClass::MyClass(int m_size) : size(m_size) {
     vec = new vector<int>(size,0);
}

当我尝试编译时,我收到以下错误消息:

g++ -c -Wall my_class.cc -o my_class.o

my_class.cc: In constructor ‘MyClass::MyClass(int):

  my_class.cc:4 error: no match for ‘operator=’ in ‘((MyClass*)this)->My_Class::vec = ((*(const allocator_type*)(& std::allocator<int>())), (operator new(24u), (<statement>, ((std::vector<int>*)<anonymous>))))’

make: *** [my_class.o] Error 1

但是,当我将违规行更改为:

vector<int> temp(size,0);
vec = temp;

它现在编译没有故障,我得到了所需的行为,并可以访问我的矢量

vec[i]  // i having been defined as an …

我有一个std::vector<std::uint8_t>,需要重复.只需调用复制构造函数即可完成此操作.

我的分析结果显示,Microsoft Visual C++(msvc100)实现在std::uninitialized_copy内部使用.这将逐个复制每个元素.在这种情况下,可以通过一次复制整个存储块来完成更优化的复制(就像memcpy可能一样).

换句话说,这可能是一个重要的优化.有没有办法强制矢量使用这种优化方法？

注意:我尝试过使用std::basic_string<std::uint8_t>它确实表现更好,但它有其他问题.

这就是重点.如何在其中写入和读取带有std :: vector的二进制文件？

我想的是:

//============ WRITING A VECTOR INTO A FILE ================
const int DIM = 6;
int array[DIM] = {1,2,3,4,5,6};
std::vector<int> myVector(array, array + DIM);
ofstream FILE(Path, ios::out | ofstream::binary);
FILE.write(reinterpret_cast<const char *>(&myVector), sizeof(vector) * 6);
//===========================================================

但我不知道如何阅读这个载体.因为我认为以下是正确的,但它不是:

ifstream FILE(Path, ios::in | ifstream::binary);
FILE.read(reinterpret_cast<const char *>(&myVector), sizeof(vector) * 6);

那么,如何进行操作？

将所有权转移std::vector<unique_ptr<int> >到正在建造的阶级的正确方法是什么？

下面是我想要做的代码表示.我意识到它不正确(不会编译)并违反"唯一性",无论我是通过值还是通过引用将向量传递给构造函数.我希望Foo成为向量的新所有者,并希望调用函数放弃所有权.我需要构造函数std::unique_ptr<std::vector<std::unique_ptr<int> > >来执行此操作吗？

foo.h中

class Foo
{
public:
  Foo(vector<std::unique_ptr<int> > vecOfIntPtrsOwnedByCaller);

private:
  vector<std::unique_ptr<int> > _vecOfIntPtrsOwnedByFoo;
}

Foo.cpp中

Foo::Foo(std::vector<std::unique_ptr< int> > vecOfIntPtrsOwnedByCaller)
{
    _vecOfIntPtrsOwnedByFoo = vecOfIntPtrsOwnedByCaller;
}

任何帮助将不胜感激 - 我已经在网上搜寻正确的方法来做到这一点.谢谢!

假设我想表示int作为向量向量的二维矩阵:

std::vector<std::vector<int> > myVec;

内部尺寸是常数,比如5,外部尺寸小于或等于N.为了尽量减少重新分配,我想保留空间:

myVec.reserve(N);

内部向量的大小是多少？这纯粹依赖于实现吗？这如何影响数据的空间局部性？由于内部维度是常量,有没有办法告诉编译器使用这个常量大小？如果内部向量的大小发生变化,这些答案如何变化？