标签: stdvector

目前我做以下事情:

// float *c_array = new float[1024];

void Foo::foo(float *c_array, size_t c_array_size) {
  //std::vector<float> cpp_array;

  cpp_array.assign(c_array, c_array + c_array_size);
  delete [] c_array;
}

如何优化此分配？我不想执行元素复制,只是交换指针.

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

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

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

myVec.reserve(N);

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

我对这个std::get()功能很困惑.std::get()可以用来访问成员array,pair和tuple.那么,为什么标准不允许它访问成员vector呢？

#include <iostream>
#include <array>
#include <vector>
#include <tuple>
#include <utility> // std::pair
using namespace std;
int main()
{
    array<int, 4> a1{3,4,5,67};
    pair<int,int>  p1{5,6};
    tuple<int,float,float> t1{6,5.5,4.5};

    cout << std::get<1>(a1) <<endl;
    cout << std::get<1>(p1) <<endl;
    cout << std::get<1>(t1) <<endl;
}

以下是输出:

4
6
5.5

但是当我尝试使用std::get()时vector,我得到了这个编译错误:

#include <iostream>
#include <array>
#include <vector>
#include <tuple>
#include <utility> // std::pair
using namespace std;
int main()
{
 vector<int> v1{4,5,6,7,9}; …

我注意到std::vector容器的交换函数具有与所有其他容器不同的 noexcept 规范。具体来说，如果表达式 std::allocator_traits<Allocator>::propagate_on_container_swap || std::allocator_traits<Allocator>::is_always_equal为 true，则该函数为 no except，但其他容器要求表达式std::allocator_traits<Allocator>::is_always_equal为 true。

既然交换函数的行为是相同的，为什么 noexcept 规范仅在std::vector容器中不同？

我有以下代码：

#include <print>
#include <vector>

int main() {
    std::vector<int> v{1, 2, 3};
    std::println("{}", v);
}

在这产生的众多错误中，有（clang++ -std=c++23 -stdlib=libc++，https://godbolt.org/z/3z9Tseh37）：

[...]/format_arg_store.h:167:17: error: static assertion failed due to [...]
  167 |   static_assert(__arg != __arg_t::__none, "the supplied type is not formattable");
      |                 ^~~~~~~~~~~~~~~~~~~~~~~~

这让我很困惑，因为根据cppreference C++23 编译器支持页面，libc++ 支持std::println并实现P2286: Formatting Ranges。

我做错了什么还是这是标准库错误？

我有以下数据:

FolioA Name1 100
FolioA Name2 110
FolioA Name3 100
FolioB Name1 100
FolioB Name3 106
FolioC Name1 108
FolioC Name2 102
FolioC Name3 110

我想只插入唯一的名称(即Name1,Name2和Name3,每一次)

std::vector<std::string> name;

当我遍历数据时.

所以,我有以下代码,我将数据存储在名为test的地图中:

std::map<std::string, std::map<std::string, double> >test;
std::map<std::string, std::map<std::string, double > >::iterator it1 = test.begin(), end1 = test.end();
    while (it1 !=end1) {
        std::map<std::string, double>::iterator it2 = it1->second.begin(), end2=it1->second.end();
        **name.push_back(it2->first);**
        ++it2;
    }
    ++it1;
}

但是,目前通过按照我的方式将数据推送到名称的名称为Name1的2个实例,Name2的2个实例和Name3的3个实例,这是我的代码所期望的.如何修复它只有唯一的名称.

一个unique_ptr不能被推回到一个std::vector，因为它是不可复制的，除非std::move被使用。但是，让我们F使用一个返回a的函数unique_ptr，然后std::vector::push_back(F())允许该操作。下面是一个示例：

#include <iostream>
#include <vector>
#include <memory>

class A {
  public:
    int f() { return _f + 10; }

  private:
    int _f = 20;
};

std::unique_ptr<A> create() { return std::unique_ptr<A>(new A); }


int main() {
  std::unique_ptr<A> p1(new A());

  std::vector< std::unique_ptr<A> > v;

  v.push_back(p1); // (1) This fails, should use std::move

  v.push_back(create()); // (2) This doesn't fail, should use std::move?

  return 0;
}

(2)允许，但(1)不允许。这是因为返回的值被隐式地移动了吗？

在中(2) …

我有一个整数数组,我需要删除重复项,同时保持每个整数第一次出现的顺序.我可以看到这样做,但想象有一种更好的方法可以更好地利用STL算法吗？插入不受我的控制,因此在插入之前我无法检查重复项.

int unsortedRemoveDuplicates(std::vector<int> &numbers) {
    std::set<int> uniqueNumbers;
    std::vector<int>::iterator allItr = numbers.begin();
    std::vector<int>::iterator unique = allItr;
    std::vector<int>::iterator endItr = numbers.end();

    for (; allItr != endItr; ++allItr) {
        const bool isUnique = uniqueNumbers.insert(*allItr).second;

        if (isUnique) {
            *unique = *allItr;
            ++unique;
        }
    }

    const int duplicates = endItr - unique;

    numbers.erase(unique, endItr);
    return duplicates;
}

如何使用STL算法完成？

我想复制矢量的内容,并希望它们被附加在原始矢量的末尾,即 v[i]=v[i+n] for i=0,2,...,n-1

我正在寻找一种很好的方法,而不是循环.我看到std::vector::insert但迭代版本禁止迭代器*this(即行为未定义).

我也尝试std::copy如下(但它导致分段错误):

copy( xx.begin(), xx.end(), xx.end());

除了标准将其定义为连续的事实之外,为什么std :: vector是连续的？

如果空间不足,则需要重新分配新块并将旧块复制到新块,然后再继续.

如果它不连续怎么办？当存储填满时,它只会分配一个新块并保留旧块.当通过迭代器访问时,它会执行简单的>,<检查以查看索引所在的块并将其返回.这样,每次空间不足时都不需要复制数组.

这会真的有用吗？还是我错过了什么？