从C++ STD中删除所有项目::向量

我想你应该用 std::vector::clear 以下内容:

vec.clear();

编辑:

不清除销毁元素 被矢量控制?

是的,的确如此。它在返回内存之前调用向量中每个元素的析构函数。这取决于存储在向量中的“元素”。在下面的示例中,我将在向量中存储对象本身:

class myclass
{
public:
    ~myclass()
    {

    }
...
};

std::vector<myclass> myvector;
...
myvector.clear(); // calling clear will do the following:
// 1) invoke the deconstrutor for every myclass
// 2) size == 0 (the vector contained the actual objects).

例如,如果要在不同容器之间共享对象,可以存储指向它们的指针。在这种情况下,当 clear 调用时,只释放指针内存,不接触实际对象:

std::vector<myclass*> myvector;
...
myvector.clear(); // calling clear will do:
// 1) ---------------
// 2) size == 0 (the vector contained "pointers" not the actual objects).

对于评论中的问题,我认为 getVector() 定义如下:

std::vector<myclass> getVector();

也许您想返回一个引用:

// vector.getVector().clear() clears m_vector in this case
std::vector<myclass>& getVector(); 

vector.clear() 应该为你工作。如果你想缩小 vector 然后清除

std::vector<T>(v).swap(v);

vector.clear()实际上与vector.erase(vector.begin(),vector.end())相同。

如果你的问题是打电话 delete 对于每一个 指针 包含在向量中,请尝试以下操作:

#include <algorithm>

template< typename T >
struct delete_pointer_element
{
    void operator()( T element ) const
    {
        delete element;
    }
};

// ...
std::for_each( vector.begin(), vector.end(), delete_pointer_element );

标准免责声明:代码在浏览器中编写,未经测试。

使用 v.clear() 清空向量。

如果向量包含指针,则clear调用对象的析构函数,但不删除指针引用的内存。

vector<SomeClass*> v(0);

v.push_back( new SomeClass("one") );

v.clear();  //Memory leak where "one" instance of SomeClass is lost

是 v.clear() 为什么不工作?

如果您将指针保存在容器中,并且不想手动销毁指针,则使用 boost shared_ptr .这里是std::vector的示例,但您可以将其用于任何其他STL容器(set、map、queue…)。

#include <iostream>
#include <vector>
#include <boost/shared_ptr.hpp>

struct foo
{
    foo( const int i_x ) : d_x( i_x )
    {
        std::cout << "foo::foo " << d_x << std::endl;
    }

    ~foo()
    {
        std::cout << "foo::~foo " << d_x << std::endl;
    }

    int d_x;
};

typedef boost::shared_ptr< foo > smart_foo_t;

int main()
{
    std::vector< smart_foo_t > foos;
    for ( int i = 0; i < 10; ++i )
    {
        smart_foo_t f( new foo( i ) );
        foos.push_back( f );
    }

    foos.clear();

    return 0;
}

增加上述好处 swap(). 那 clear() 不保证释放内存。你可以使用 swap() 如下:

std::vector<T>().swap(myvector);

如果你的向量像这样 std::vector<MyClass*> vecType_pt 您必须显式释放内存,或者如果您的向量看起来像: std::vector<MyClass> vecType_obj ,构造函数将由vector调用。请执行下面给出的示例,并理解不同之处:

  class MyClass
    {
    public:
        MyClass()
        {
            cout<<"MyClass"<<endl;
        }
        ~MyClass()
        {
            cout<<"~MyClass"<<endl;
        }
    };
    int main() 
    {
        typedef std::vector<MyClass*> vecType_ptr;
        typedef std::vector<MyClass> vecType_obj;
        vecType_ptr myVec_ptr;
        vecType_obj myVec_obj;
        MyClass obj;
        for(int i=0;i<5;i++)
        {
            MyClass *ptr=new MyClass();
            myVec_ptr.push_back(ptr);
            myVec_obj.push_back(obj);
        }
        cout<<"\n\n---------------------If pointer stored---------------------"<<endl;
        myVec_ptr.erase (myVec_ptr.begin(),myVec_ptr.end());
        cout<<"\n\n---------------------If object stored---------------------"<<endl;
        myVec_obj.erase (myVec_obj.begin(),myVec_obj.end());
        return 0;
    }

class Class;
std::vector<Class*> vec = some_data;

for (unsigned int i=vec.size(); i>0;) {
    --i;
    delete vec[i];
    vec.pop_back();
}
// Free memory, efficient for large sized vector
vec.shrink_to_fit();

性能:Theta(n)

如果是纯对象(不建议用于大型数据类型,则 VCE.Car();