标签: stdvector

我目前有一些代码,我使用的vector是pair<string,string>.这用于存储来自XML解析的一些数据,因此,该过程在某些地方非常慢.在试图加快整个过程中,我想知道是否有将是从交换任何性能方面的优势vector<pair<string,string> >来std::map<string,string>？我可以编写代码并运行一个分析器,但我想我会看到我是否能得到一个答案,表明首先会有一些明显的性能提升.我不需要进行任何排序,我只是将项添加到向量中,然后在稍后阶段迭代内容并进行一些处理 - 我不需要排序或任何这种性质.我猜也许我不会获得任何性能提升,但我从来没有真正使用过std::map,所以我不知道没有要求或编码全部.

我是C++的新手.我想知道如何在向量中找到重复的字符串并打印出该字符串的一个副本.例如,如果我有<"猫","狗","狗","鸟",>它会打印出猫,狗,鸟.我已经对我的向量进行了排序,并使用了adjacent_find函数并迭代了向量(因为我必须找到是否有任何单词重复).我的代码检测到重复,但它只打印出非重复的代码.我想改变它以打印出所有非重复项,也只打印其中一个重复项,因此矢量中的所有字符串都会打印出来.这是我到目前为止的代码:

public: void print(vector<string> in) // print method for printing a vector and it's key
{ 

  sort(in.begin(), in.end()); // sort the vector alphabetically first

  vector<string>::iterator it; 

      for( it = in.begin(); it != in.end(); it++ ) // iterate through it


             if(adjacent_find(in.begin(), in.end()) == in.end()) // don't print duplicates


             cout << *it<<endl; // and print out each string in the vector
}

我在尝试删除指针向量时遇到问题:

std::vector<float*> *v;

v = new std::vector<float*>;
v->assign(2, new float[2]);

for (int i = 0; i < 2; ++i)
{
    delete[] v->at(i);
}
delete v;

我正在删除整个向量中的每个元素,但我仍然得到一个断言.你能告诉我我做错了什么吗？

先感谢您.

给定一个char数组的指针,是否可以从中构造一个std :: vector或boost :: array,并避免内存复制？

提前致谢!

为什么std::queue用std::vector容器创建不会引起编译器错误？

只有在调用pop时才会出现编译器错误(这很明显,因为vector不提供pop_front()).

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

int main()
{
    queue<int, vector<int>> s;

    s.push(10);

    cout << s.front() << endl;

    s.pop();

    return 0;
}

DEMO

我有一个std::vector<vector<double>>我想填写一个功能.我需要在我的程序中稍后为某些计算存储一些3维坐标.

我的问题是如果我这样做:

//in classdefinition
std::vector<std::vector<double>> data;

    myFunc()
    {
        std::vector<double> temp;
        temp.push_back(1);
        temp.push_back(2);
        temp.push_back(3);
        data.push_back(temp);

        temp.clear();
        //new data
        temp.push_back(2);
        temp.push_back(3);
        temp.push_back(4);
        data.push_back(temp);
    }

清除和重新填充temp会影响数据中的值吗？

我已经找到了这个http://www.cplusplus.com/reference/vector/vector/push_back/, 但由于解释是"将val的内容复制(或移动)到新元素." 我不知道该怎么想.对我来说,这听起来像是一个矛盾.

我认为如果变量作为参考传递是没有多大意义的,因为它们可以像我的情况一样只在有限的范围内有效.我的假设是对的吗？

我有以下脚本在特定基础中创建所有可能的点:

int main(){

  int base;
  cout << "Enter Base: ";
  cin >> base;

  int dimension;
  cout << "Enter Dimension: ";
  cin >> dimension;

  //This creates all possible numbers
  vector<double> dist;
  dist.reserve(base);
  for(int k=0; k<base; k++){
    dist[k] = (-1.0+k*2.0/(base-1.0));
  }

  vector< vector<double> > points;
  int perms = 1;
  for(int i=0; i<dimension; i++){
    perms *= base;
  } // base^dimension
  points.reserve(perms);

  vector<double> stand;
  stand.reserve(dimension);

  // Defined later
  getPermutations(dist, base, stand, dimension, 0, points);

  for(int i=0; i<points.size(); i++){ //DOESN'T DO ANYTHING BECAUSE SIZE IS …

有没有办法用另一个设置std :: vector,其中两个是不同类的向量？

struct A {
   int a;
};

struct B {
   int a, b;
   B(int _a, int _b) : a(_a), b(_b) {}
};

int commonB = 123;

std::vector<A> va;
std::vector<B> vb;

// Fill va...

// Code I would like to optimise:
for(size_t i = 0; i < va.size(); ++i) {
    vb.push_back(B(va[i].a, commonB));
}

像(伪代码)一样:

vb = va;

B :: b值未初始化？

我有以下一段代码，用于将二维数组转换为一维向量。数组使用 std::vector 分配，嵌套的 for_each 循环用于将二维数组的内容传输到一维数组。

#include <iostream>
#include <algorithm>
#include <vector>
#include <stdexcept>
#define UNUSED(expr) (void)(expr)

using usll = __uint64_t;

void print1d(std::vector<double> vv);
void matToVect1d(const std::vector<std::vector<double>>& v2d, std::vector<double>& v1d);
void matToVect1dEx(const std::vector<std::vector<double>>& v2d, std::vector<double>& v1d);

int main(int argc, char* argv[])
{
    UNUSED(argc);
    UNUSED(argv);

    std::cout << std::endl;

    const usll DIM0 {10};
    const usll DIM1 {8};

    std::vector<std::vector<double>> data2d(DIM0, std::vector<double>(DIM1));
    std::vector<double> data1d(DIM0 * DIM1);
    double temp = 0.0;

    for (usll i{}; i<DIM0; ++i)
    {
        for (usll j{}; j<DIM1; ++j)
        {
            data2d[i][j] = temp++; …

使用g++flag编译时，这些对数组和向量求和的函数之间似乎存在性能差异-O3：

float sum1(float* v, int length) {
    float sum = 0;
    for(int i = 0; i < length; i++) {
        sum += v[i];
    }
    return sum;
}

float sum2(std::vector<float> v) {
    return sum1(&v[0], v.size());
}

当sum1使用例如长度为 100000 和sum2具有相同长度和内容的向量调用时，sum2最终大约为。比sum1我的测试慢 10% 。测量的运行时间是：

sum1: 0.279816 ms
sum2: 0.307811 ms

现在这个开销从何而来？附加您还可以找到我在那里犯错误的可能性的完整测试代码。

[更新]通过引用 ( float sum2(std::vector<float>& v))调用时，性能差异约为 . 还剩下 3.7%，所以这会有所帮助，但在其他地方仍有一些性能损失？

[更新 2]其余的似乎在统计上占主导地位，从更多的迭代中可以看出。因此，唯一的问题确实是通过引用调用！

完整的测试代码（编译标志-O3与g++，也与测试clang++）：

sum1: …