C++ 为什么要用c++；矢量？

代码

vector myVector动态分配内存，因此存储的任何元素都将一直存在，直到调用delete。下面是怎样的，
vector*myVector=newvector（），与前面的代码不同（不是指针）

这里有双重分配吗？
每个人都提到将
向量
与
新的
调用混合在一起是邪恶的，但为什么呢？
如果它是邪恶的，为什么编译器可以接受它，什么时候可以使用它

这里有双重分配吗

这取决于你所说的“双重分配”是什么意思

您正在使用动态内存分配为
std:：vector
分配内存。
std:：vector
的构造函数对
std:：vector
的元素执行相同的操作。如果这就是你所说的“双重分配”，那么答案是“是”

每个人都提到将向量与新调用混合在一起是邪恶的，但为什么呢

使用

vector<someType> *myVector = new vector<someType>();

vector*myVector=newvector（）；

意味着您负责管理
myVector
的动态分配内存。这带来了一些陷阱：

newvector（）
可以抛出
std:：bad\u alloc
。您必须添加代码来处理异常。如果不这样做，您将终止您的应用程序

您必须确保释放内存。如果不这样做，则程序会泄漏内存

您必须确保在释放内存后不使用指针

这些并不完全是邪恶的，但您在应用程序代码中添加的工作超出了必要的范围

如果它是邪恶的，为什么编译器可以接受它，什么时候可以使用它

如果您的应用程序管理某些核心组件中的低级数据的原因对您有意义，那么可以使用动态分配的
std:：vector
。我认为将这样的代码散布在代码库中是不可接受的。这显然是我的意见。YMMV

这里有双重分配吗

这取决于你所说的“双重分配”是什么意思

您正在使用动态内存分配为
std:：vector
分配内存。
std:：vector
的构造函数对
std:：vector
的元素执行相同的操作。如果这就是你所说的“双重分配”，那么答案是“是”

每个人都提到将向量与新调用混合在一起是邪恶的，但为什么呢

使用

vector<someType> *myVector = new vector<someType>();

vector*myVector=newvector（）；

意味着您负责管理
myVector
的动态分配内存。这带来了一些陷阱：

newvector（）
可以抛出
std:：bad\u alloc
。您必须添加代码来处理异常。如果不这样做，您将终止您的应用程序

您必须确保释放内存。如果不这样做，则程序会泄漏内存

您必须确保在释放内存后不使用指针

这些并不完全是邪恶的，但您在应用程序代码中添加的工作超出了必要的范围

如果它是邪恶的，为什么编译器可以接受它，什么时候可以使用它

如果您的应用程序管理某些核心组件中的低级数据的原因对您有意义，那么可以使用动态分配的
std:：vector
。我认为将这样的代码散布在代码库中是不可接受的。这显然是我的意见。YMMV

代码
vector myVector动态分配内存，因此存储的任何元素都将一直存在，直到调用delete

否。当此对象不再可用时，此内存将被删除

考虑以下几点：

{
    // Allocate a vector of 4 ints
    vector<int> v(4);

    // Do a lot of operations on this vector

}

此范围结束后，
v
对象不会被删除，直到您显式调用
delete v

为了比指针更好地使对象脱离范围，可以使用
共享ptr
、
唯一ptr
和
弱ptr
，这样可以防止您忘记使用
删除

代码
vector myVector动态分配内存，因此存储的任何元素都将一直存在，直到调用delete

否。当此对象不再可用时，此内存将被删除

考虑以下几点：

{
    // Allocate a vector of 4 ints
    vector<int> v(4);

    // Do a lot of operations on this vector

}

此范围结束后，
v
对象不会被删除，直到您显式调用
delete v

为了比指针更好地使对象脱离范围，可以使用
shared\u ptr
、
unique\u ptr
和
weak\u ptr
，这样可以防止您忘记使用
delete
您的第一条语句不正确。
vector myVector
中的元素将一直存在，直到向量被销毁。如果
vector
是一个局部变量，它将在超出范围时自动销毁。您不需要显式调用delete。如果您考虑到由于可能引发的异常，您的
delete
语句可能永远无法到达，从而导致内存泄漏，那么显式调用
delete
很容易出错。
例如，比较以下两种情况

void foo()
{
   std::vector<int> v;
   v.push_back(1);
   f(); // f is some operation that might throw exception.
}  // v is automatically destroyed even if f throws.

void bar()
{
   std::vector<int>* v = new std::vector<int>;
   v->push_back(1);
   f(); // f is some operation that might throw exception.
   delete v;  // You need to call delete explicitly here.
              // The vector will be destroyed only if f doesn't throw.
}

void foo（）
{
std：：向量v；
v、 推回（1）；
f（）；//f是可能引发异常的某个操作。
}//即使f抛出，v也会自动销毁。
空条（）
{
std:：vector*v=新的std:：vector；
v->推回（1）；
f（）；//f是可能引发异常的某个操作。
delete v；//您需要在此处显式调用delete。
//只有当f不抛出时，向量才会被销毁。
}

除上述情况外，向量确实会动态分配内存