属于向量的对象的指针会发生什么？
向量是一种数据结构，用于存储和操作一系列相同类型的元素。在C++中，向量可以通过指针来访问和操作其中的元素。
当向量中的对象被删除或移动时，指向这些对象的指针可能会发生无效化。这是因为向量在内存中是连续存储的，当删除或插入元素时，向量可能需要重新分配内存空间，并将元素移动到新的位置。这样一来，之前指向旧位置的指针就会变得无效。
为了避免指针无效化的问题，可以采取以下几种方法：
- 使用智能指针：智能指针是一种自动管理内存的指针，它会在对象不再被使用时自动释放内存。使用智能指针可以避免手动释放内存和悬空指针的问题。
- 使用索引而非指针：可以通过使用向量的索引来访问和操作对象，而不是使用指针。索引是相对稳定的，不会因为向量的重新分配而发生变化。
- 使用迭代器：迭代器是一种用于遍历容器中元素的对象，它可以提供对容器中元素的访问和操作。使用迭代器可以避免直接使用指针，从而减少指针无效化的风险。
总结起来，向量中对象的指针可能会在删除或移动元素时发生无效化。为了避免这个问题，可以使用智能指针、索引或迭代器来代替直接使用指针。这样可以提高代码的健壮性和可维护性。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云CVM（云服务器）：https://cloud.tencent.com/product/cvm
- 腾讯云CDB（云数据库MySQL版）：https://cloud.tencent.com/product/cdb_mysql
- 腾讯云COS（对象存储）：https://cloud.tencent.com/product/cos
- 腾讯云VPC（私有网络）：https://cloud.tencent.com/product/vpc
- 腾讯云CDN（内容分发网络）：https://cloud.tencent.com/product/cdn
相关·内容
我有一个A级被宣布为：
class A {
public:
vector<int> vec;
};
运行以下代码：
const A *a = new A();
sort(a->vec.begin(), a->vec.end());
给我一个错误：
algorithm: No matching call to swap()
在Xcode中。
知道为什么会发生这种事吗？
浏览 3提问于2015-10-18得票数 0
回答已采纳
2回答
指针将失效，从而导致访问冲突。
、、、、
开发环境为VS2010，语言为混合C# (GUI)和C++ (Sim Engine)，为32位Windows编译.这些异常发生在我们测试过的每个版本的Windows上，包括32位XP、32位Vista、32位7和64位7。
我对这件事完全不知所措。由于程序的性质(基于事件的模拟)，指针在某个未知的时间点失效，然后我们才真正尝试访问它并获得AVE。
我所知道的是，它正以一种非常特殊的方式失效，我希望外面的人能对造成这种情况的原因有一个想法。当发生AVE时，它试图使用的指针已更改为：
(original) - ((size * 2) - 1)
其中original是指针指向的原始地址，size
浏览 7提问于2012-01-26得票数 2
我有一个问题：
class B : public class A {
public:
vector<int*> vec;
};
class A {
};
vector<A*> vec_a;
vector<B*> vec_b;
如果我把一个类为B的对象推回到两个向量中。
B* b = new B;
vec_a.push_back(b);
vec_b.push_back(b);
然后，我在B类的对象中更改了一些东西，
例如：
int* i = ....
vec_b[0].push_back(i);
vec_a会发生变化吗？
我对此感到困惑，因为我检查
浏览 0提问于2012-08-23得票数 2
回答已采纳
2回答
在我的实际应用程序中，我使用一个双连接的边缘列表来存储一个平面的子部分，但是我尝试减少代码来显示我的问题。
我有一个包含自定义结构的列表，需要将其转换为指向存储在列表中的对象的指针向量。当我这样做时，在发生转换的函数中，向量中的指针与指向列表中对象的指针相同，但在函数外部(当我在变量中存储返回值时)指针发生了变化。为什么会发生这种事？它与移动/复制值有关吗？出什么问题了？
谢谢你的帮助！
struct MyStruct
{
MyStruct* my_other_struct;
}
static std::vector<MyStruct*> structPointers(
浏览 4提问于2020-06-26得票数 0
回答已采纳
2回答
"this“指针和容器
、、、
在我的游戏中，我建立了一个小框架，其中包括：
拥有组件的实体。
保存指向实体的指针的系统。
拥有系统的发动机。
拥有实体的EntityManager。
每次我添加组件时，实体都会通过它持有的引擎指针将它的"this“指针传递给系统，然后由它们决定是注册还是忽略它。
现在，由于实体是EntityManager容器的元素，我是否正确地假设，如果对它的insert操作导致转移或重新分配，系统将不再保存有效的指针？
如果是这样的话，有什么好的容器可以用来防止这种情况发生呢？如果我正确地理解了事情，这类似于迭代器发生的情况，当要求插入无效时，同样的规则应该适用。
浏览 1提问于2014-05-10得票数 0
回答已采纳
4回答
在将向量的引用作为参数传递时，我遇到了一些困难。最初它是一个指向指针向量的指针，被调用的函数将改变其被调用的任何值的属性。例如，我使用：
(*myVector)[i]->myFunction();
一切都运行得很完美。无论哪个对象是myVector的当前索引，myFunction()都会进行转换。
现在我已经更改了向量，以保存一组对象，而不是像最初那样指向对象的指针。我没有传递指向向量的指针，而是传递了它的引用。我按如下方式访问该函数：
myVector[i].myFunction();
它编译后，我发现myFunction()不再具有与以前相同的结果。我使用了一个断点，并看到它正在更改
浏览 2提问于2011-06-20得票数 3
回答已采纳
1回答
指向向量的共享指针
、、、
请原谅这个简单的问题，但是我很难理解集合的指针。
假设我有一个字节向量：
vector<uint8_t> n;
我想把它存储在一个共享指针中。为什么我需要接线员的地址？
shared_ptr<vector<uint8_t>> m(&n);
我认为构造函数将采用n。但我也认为我对这里发生的事情有一个深刻的误解:)
浏览 3提问于2014-02-25得票数 1
回答已采纳
3回答
简单的问题，我希望..。
我有一个元素向量。这些元素属于我自己的类类型。我维护一个指向该向量的特定成员的指针。
问题是：如果我从向量中移除元素，指针会发生什么变化？
子-问题
在迭代向量时，是否有任何方法可以检查迭代器是否指向当前有指针的元素？vIterator == pElement会这么做吗？
是否有任何方法从向量中删除元素，而只使用指向该元素的指针？如果上一个问题的答案是肯定的，那么我想我可以用一个循环来完成它。
提前感谢！
浏览 3提问于2014-05-16得票数 2
回答已采纳
4回答
我基本上有一个
vector<Object> vec_;
作为cpp类中的类成员。在某个类函数中，这个向量将被“对象”填充，就像这样：
vec_.push_back(Object());
稍后，我将遍历向量元素，并保留指向最佳元素的指针。然后清除该向量，如下所示：
Object* o_ptr = &(vec_[0]);
for (unsigned int i = 1; i < vec_.size(); i++) {
if (o_ptr->getCost() > vec_[i].getCost()) {
o_ptr = &(vec_[i]
浏览 3提问于2012-10-16得票数 0
回答已采纳
来自C#世界的我很难确保我没有在分配给我的C++项目中引入内存泄漏和错误。我正在编写使用structs解析数据缓冲区中的信息的代码。由于缓冲区中出现的数据结构的数量在运行时可能有所不同，所以使用stl向量来存储处理过的数据。我在现有的软件中遇到了以下代码块，并且很难理解它为什么工作：
MyVectorOfObjects.clear();
for (unsigned __int8 i = 0; i < NumberOfObjects; i++)
{
MyParserObject parserObject; // Declaring without &#
浏览 1提问于2011-08-24得票数 8
回答已采纳
我不知道该怎么做--请告诉我下面的代码有什么问题。我修改了我的代码，将其简化为最简单的术语。有一个包含大量MyNode对象的std：：向量。第一步是获取对其中一个节点(数据m_data)的一个数据元素的常量引用-在下面的示例中，在插入第二个节点之前只有一个节点，如下所示：
const cv::Data& currData = m_nodesVector[currIndex].GetData();
MyNode node(...);
m_nodesVector.push_back(node);
在精确的vector::push_back调用中，currData的值会发生变化！！我只是不明
浏览 6提问于2013-10-25得票数 7
回答已采纳
3回答
我使用了一个指针向量和C++中附带的迭代器。我最初编写它的方式会导致seg错误，但通过一个看似微不足道的更改，声明并初始化一个未使用的变量，seg错误就消失了。有人知道为什么吗？
下面是seg错误的代码。成功执行的最后一行是第8行(通过printf语句找到)和取消逗号的第4行，它们获得了segfault的rids：
1 Intersect RayTracer::closestShape(Ray r){
2 vector<Shape *>::iterator itStart = scene.getShapes().begin();
3 vector<Shape *&
浏览 0提问于2012-11-16得票数 1
回答已采纳
我有一个自定义对象向量。
vector<MyObject*> newOnes;
在进行了一些填充操作之后，newOnes可能有重复的对象，所以我使用std:unique()。
std::unique(newOnes.begin(), newOnes.end(), isEquivalent); //isEquivalent return true if equal
现在，在我使用完向量之后，我继续使用下面的函数释放内存
void MyCalss::releaseSource(vector<MyObject*> v) {
for (unsigned int i =
浏览 5提问于2013-04-13得票数 2
回答已采纳
3回答
当您有指向堆栈上的对象的非静态成员函数的指针时，当对象因为移动而更改其位置时会发生什么？指针是否仍然指向移出对象的位置，因此无效/悬空？
浏览 4提问于2020-08-12得票数 2
回答已采纳
2回答
通过使用构造函数填充向量值，我遇到了一些“奇怪的行为”。
因此，每当调用构造函数时，我就有一个块类来填充这个名为blockList的静态向量。
static std::vector<Block*> blockList;
Block::Block(float x, float y)
: RectangleShape(sf::Vector2f(WIDTH, HEIGHT)) {
blockList.push_back(this);
setFillColor(sf::Color(221, 221, 221, 255));
setPosition(x, y
浏览 5提问于2016-07-19得票数 3
回答已采纳
4回答
C++管理对象
、、、
我有个游戏服务器。它会创建多个Game实例并添加它们(或指向它们的指针)。还有什么更好的？它有10个ints和5个其他指针，10个成员函数)到向量。在此之后，游戏中发生了一些事件，比如game_ends。就在此时，游戏应该从矢量中删除.实现这一目标的最佳途径是什么？
我们得出的两种方法是：
创建一个观察者模式。服务器将是一个观察者，游戏将分派一个事件来删除它。
将游戏设置为ended状态，而服务器不断扫描向量并删除处于ended状态的游戏。
浏览 4提问于2012-08-23得票数 4
回答已采纳
6回答
指针向量中的c++垃圾值
、、、、
当我这么做时：
for(i=0; i<size; i++){
//create objectA here
vectorA.push_back(objectA);
pvectorA.push_back(&vectorA[i]);
}
pvectorA的一些元素是垃圾。然而，当我这样做时：
for(i=0; i<size; i++){
//create objectA here
vectorA.push_back(objectA);
}
for(i=0; i<size; i++){
pvectorA.push_back(&
浏览 9提问于2015-10-27得票数 1
回答已采纳
2回答
访问结构的向量
、、、
我有一个结构体：
struct OutputStore
{
int myINT;
string mySTRING;
}
如果我创建一个OutputStore类型的数组，如下所示：
OutputStore *OutputFileData = new OutputStore[100];
然后，我可以使用以下命令来处理它：
OutputFileData[5].myINT = 27;
但是如果我使用向量而不是数组：
vector<OutputStore> *OutputFileData = new vector<OutputStore>(100);
然后我得到
浏览 0提问于2009-07-22得票数 3
回答已采纳
3回答
指针声明向量
、、、
看着我的教授给我的一些代码，我不明白发生了什么。我对编程很陌生，完全迷失了方向。
vector <_Account*>*myvector = nullptr;
所以我知道他做了一个向量，我知道有一个名为Account的现有类，这是指向Account对象的指针的vector吗？我不知道第二个星号是干什么的？
浏览 3提问于2015-09-29得票数 0
回答已采纳
6回答
关于C++指针
、、
我很好奇在这种情况下数据是如何处理的：
chapterlist.clear();
cScene newscene;
newscene.name = "Laura does something.";
newscene.words = 432;
newscene.pov = "Laura";
cChapter newchapter;
newchapter.scenelist.push_back(newscene);
chapterlist.push_back(newchapter);
chapterlist是一个cChapter向量。
我正在创建一个新的cScene
浏览 0提问于2010-09-06得票数 1
回答已采纳
所以我正在读关于复制控制和三的规则，似乎他们给出的为什么它们是必要的主要例子是当使用指针作为类成员时。它说明，如果将指针从一个对象复制到另一个对象，那么该类的多个对象将指向相同的内存。为什么这很糟糕？难道我们不希望我们所指向的对象指向相同的东西吗？当指针在类之间复制时，究竟会发生什么？我不确定在使用复制构造函数来处理指针时，我们到底应该做什么。
浏览 0提问于2013-11-17得票数 0
我正在编写一个具有成员函数的类，这些成员函数接受一些输入文件并生成一个请求流，这些请求流存储在一个类成员中。
但是，一旦测试结束，当执行默认析构函数时，我就会得到一个读访问冲突。我想不出是什么原因。
这是描述这个类的.hpp文件，有人能指出这里的基础知识中的任何缺陷吗？
#include <iostream>
#include <fstream>
#include <vector>
#include <memory>
#include <string>
#include <sstream>
#include <map
浏览 0提问于2016-05-03得票数 1
我有一个指针向量，如下所示：
std::vector<foo*> stuff;
我用一个new foo();初始化每个元素
我的问题是，当我重新分配一个向量的元素时，会发生什么
stuff[3] = new foo();
我是不是内存泄露了，我应该在这之前调用delete[]吗？在这种情况下，我应该使用智能指针吗？(到目前为止还没有)
通常我不会使用new，但我正在学习Qt，示例中看起来就是这样做的。Qt似乎有自己的智能指针；我应该使用其中之一吗？
谢谢。
浏览 0提问于2013-05-12得票数 1
回答已采纳
我是从C#背景到C++的。假设我有一个在堆栈上的方法中创建对象的方法，然后将它传递给另一个类方法，后者将它添加到memeber向量中。
void DoStuff()
{
SimpleObj so = SimpleObj("Data", 4);
memobj.Add(so);
}
//In memobj
void Add(SimpleObj& so)
{
memVec.push_back(so); //boost::ptr_vector object
}
以下是我的问题：
一旦DoStuff方法结束，so会走出范围并从堆栈中弹出吗？
me
浏览 2提问于2010-09-21得票数 6
回答已采纳
我正在尝试创建一个std::vector<SystemBase>类成员，该成员存储所有从SystemBase派生的多个系统。但是，该类具有引用，因此没有合理的默认构造函数：
class SystemBase {
public:
SystemBase() = delete;
explicit SystemBase(entt::registry &Registry) : Registry{Registry} {}
virtual ~SystemBase() = default;
SystemBase(const SystemBase &) = dele
浏览 0提问于2021-04-09得票数 0
回答已采纳
据我所知，这两种向量声明如下：
//TYPE 1
std::vector<cls> vec; //cls is user defined datatype(A class)
向量的内存在堆栈上分配，向量中的内容内存在堆上分配。
以下声明也是正确的(如果我错了，请纠正我)：
//TYPE 2
std::vector<cls*> vec; //cls is user defined datatype(A class)
现在，当类型1中的向量超出作用域时，内存将被释放给存储在其中的对象。
但是，如果我按下面的方式插入元素(假设我有正确的重载构造函数)，然后向量超
浏览 0提问于2013-07-29得票数 11
回答已采纳
当向量需要更多内存时，它会将内存重新分配到某个地方，我还不知道在哪里！然后指针变得无效，对此有什么好的解释吗？
我的意思是，它们去了哪里，我的容器会发生什么？(不是链表)
浏览 0提问于2011-11-25得票数 11
回答已采纳
我知道许多关于避免堆碎片的文章。我的问题是，具体而言，当我们使用向量存储数据时会发生什么：
class foo{
public:
std::vector<bar>; // Or I can have std::vector<bar*>
};
我没有问题使用新的或删除(我没有内存泄漏，这是非常清楚，当一个酒吧不使用，我可以调用删除在必要时)。但是对于堆碎片，哪一个更好？这会使堆栈溢出的可能性更大吗？
编辑:我实际上没有任何新的信息要添加。我只想感谢每个人，并说我发现，任何一个问题的标签，似乎吸引了这么多知识丰富，乐于助人的人。真的很不错。谢谢。
浏览 7提问于2014-07-10得票数 1
回答已采纳
4回答
我有一个像std::vector<AnyObject*> myVector;这样的向量，我想删除向量中的一个元素，而不改变其他元素的位置。我该怎么做？我有两个解决方案，告诉我它们是否好：
AnyObject* initial;
std::vector<AnyObject*> myVector(10, initial);
AnyObject* object = myVector.at(4);
delete object;
或
AnyObject* initial;
std::vector<AnyObject*> myVector(10, initial);
d
浏览 7提问于2017-03-08得票数 0
回答已采纳
只是想知道在C++中关于向量的最佳实践是什么。
如果我有一个包含向量成员变量的类。何时应宣布该向量为：
“整体对象”向量成员变量包含值，即vector<MyClass> my_vector;
指向向量的指针，即vector<MyClass>* my_vector;
指针向量，即vector<MyClass*> my_vector;
指向指针向量的指针，即vector<MyClass*>* my_vector;
在我的一个类中，我有一个特定的例子，在其中一个类中，我将向量声明为案例4，即vector<AnotherCl
浏览 3提问于2011-04-13得票数 12
2回答
( a)指出向量元素的地址安全吗？
unsigned int* ptr;
std::vector<unsigned int> vec;
vec.resize(10);
vec[0] = 10;
ptr = &vec[0];
在我看来，只要我不改变预分配向量的大小，&vec的地址就不会改变。我的问题是，如果指向向量元素是安全的，只要它是预先分配的。
( b)如果我不预先分配vec的大小，那么&vec的地址似乎会发生变化。如果我通过vec.push_back()将附加值推送到向量中。我想要一个指向索引向量的指针向量。
std::vector<unsigne
浏览 5提问于2014-05-21得票数 1
回答已采纳
6回答
在C++中，如果您在堆栈上(在函数中)创建一个对象，并将其插入堆分配的容器(该容器已传递到函数中/在函数完成后存在)，会发生什么情况？
堆栈对象具有局部作用域，但是它所插入的容器在堆上，并且可以在函数(进行插入的位置)返回之后继续存在。在函数返回后，堆栈对象仍然可以从容器中检索吗？
void Test( std::vector<MyClass>& myvec )
{
MyClass m;
myvec.push_back(m);
}
浏览 3提问于2013-01-10得票数 1
回答已采纳
这里只是个初学者。
我试图在一个向量中存储一些对象，这样我可以在以后循环它，但是引用在之后发生了变化，我不确定发生了什么
代码如下；
#include <iostream>
#include <vector>
using namespace std;
class Car;
class Garage {
public:
vector<Car*> vCar;
};
class Car {
public:
short id;
};
int main()
{
Garage garage;
sho
浏览 0提问于2013-06-28得票数 0
回答已采纳
3回答
假设我想将int的二维矩阵表示为向量的向量：
std::vector<std::vector<int> > myVec;
内部维度是恒定的，比如5，外部维度小于或等于N。为了最大限度地减少重新分配，我想保留空间：
myVec.reserve(N);
假设内部向量的大小是多少？这是纯依赖于实现的吗？这对数据的空间局部性有什么影响？由于内部维度是常量，有没有办法告诉编译器使用这个常量大小？如果内部向量的大小发生变化，这些答案会发生什么变化？
浏览 0提问于2013-09-25得票数 29
回答已采纳
3回答
我试图弄清楚，如果你创建一个共享指针，指向一个被保存在向量中的对象，会发生什么。
“守则”如下：
class TestObject
{
public:
int someTestData;
};
class Test
{
public:
std::shared_ptr<TestObject> testPointer;
std::shared_ptr<std::vector<TestObject>> getTestVector()
{
return testVector;
}
private:
浏览 0提问于2019-10-18得票数 0
我读过可可内存管理规则，但仍然想要确定，并想知道这是否是好的形式。
我们班有一本易变的字典伊瓦尔：
NSMutableDictionary *m_Dict;
...
m_Dict = [NSMutableDictionary dictionaryWithCapacity:10];
[m_Dict retain];
在某些时候，我将向字典中添加一个可变数组：
NSMutableArray *array = [NSMutableArray arrayWithCapacity:100];
[m_Dict setObject:array forKey: @"myArray"];
此
浏览 1提问于2010-09-01得票数 1
回答已采纳
几个月前我用向量编写了一个程序。我使用clear()成员函数来“重置”向量，假设它不仅会清除元素中的项并重置大小数据成员，而且还会给堆返回以前与它一起使用的内存。嗯，我偶然发现了一篇关于向量的帖子，它说这不是从向量中获取内存的正确方法，因为使用clear()并不能做到这一点，但是需要使用交换方法：
vector<MyClass>().swap(myVector);
我很好奇为什么我们要调用交换来删除旧的记忆？我想这更像是一种解决办法，因为我们使用的是交换，但其他的事情正在发生。正在调用析构函数吗？
最后一个问题，我现在读到的所有文章都说，clear()没有释放那些对象被“销毁”的内
浏览 4提问于2016-08-23得票数 0
回答已采纳
我遇到了这段现有的代码，而且对于C++来说仍然是新的，我不明白为什么将局部变量存储到向量中使它以后仍然可以访问。
下面是简化的代码流，其中BackendCall是前面定义的类：
void SaveBackendCall(BackendCall* backend_call,
vector<BackendCall>* logged_calls) {
logged_calls->push_back(*backend_call);
}
void AddNewCall(vector<BackendCall>* logged_c
浏览 5提问于2014-05-19得票数 2
回答已采纳
4回答
我正在解决的一个问题涉及到一个很大的树结构。最初，我通过对新节点执行new操作并将其附加到其父节点等方式来创建树。这花了很长时间。一位朋友建议我放弃动态内存分配，将树结构化为一个带有子词偏移量的数组。我以前没有这样做过，所以我对实际发生的事情有一些疑问。
这是最基本的，没有任何安全检查的例子：
struct DataStructure
{
std::vector<Entry> mCollection;
};
struct Entry
{
char mValue;
std::vector<unsigned int> mOffsetCollecti
浏览 0提问于2011-04-16得票数 1
回答已采纳
2回答
我有一个问题，如果我有一个STL向量，我可以这样写
std::vector<int> *p;
但是我不能决定我是否会在任何情况下使用它？另外，在这种情况下，如果我调整被指针p指向的向量的大小，那么指针p会发生什么？
我在这里可能听起来很愚蠢，但这些问题只是在脑海中浮现，我能够用g++编译std::vector<int> *p这个东西。
浏览 1提问于2011-12-19得票数 0
我目前正在学习新的c++内容，并且正在学习如何使用智能指针(std::unique_ptr)。
假设我有一个std::vector of std::unique_ptr。在我的代码中，有一次，我需要迭代这个stl向量，并选择我需要计算的对象。
for (const auto& obj : objectList)
{
if(/*check if this is an object I need*/)
OtherFunc(obj.get());
}
void OtherFun(object* obj)
{
std::vector temp
浏览 9提问于2015-11-23得票数 1
回答已采纳
3回答
我有一个全局范围内的myObjects向量。
std::vector<myObject>
向方法传递一个指向向量中某个元素的指针。此方法是否可以递增指针，以获取下一个元素，
myObject* pmObj;
++pmObj; // the next element ??
或者应该向它传递一个std::Vector<myObject>::iterator并递增它？
现在假设向量在此期间不会发生变化。
浏览 0提问于2009-03-16得票数 1
回答已采纳
我正在开发一个应用程序，它将生成一些代码，速度不是问题，但我不希望内存泄漏。
我对来自其他语言的带有垃圾收集器的shared_ptr有点困惑。
如果我正确理解，基本上，如果我在每个指针上使用shared_ptr，它将以类似于垃圾收集器的方式运行，因为当对象不再被引用时，它将重新生成对象。
当我在emplace_back向量中使用shared_ptr时，我很困惑会发生什么。假设我有这样的功能：
void fun(MyObject* o){
std::vector<std::shared_ptr<MyObject>> v;
v.emplace_back(o)
浏览 1提问于2017-11-11得票数 0
回答已采纳
4回答
如果我有课：
Class aClass
{
vector<aClass> connections;
}
如果我要做的话，所有其他的事情都会被正确地宣布：
aClass a = new aClass();
aClass b = new aClass();
b.connections.push_back(a);
这是创建对a的引用，还是复制类。
我希望它是指向类的指针，但我不确定是否需要额外的语法来确保这一点。我记得我读到，当一个类被声明为aClass a = new aClass时，它正在创建一个指向堆中对象的指针，但我不知道这里会发生什么。
作为参考，这是类似链接列表的东
浏览 5提问于2016-06-11得票数 0
回答已采纳
5回答
指针向量与值向量之差
、、、、
我听说在C++中不推荐指针，但我不明白为什么。
我的问题是我想要创建一个类对象的向量来管理我的类。
vector<MyClass> vectorOfClass;
当然，为了获得更好的性能，我应该使用类对象指针的向量吗？
vector<MyClass *> vectorOfClass;
或者，是否可以创建类对象的引用向量？
vector<MyClass &> vectorOfClass;
所以我的问题是：
这两种方式有什么区别？
创建类对象向量的最优方法是什么？
浏览 0提问于2019-11-08得票数 2
3回答
假设我有一个std::vector<Node*> nodes;和一个std::vector<Unit*> units;。每个节点指向一个单元，每个单元指向该节点，因此它们被连接。但是，当我使用擦除从两个数组的中间删除一个元素时会发生什么呢？如果它调整了数组的大小，这是否意味着它会删除所有元素，将它们存储在某个缓冲区中，并重新构建大小调整的数组？所以，如果我在节点上使用擦除，单元中的指针就会失效吗？
浏览 1提问于2012-10-29得票数 0
我目前有一吨的矢量，全部设置为1200个项目，这是过度杀伤力，但可以使用。所以我不需要重新编码很多东西，什么是创建和迭代这些向量列表并根据需要调整它们大小的最好方法？(它们的大小相同) 我的一个选择是创建一个指向每个向量的指针(在事实之后)，然后创建这些指针的一个向量，可以迭代以调整大小。另一种选择是首先将向量创建为指针而不是对象。这看起来会有很多工作要做，而且我现在有很多使用矢量对象的代码。 还有其他选择吗？ 佛瑞德E。
浏览 18提问于2020-01-31得票数 0
7回答
我不明白为什么当重新分配发生时，vector的迭代器会失效。
难道不能仅仅通过在迭代器中存储偏移量(而不是指针)来防止这种情况吗？
为什么vector不是这样设计的？
浏览 3提问于2012-06-11得票数 15
回答已采纳
4回答
C++中删除操作符的混淆
、、、
这看起来很简单，但我的朋友和我争论说，下面的程序调用UB。但我认为他错了。考虑下列方案：
#include <iostream>
int main()
{
int* p=new int[3]();
int* q=p;
for(int i=0;i<3;i++)
std::cout<<q[i]<<' ';
delete[] q;
std::cout<<'\n';
}
这个程序的行为有明确的定义吗？如果我写的是delete[] p;而不是delete[] q;
浏览 0提问于2015-08-18得票数 1
回答已采纳
2回答
我在做一个控制台游戏，玩家可以射击。播放机按下空格键后，将创建一个新对象，并将其放置在地图上，并且映射包含指向该对象的指针。这些对象存储在向量中。我读了一篇关于向量的文章，它说：
向量与动态数组相同，可以在插入或删除元素时自动调整自身大小。
我以为在我删除一个物体之后，向量会自动缩小，所以每当有一个弹丸撞到墙时，我就会这样做：
delete entities[x + y * width];
entities[x + y * width] = nullptr;
但是矢量的大小并没有改变。我需要手动从向量中删除对象吗？我有一个想法，为存储其状态(死/活)的每一个弹丸创建一个布尔变量，以便在循环的
浏览 1提问于2021-04-09得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
