将'动态分配的对象'推送到向量是否安全？
将动态分配的对象推送到向量是安全的。
动态分配的对象是指在运行时动态创建的对象，通常使用new关键字进行分配内存。向量是一种数据结构，用于存储和管理一组元素。在C++中，向量可以使用std::vector来实现。
将动态分配的对象推送到向量是安全的，因为向量会自动管理内存，并确保对象的正确分配和释放。当将动态分配的对象推送到向量时，向量会调用对象的拷贝构造函数来创建一个副本，并将副本存储在向量中。当向量被销毁时，它会自动调用对象的析构函数来释放内存。
推荐的腾讯云相关产品：无
请注意，以上答案仅供参考，具体的实现方式和推荐产品可能因实际需求和环境而异。
相关·内容
2回答
我知道向量是连续内存，数组也是如此。所以当我这样做的时候会发生什么：
std::vector<uint8_t> my_array[10];
my_array[2].push_back(11);
my_array[2].push_back(7);
记忆会是什么样子？如果两者都需要是连续的，那么每次我在my_array[2]上执行push_back()时，数组中的每个元素都会被向前推一个字节吗？
这是否与我有一个结构数组时的情况相同，其中结构有一个具有可变大小的成员，例如字符串或另一个向量？
浏览 8提问于2014-08-03得票数 5
回答已采纳
当向量满时，它被重新分配，所有的迭代器和指向元素的指针都失效。当用new创建向量时，这种行为是否发生了任何变化？
std::vector<int>* v = new std::vector<int>(); //What happens if this vector gets reallocated?
我可以从它的指针中获取对象(作为一个单独的变量)，还是必须将它复制到另一个对象？
浏览 4提问于2015-11-13得票数 3
回答已采纳
1回答
在C++中，有两种方法可以声明对象。例如：
// The first way
vector<int> *nums = new vector<int>;
// The second way
vector<int> nums;
人们说，第一个声明在堆中分配对象，第二个在堆栈上分配。如果向量对象在堆中，我可以想象它是如何工作的。编译器只需在堆中找到一个空闲块来存储向量。但是，当我不断地将新元素推送到向量时，如果对象被分配到堆栈上会发生什么呢？是否有足够的内存空间？如果没有，编译器如何在堆栈上找到足够大的内存块来存储向量，当向量的大小可以改变时？
浏览 3提问于2015-03-18得票数 8
回答已采纳
在我的代码中，我有一个指向SomeClass对象的指针向量和一个(自定义比较)基于向量的优先级队列，其中包含指向SomeClass对象的指针
std::vector<SomeClass*> my_vector;
std::priority_queue<SomeClass*, vector<SomeClass*>, CustomCompare> my_queue;
最初，my_vector是空的，my_queue是满的。逐渐地，my_queue被清空到my_vector中，如下所示：
my_vector.push_back(my_queue.top());
m
浏览 1提问于2012-08-21得票数 0
回答已采纳
如何为Vector动态分配内存？
vector<Point> vInPts; //我的输入向量-我已经转储了一些值(大小为6)
//对输入向量点做一些计算
vector<Point> vOutPts; //如何为该输出向量点动态分配内存
浏览 0提问于2013-04-17得票数 1
回答已采纳
2回答
在C++中处理指针和向量
、、、
我正在用node类构造一个树，这些类有两个指向子节点的指针。在构建树时，我使用节点的向量进行操作，并最终将它们指向彼此。我经常需要将它们从向量中取出，以维护链接过程的逻辑。不幸的是，如果我指向一个节点并将其弹出向量，该对象就会被销毁(据我所知)。关于如何让我的指针指向正确的位置或更好的系统，有什么建议吗？
编辑--如果有帮助，下面是一些细节：
我有一个节点向量数组：Vector<node> nVec[3]
对于我的程序需要进行的每一级解析，它都会用节点填充这3个向量。然后，基于其他解析数据，我将系统地链接节点。为此，我填充了向量，在某个点上，我需要从nVec[2]中的某个节点链接到
浏览 0提问于2013-02-23得票数 0
回答已采纳
3回答
我刚读过，它讨论了在内存中存储STL向量的位置。根据公认的答案，
vector<int> temp;
堆栈上的向量的头信息，但是堆上的内容。
在这种情况下，下面的代码会不会出错？
vector<int> some_function() {
vector<int> some_vector;
some_vector.push_back(10);
some_vector.push_back(20);
return some_vector;
}
我应该用vector<int> *some_vector = new vector<in
浏览 8提问于2013-12-18得票数 1
回答已采纳
如果我有一个std::vector的东西(比如说，std::vector::clear()调用内容的析构函数吗？例如，如果我有一个数据作为向量，下面的代码是否有效？
char * pd;
for(vector<char *>::iterator it = data.begin(); it != data.end(); ++it) {
pd = *it;
delete pd;
}
或者，它是否像data.clear()那样是多余的？我认为不需要，即需要手动重新分配内容。我假设data.clear()不会为内容调用隐式析构函数？这是正确的吗？这是针对pre C++11的。
浏览 12提问于2014-03-28得票数 22
我们是否可以动态分配
std::vector<fooType> foo[num];
是像这样吗？
std::vector<sidType>* lSamplesPerClass = new vector<sidType>[nClasses];
[...]
delete [] lSamplesPerClass;
浏览 0提问于2013-05-31得票数 3
回答已采纳
2回答
我是C++的新手，也许这些问题非常简单和基本，对此我感到很抱歉！这里我有两个基本问题：
据我所知，C++中的向量是动态数组。他们可以通过向后推/前推元素来改变尺寸。
我的问题是:向量是动态分配的还是“动态数组”名称是因为大小的变化而被调用的？动态分配数组和动态数组使我完全困惑！
STL列表是C++中的链接列表(正如我所理解的)。这些是双链接列表还是单链接列表？
谢谢,
浏览 7提问于2017-07-26得票数 2
4回答
下面的构造函数
std::vector<Object> objects(n);
创建n个调用默认构造函数的对象，例如：
std::vector <Object> objects;
for (unsigned int i = 0; i < n; i++) objects.push_back(o);
此过程是否也适用于动态分配的对象？这个构造
std::vector<Object *> objects(n);
是否代表此功能？
std::vector <Object*> objects;
for (unsigned int i = 0; i
浏览 0提问于2011-02-04得票数 1
例如，像std::vector<T*>这样的容器会销毁push_back(new T)添加到容器中的所有元素。当你像{ new T1, new T }一样初始化std::pair<T1*, T2*>时，它会做同样的事情吗？
我有这个问题是因为std::pair是一种结构，不像容器那样是类(它没有任何意义，但仍然是)。我找不到任何关于它的信息。
编辑:尽管我认为容器delete了它们动态分配的元素，但这是错误的。
浏览 17提问于2019-11-29得票数 6
回答已采纳
2回答
假设我有一个大小为n的输入，这n个元素被推到一个向量上。
我最近开始学习空间复杂性，但我有点困惑。所以它会查看内存使用情况，但这是动态分配的内存吗？
vector<int> v;
虽然这没有使用"new“关键字，但我读到的向量实际上是在推送时动态分配的，所以这是否意味着空间复杂度将简单地为O(n)？
浏览 0提问于2013-12-06得票数 1
如果我使用std::vector<>或std::string，是否也需要在堆中分配它们。例如：
int main() {
std::vector<int>* p = new std::vector<int>();
delete p;
}
在Java和C#中，对象总是使用这种语法在堆中分配。我想知道在C++中做同样的事情是否有效？因为每当我在C++中创建类时，我通常会在堆栈和堆变量之间混合。让我们说：
class simple {
int a;
double b;
std::string c;
std::vect
浏览 2提问于2011-01-04得票数 1
回答已采纳
2回答
我正在开发一个读取WAV文件的类。该类应为每个通道(左/右)生成一个矢量，其中通道矢量位于其自身的矢量中。
我将类中的加载方法定义为：
std::vector<std::vector<double> >* wavloader::load() throw(load_failed)
因此返回一个指向该向量向量的指针。
在类中，我为顶级向量分配了内存，然后为任意数量的通道创建了向量，如下所示：
std::vector<std::vector<double> >* audio_all_chans = new std::vector<std::vec
浏览 0提问于2011-11-21得票数 1
回答已采纳
1回答
向量的内存布局
、、、、
std::vector<T>具有在内存中连续存储其元素的特性。但是std::vector<std::vector<T>>呢？单个std::vector<T>中的元素是连续的，但是向量本身在内存中是连续的吗(即，保存在外部向量中的整个数据将是一个内存块)？这是否意味着，如果我调整一个内部向量的大小，我将不得不复制(或移动)许多对象以保持连续性？那std::array<std::array<T,N>,N>呢？在这里，我假设内存连续性就像T[N][N]一样
浏览 19提问于2021-11-06得票数 1
该文件的格式如下：
word1
word2
word3
..。
在从文件中读取这些单词后，我创建了字符串向量，如下所示：
std::vector<string> words;
string w;
ifstream file("input");
while(getline(file,w))
words.push_back(w);
file.close();
向量占用的物理内存大小是否与输入文件的大小相同？为什么？
浏览 0提问于2018-06-29得票数 2
3回答
对象容器的性能与指针容器性能
、、、、
class C { ... };
std::vector<C> vc;
std::vector<C*> pvc;
std::vector<std::unique_ptr<C>> upvc;
根据C的大小，按值存储的方法或指针存储的方法都将更有效。
是否有可能大致知道这个大小(在32位和64位平台上)？
浏览 0提问于2015-03-09得票数 2
回答已采纳
1回答
假设在函数中定义了std::vector (例如，在堆栈上)，并且重新分配了该向量(例如通过插入数据)。向量的任何部分会在堆中吗？如果是，执行完函数后是否会在堆中留下垃圾？谢谢。
浏览 5提问于2011-03-09得票数 1
回答已采纳
我正在尝试调试一个潜在的内存泄漏。我可以看到在调用mq_timedsend之后没有手动释放msg_ptr。
我的问题是，在将消息发送到队列后，mq_timedsend会释放消息吗？
浏览 1提问于2014-01-03得票数 2
3回答
可能重复：
我知道当一个std::vector被销毁时，它会调用每个项目的析构函数。它是否调用指向对象的指针的析构函数？
vector<myclass*> stuff;
当物品被销毁时，内部指针所指向的单个对象会被破坏吗？
浏览 2提问于2012-02-25得票数 27
下面的分配总是在既没有内存泄漏也没有未初始化甚至未分配的内存的情况下执行的吗？
结果a中的任何单元格都不会具有与结果b中的单元格相同的地址？
不管向量有多少向量，情况是否如此……我们所拥有的向量吗？
vector<vector<double>> a, b;
// Give a and b random contents: empty, rectangular, ragged, etc.
a = b;
浏览 0提问于2018-02-21得票数 1
for(int i =0; i <shapes.size(); i++) // shapes is QList<QWidget*> of QShape
{
shapes.at(i)->setShape(QShape::ellipse);
QGraphicsProxyWidget* proxyWid = graphscene->addWidget(shapes.at(i));
}
view->setScene(graphscene);// view is a QGraphicsView object.
我有上面的代码，我用它在图形视图场景中放置
浏览 5提问于2015-08-31得票数 2
回答已采纳
对于我的矩阵类，我做到了：
template<typename T, std::uint32_t Height, std::uint32_t Width>
class Matrix
{
private:
std::array<std::array<T, Width>, Height> Elements;
static_assert(std::is_arithmetic<T>::value, "Argument T must be of arithmetic type.");
pub
浏览 2提问于2013-06-09得票数 3
回答已采纳
3回答
在我的代码中，我有一个包含整数的向量。使用第一个循环，我创建了100个新的整数，并将它们推送到向量上。然后，下一个循环删除除最后一个以外的所有动态分配的整数，因为删除最后一个整数会导致错误并返回0xc0000005。为什么我的程序在删除最后一个整数后崩溃？
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> list;
cout << list.size() << endl;
int i
浏览 0提问于2013-05-01得票数 2
回答已采纳
1回答
向量迭代器不兼容
、、、
我有一些类，我想要使用大量的向量。
class Bar {
Bar ();
std::vector<Foo> * _grid;
void someFunction ();
}
Bar::Bar () {
_grid = (std::vector<Foo> *)malloc(_gridSize * sizeof(std::vector<Foo>);
memset(_grid, 0, _gridSize * sizeof(std::vector<Foo>);
}
void Bar::someFunction
浏览 1提问于2010-12-08得票数 1
回答已采纳
2回答
如果我有一个像std::vector这样的动态分配类。用该对象的元素创建数组有什么意义？
我测试了以下内容：
std::vector<int> array[2];
array[0].push_back(10);
array[0].push_back(20);
array[0].push_back(30);
array[1].push_back(40);
array[1].push_back(50);
array[1].push_back(60);
for (auto x : array[0]) {
std::cout << x << std:
浏览 2提问于2020-10-01得票数 1
回答已采纳
3回答
动态分配包含向量的结构
、、、、
如果我有一个动态分配的结构，其中有一个向量，那么这个向量什么时候会超出作用域？是否在删除结构时调用向量析构函数，或者是否需要在删除结构之前强制执行析构函数调用？
浏览 0提问于2011-11-10得票数 0
2回答
例如，我有两个类A和B。B是从A派生出来的。
class A {};
class B : public A {};
我有一个A唯一指针的向量，我可以向后推一个指向该向量的唯一指针。
vector<unique_ptr<A>> vA;
unique_ptr<A> a(new A);
vA.push_back(std::move(a));
(1)如何回推B的唯一指针
vector<unique_ptr<A>> vA;
unique_ptr<B> b(new B);
vA.push_back(std::move(b)); //?
浏览 1提问于2013-09-30得票数 0
回答已采纳
4回答
我知道std::vector<T>在内部连续地存储数据(除非是std::vector<bool>)，无论是旧的C++03标准还是新的C++11。
处理这个问题并引用标准：，的问题非常好。
嵌套向量std::vector <std::vector <T> >中的数据如何？那是怎么储存的？
如果每个内部向量都需要连续地存储它的数据，那么&v[n] == &v[0] + n for all 0 <= n < v.size()怎么可能是真的。
要说这一点略有不同，是否有可能“简单地”和顺序地(通过指针或类似的)访问存储在这种嵌
浏览 3提问于2012-06-05得票数 31
回答已采纳
可能重复：
我对STL相当陌生，而且我已经读到，通常保留对象的向量而不是指向对象的指针的向量是很好的做法。为了遵守这一信条，我遇到了以下情况：
//Approach A
//dynamically allocates mem for DD_DungeonRoom object, returns a pointer to the block.
//then, presumably, copy-constructs the de-referenced DD_DungeonRoom as a
//disparate DD_DungeonRoom object to be stored a
浏览 7提问于2013-01-09得票数 2
回答已采纳
2回答
因此，我有一个向量向量，它是堆分配的：
std::vector<std::vector<int>>* matrix = new std::vector<std::vector<int>>();
在将大量数据放入matrix之后。删除这个对象的正确方法是什么？
delete matrix是否释放所有内部向量？
浏览 4提问于2016-07-17得票数 2
回答已采纳
1回答
以下是关于家庭作业的内容。克制宠物项目类型的东西，任务就是更新它使用向量。我遇到的问题是:这会导致核心分段错误，但当我使用valgrind时，仍然能够适当地检索所有信息。
void Table::partyCheckout(void)
{
if(status == SERVED)
{
cout << " ---------------- " << endl;
cout <<"Table: " << tableId <
浏览 0提问于2012-11-29得票数 0
回答已采纳
对于如何对通过向量构造的对象调用析构函数，我有点困惑，但只有在使用指针创建对象时才调用一次。
#include <iostream>
#include <vector>
#include <string>
class Student
{
std::string first;
std::string last;
int age;
public:
Student();
Student(std::string f, std::string l, int a) : first(f), last(l), age(a)
浏览 4提问于2015-05-28得票数 4
回答已采纳
5回答
向量上删除的传播
、、
如果我delete一个指针向量，delete会在其中的指针上调用吗？例如：
vector<Obj *> v = new vector<Obj *>();
v.push_back(new Obj());
delete v;
在此之后，Obj是否也会被删除？
浏览 0提问于2012-12-06得票数 1
我正在测试向后推对象、与向后推对象指针、到C++中的向量之间的性能差异。
我在Stackoverflow和其他文章中读到过，除非您必须这样做，否则您应该避免向后推指针。
然而，我意识到回击指针有很大的性能提高，
这是我运行的一个简单测试：
tstart = chrono::system_clock::now();
vector<MyObject> VectorOfObjects;
for (int i=0; i<10000; i++) {
MyObject x("test");
VectorOfObjects.push_back(x);
}
浏览 1提问于2014-07-22得票数 2
回答已采纳
3回答
填充指针向量
、、
请原谅我的努比问题..
我有：
class A;
{
public:
A(int i) : m_i(i) {}
int m_i;
}
A newA(i);
{
return A(i);
}
我想填充下面的向量，但使用一个循环，其中对象A是用一个函数(NewA)创建的：
vector<A*> list;
for (int i=0 ; i<3; ++i) { A a = newA(i); list.push_back(&a); }
如果我使用vector<A>而不是vector<A*>，这是可行的，因为我所做
浏览 0提问于2013-04-17得票数 0
回答已采纳
2回答
这是而不是关于将std::auto_ptr放入std：：std：：auto_ptr的问题。
在std::auto_ptr、std::、std::tr1::或boost::中是否存在与之等价的向量？我在函数参数中使用std::auto_ptr，并返回值来降低这些函数的所有权语义。但这样我只能传递单个对象。作为向量的临时解决方案，我有以下几点：
std::auto_ptr<std::vector<std::tr1::shared_ptr<ClassExample> > > fx(....);
我想，通过引入boost，我将能够转变为：
std::auto_ptr
浏览 3提问于2011-08-18得票数 3
回答已采纳
我想问关于这个代码的两个问题。我只是试着模拟一个堆栈。
Stack.h
#pragma once
namespace stackandqueue {
class Stack
{
private:
int index;
int *stackdata;
public:
Stack();
~Stack();
void push(int val);
int pop();
int top();
bool isEmpty(
浏览 0提问于2019-03-05得票数 3
回答已采纳
2回答
背景：，我想实现一个三维碰撞检测算法，并希望将搜索空间分割成多维数据集，这样我只在对象足够接近时才检查冲突。
实际问题：，我正在考虑使用一个向量数组来存储指向我将要迭代的对象的指针。例如，方框将是一个向量，在模拟空间的一个角落中保存指向对象的指针。不管这是否是最佳解决方案，我都想知道c++是如何处理向量数组的。数组会保存指向向量的指针，以便它们随后的重新分配不会影响数组的有效性，还是会在数组内创建向量，然后移出，从而导致未定义的行为？
类似的问题没有针对这一实现细节的具体答案。如果这件事真的在别的地方被回答了，我很抱歉，我错过了。
浏览 5提问于2015-03-20得票数 2
回答已采纳
2回答
考虑一下存在一些std::vector<ClassA>的情况，然后另一个类的对象包含指向该向量元素的指针，例如：
ClassB Object(&ClassA[12]);
这是一个雷场，万一矢量被调整大小，等等？我应该换个std::vector<ClassA *>吗？
浏览 4提问于2014-03-03得票数 1
回答已采纳
1回答
链接列表在当今世界的真正使用
、、、、
我花了很多时间反复讨论是否应该使用向量还是链表。我一直在阅读关于这个主题的许多完全自相矛盾的观点，所以我想要一个基于今天的硬件在真实的世界中的一个严格的答案。
因此，我被告知，如果您在序列中间执行大量插入和删除操作，那么链接列表将是理想的，其复杂性为O(1) (这本身我并不完全理解，因为您必须一直遍历到想要的位置)，而插入到向量显然非常缓慢，而且复杂性为O(n)。
另一方面，在观看了Bjarne 的演讲后，似乎没有真正的使用链接列表，而使用链接列表，因为会有大量的插入和删除，实际上只能由一个天真的学生来实现。我从中得到的是，从本质上说，根据链接列表的遍历特性，它在遍历内存中的不同位置时执行了几
浏览 1提问于2014-11-11得票数 1
回答已采纳
2回答
我编写了一个类vector，其成员是一个动态分配的数组。
template <typename T> struct vector{
T* elem;int capacity;
/*
*capacity is the size of array, not number of elements in the array .
*the default capacity is 3.
*/
vector(int c=3,T e=0){ /* initializing all elements as e */
T* el
浏览 4提问于2021-11-01得票数 0
回答已采纳
2回答
我有一个“Pictureframe”的向量(pflist)，我想把它们都销毁掉。所以我运行了pflist.clear()；文档说这会运行向量中每一项的析构函数，但事实并非如此！
我有一个：
vector<Pictureframe*> pflist;
下面是剩下的内容：
class Pictureframe{
scene::IMeshSceneNode *picture;
scene::IMeshSceneNode *frame;
public:
Pictureframe();
~Pictureframe();
};
然后在cpp文件中：
Pictu
浏览 0提问于2012-05-22得票数 2
回答已采纳
错误C2661：'Stock::Stock‘：no重载函数接受2个参数
我使用VisualStudio2012FYI，每次尝试用类的对象填充向量时都会得到一个C2661错误：
void AFTS::createSys() {
AFTS::fs.assign(100, new Stock());
// the error occurs when calling the assign() function
}
下面是保存向量的类：
class AFTS {
public:
std::vector<Stock> fs;
void createSy
浏览 5提问于2015-08-07得票数 0
回答已采纳
2回答
我需要一个可以存储从B继承的类( A )的向量。向量位于一个管理应用程序所有流并包含向量Test的类中。
A类
class A {
public:
virtual void test() {
cout << "Class A" << endl;
}
};
B类
class B : public A {
public:
virtual void test() {
cout << "Class B" << endl;
}
};
测试类
class Test
浏览 6提问于2013-12-30得票数 0
回答已采纳
我想问，有这样的变体安全吗？
struct A
{
unique_ptr<T> anything;
};
struct B
{
int x = 0;
int y = 0;
};
variant<A, B> myVar;
myVar = ... A object;
myVar = ... B object;
myVar = ... another A object;
会对所有编译器调用std::unique_ptr析构函数吗？其想法是创建一个std::array of variant<A, B>，以便在FIFO中使用它。在Visual
浏览 4提问于2022-01-20得票数 4
回答已采纳
1回答
我们目前在发送到GCS之前对对象进行加密，但是考虑将加密卸载到GCS，尽管我们将继续管理密钥，即。除了密钥之外，我们是否可以管理初始化向量并将其发送到API中？
Nothing用于初始化向量。
浏览 8提问于2022-10-31得票数 0
回答已采纳
2回答
我正在尝试打印存储在包含类实例的向量中的项，例如：
vector<Tree *> vec_;
我知道为了将一个项目插入到向量中，我可以动态地分配内存来将一个Tree对象插入到向量中，例如：
方法1：
Tree * obj = new Tree();
vec_.push_back(obj);
方法二：
vec_.push_back(new Tree());
首先，我想知道如何删除方法2的动态分配的内存，因为我知道对于方法1，我会这样做：
delete obj;
最后，我在打印向量中的项目时遇到了问题，我得到了一个错误，指出二进制表达式有无效的操作数(我不确定这是什么意思)，这是我尝试
浏览 0提问于2016-04-07得票数 1
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
