Question

我有一个包含对象的2D矢量。

std::vector<std::vector<List> >   ListPos;

ListPos.clear();

std::vector<List> initPV;
ListPos.push_back(initPV);

List newList;

//... some code to determine where the object needs to go and vector resized to accommodate ...// 

ListPos[ThisY].insert(ListPos[ThisY].begin()+ThisX, newList);

创建对象并根据需要调整矢量大小，我的问题是我如何遍历向量和delete我不使用的任何对象（给定一些位置数据，如if(![3][7])来释放记忆。

我还可以使用向量来释放对象在被删除后使用的空间吗？

| List | List | List |
-------------------------------
| List | List | Delted | List |
-------------------------------
| Deleted | List |

因此，在上面的表示中，我有一个3行向量，最多有4个cols，因此它表示删除了删除对象位置的位置。

我猜测，一旦从内存中删除了对象，向量中的空间只会是'零'？

我应该注意，如果对象从[2][0]中删除，我需要让其他对象可以使用它，但是如果有意义的话，不能让[2][1]取代它。 [2][1]需要保持[2][1]

我尝试了以下（实际代码）

for (std::vector<std::vector<List*> >::iterator i = Area::AreaControl.ListPos.begin(); i != Area::AreaControl.ListPos.end();++i) 
{
     for (std::vector<List*>::iterator j = i->begin(); j != i->end();++i)
     {
         if(j != Area::AreaControl.ListPos[0][0]) {
             // Delete
         }
     }
 }

但没有骰子:(

    error: conversion from ‘std::vector<List>::iterator {aka __gnu_cxx::__normal_iterator<List*, std::vector<List> >}’ to non-scalar type ‘std::vector<List*>::iterator {aka __gnu_cxx::__normal_iterator<List**, std::vector<List*> >}’ requested
src/Void_OnLoop.cpp:62:73: error: no match for ‘operator!=’ in ‘j != i.__gnu_cxx::__normal_iterator<_Iterator, _Container>::operator-> [with _Iterator = std::vector<List>*, _Container = std::vector<std::vector<List> >, __gnu_cxx::__normal_iterator<_Iterator, _Container>::pointer = std::vector<List>*]()->std::vector<_Tp, _Alloc>::end [with _Tp = List, _Alloc = std::allocator<List>, std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<List*, std::vector<List> >, typename std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type::pointer = List*]()’
src/Void_OnLoop.cpp:62:73: note: candidates are:
/usr/include/c++/4.6/ext/new_allocator.h:128:5: note: template<class _Tp> bool __gnu_cxx::operator!=(const __gnu_cxx::new_allocator<_Tp>&, const __gnu_cxx::new_allocator<_Tp>&)
/usr/include/c++/4.6/bits/stl_iterator.h:817:5: note: template<class _Iterator, class _Container> bool __gnu_cxx::operator!=(const __gnu_cxx::__normal_iterator<_Iterator, _Container>&, const __gnu_cxx::__normal_iterator<_Iterator, _Container>&)
/usr/include/c++/4.6/bits/stl_iterator.h:811:5: note: template<class _IteratorL, class _IteratorR, class _Container> bool __gnu_cxx::operator!=(const __gnu_cxx::__normal_iterator<_IteratorL, _Container>&, const __gnu_cxx::__normal_iterator<_IteratorR, _Container>&)
/usr/include/c++/4.6/bits/streambuf_iterator.h:200:5: note: template<class _CharT, class _Traits> bool std::operator!=(const std::istreambuf_iterator<_CharT, _Traits>&, const std::istreambuf_iterator<_CharT, _Traits>&)
/usr/include/c++/4.6/bits/basic_string.h:2497:5: note: template<class _CharT, class _Traits, class _Alloc> bool std::operator!=(const std::basic_string<_CharT, _Traits, _Alloc>&, const _CharT*)
/usr/include/c++/4.6/bits/basic_string.h:2485:5: note: template<class _CharT, class _Traits, class _Alloc> bool std::operator!=(const _CharT*, const std::basic_string<_CharT, _Traits, _Alloc>&)
/usr/include/c++/4.6/bits/basic_string.h:2473:5: note: template<class _CharT, class _Traits, class _Alloc> bool std::operator!=(const std::basic_string<_CharT, _Traits, _Alloc>&, const std::basic_string<_CharT, _Traits, _Alloc>&)
/usr/include/c++/4.6/bits/postypes.h:223:5: note: template<class _StateT> bool std::operator!=(const std::fpos<_StateT>&, const std::fpos<_StateT>&)
/usr/include/c++/4.6/bits/stl_vector.h:1297:5: note: template<class _Tp, class _Alloc> bool std::operator!=(const std::vector<_Tp, _Alloc>&, const std::vector<_Tp, _Alloc>&)
/usr/include/c++/4.6/bits/allocator.h:137:5: note: template<class _Tp> bool std::operator!=(const std::allocator<_Tp1>&, const std::allocator<_Tp1>&)

你可以从我的代码中看出，我不是主人......任何建议都将受到高度赞赏！

Answer 1

在你的第一个代码块中，你定义一个std::vector<std::vector<List> >，即List的向量向量，在第二个块中你循环std::vector<std::vector<List*> >，即一个指向List的向量向量。因此，应用的迭代器是不同的类型，不能相互转换。

我建议对内部和外部向量使用typedef以确保类型一致。

请记住，迭代器擦除元素会使迭代器无效，但会返回指向下一个元素的新迭代器。

迭代2D向量以从内存中删除对象

1 个答案: