标签: stdvector

如果我使用这条线

std:vector<MyObject>* vec = new std::vector<MyObject>(100);

• 如果我在堆栈中创建 MyObject 并将它们添加到向量中，它们将保留在堆栈中，对吗？

MyObject obj1;
vec->push_back(obj1);

Run Code Online (Sandbox Code Playgroud)

• 那么，如果它进入堆栈，那么添加到向量中的 MyObject 将在方法结束后消失？向量里面会有什么？垃圾？

• 我应该用这个代替吗？：

  std:vector<MyObject*>* vec = new std::vector<MyObject*>(100);

如果是这样，那么每个 MyObject 内的对象和基元又如何呢？它们也应该动态创建吗？

谢谢

您将如何优雅地（以现代 C++ 方式）编写一个返回向量元素索引的函数，并将该向量作为参数，并引用其元素之一？

异常处理将不胜感激。

#include <vector>

template <class T>
std::size_t GetIndexFromRef(std::vector<T> &vec, T &item)
{
...
};

假设我有这个向量向量[[5,10],[2,5],[4,7],[3,9]]，我想使用sort()cpp的方法对它进行排序，这样[[5,10],[3,9],[4,7],[2,5]]排序后就变成这样了。那就是我想根据第二个索引进行排序。

现在我已经编写了这段代码来对向量的向量进行排序，但它无法正常工作。

static bool compareInterval( vector<vector<int>> &v1, vector<vector<int>> &v2)
    {
        return (v1[0][1]>v2[0][1]);
    }
    

sort(boxTypes.begin(), boxTypes.end(), compareInterval);

谁能告诉我哪里出了问题，我该如何纠正。提前致谢。

我试图将类型作为参数传递给一个方法，该方法将正确构造对象并将其推送到 unique_ptr 向量，但是创建的对象始终是 Base 对象。使用 emplace_back() 时会发生这种情况，如果我只是实例化对象，同样可以正常工作。

在向量外部构造对象效果很好，但是我不确定如何将指针移动到向量。

body_parts.hpp

#include <vector>
#include <string>
#include <fmt/core.h>

using namespace std;

namespace uhcr {

class body_part
{
  public:
    string name = "Generic";

    template <class T>
    void add_body_part()
    {
      this->body_parts.emplace_back<T*>(new T());
      fmt::print("{}\n", this->body_parts.back()->name);
    }

  private:
    vector<unique_ptr<body_part>> body_parts;

};

class torso : public body_part
{
  public:
    string name = "Torso";
    
};

}

字符.hpp

#include <string>

#include "components/body_parts.hpp"

using namespace std;

namespace uhcr {
  
class character : public body_part
{
  public:
    string name = "Character";
    
}; …

我能否确定一个std::vector（或者一般来说，任何标准容器）包含对象而不是指向对象的指针，无论对象的类有多复杂，如果它具有恒定的大小？

例如：在这个简单的情况下：

struct MyStruct { int a, b; };
std::vector<MyStruct> vs;

结果向量布局是：

[ ..., a1, b1, a2, b2, a3, b3, ... ]

标准是否保证在这种（或更复杂的）情况下会发生同样的情况，其中结构的大小应该是恒定的：

struct MyStruct2 { float f[10]; };
std::vector<MyStruct2> vs2;

带布局：

[ ..., f1[0], f1[1], ..., f1[9], f2[0], f2[1], ..., f2[9], ... ]

代替：

[ ..., *pf1, *pf2, ... ]
pf1 = [ f1[0], f1[1], ..., f1[9] ]
pf2 = [ f2[0], f2[1], ..., f2[9] ]

我正在用 C++ 创建一个自定义语言解析器，我正在努力解决运行时错误，其中我有一个std::vector<std::string>带有构造函数的类的成员。完整的错误是：

The procedure entry point
_ZSt28__throw_bad_array_new_lengthv could no be located
in the dynamic link library
"path_to_executable"

每当我尝试在代码中使用 std::vector::push_back 时，都会引发此错误，但 std::vector 不应该是动态大小的数据容器吗？为什么会出现这个错误？

我的一些代码：

The procedure entry point
_ZSt28__throw_bad_array_new_lengthv could no be located
in the dynamic link library
"path_to_executable"

//"lib/cursor.h"

#ifndef T_CURSOR
#define T_CURSOR

#include <iostream>

struct Cursor
{
private:
    std::string input;
    int inputLength;

    char getChar(int p);

public:
    char character;
    int pos;
    int line;
    int column;
    bool eof;
    bool lineBreak;

    Cursor(std::string i);

    void walk(bool back = false);
    void …

C++中有这样的要求吗

sizeof(std::vector<T>) == sizeof(std::vector<S>)

哪里S和T是任意可复制分配和可复制构造的类型？例如，在我的 64 位 Windows 笔记本电脑上，GCC我们有

sizeof(std::vector<int>) == 

sizeof(std::vector<std::tuple<std::vector<double>, 
       int, std::map<int, std::string> > >)

== 24

根据https://en.cppreference.com/w/cpp/container/vector/data，如果大小为 0，则不保证底层指针为 nullptr

如果 size() 为 0，则 data() 可能会也可能不会返回空指针。

但这是否适用于没有元素的默认初始化 std::vector ？或者这只是简单地说明如果向量的所有元素都被删除，底层指针可能不会变成 nullptr？

考虑以下行：

std::vector<int> fooArr;
int* fooArrPtr = fooArr.data();

是否保证fooArrPtr等于 nullptr？

我的代码中有一个我不太明白的错误。根据文档，std::vector.back()返回对容器中最后一个元素的引用，所以这就是我所做的：（住在这里）

#include <iostream>
#include <vector>

class Foo {
  public:
    Foo(int id) : id(id) {
        std::cout << "foo " << id << " constructed" << std::endl;
    }
    ~Foo() {
        std::cout << "foo " << id << " destructed" << std::endl;
    }

    int id;
};

int main() {
    std::vector<Foo> foos;
    
    for (int i = 0; i < 2; i++) {
        foos.emplace_back(i);  // construct foo in place
        
        auto& foo = foos.back();
        std::cout << "Play with " << foo.id << …

这应该是一个简单的问题，但我很难找到答案。

如果我在堆上有多个 std::vector，每个只能由一个线程访问，那么它们是线程安全的吗？也就是说，因为向量将专用于特定线程，所以我只关心向量调整自身大小时的内存访问冲突，而不关心并发访问、数据竞争等。

当然，我可以将每个向量粘贴在其线程的堆栈上，但它们将非常大，可能会导致我的应用程序中的堆栈溢出。

谢谢！