读书人
栏目▼

关于嵌套vector的析构有关问题

发布时间： 2013-07-04 11:45:55 作者： rapoo

关于嵌套vector的析构问题


vector<vector<wchar_t*>> vecUpper;

// constructor
for (int i = 0; i < 10; ++i)
{
vector<wchar_t*> vecInner;
for (int j = 0; j < count; ++j)
{
wchar_t *pItem = new wchar_t[10];
vecInner.push_back(pItem);
}
vecUpper.push_back(vecInner);
}

// destructor
for (std::vector<vector<wchar_t*>>::iterator i = vecUpper.begin(); i != vecUpper.end(); ++i)
{
for (std::vector<wchar_t*>::iterator j = i->begin(); j != i->end(); ++j)
{
delete []*j;
}
}


代码是根据发帖时根据记忆临时写的，大体意思已经表达了。在析构的时候程序会死掉，添加计数器，发现循环执行了560次，各种诡异。。。。 vector 析构
[解决办法]
[code=c]namespace test{
 
    void testIt(){
        vector< vector < wchar_t*> > vecUpper; 
        vecUpper.resize(10);  
        int count=20;
        // constructor 
        for (int i = 0; i < 10; ++i) { 
            vector<wchar_t*> vecInner;     
             for (int j = 0; j < count; ++j)     {
                 wchar_t *pItem = new wchar_t[10];  
                 //vecInner.push_back(pItem);   
                 vecUpper[i].push_back(pItem); 
             }   
 
             //vecUpper.push_back(vecInner);           
        }   
        // destructor 
        for (std::vector< vector<wchar_t*> >::iterator i = vecUpper.begin(); i != vecUpper.end(); ++i) {     
            for (std::vector<wchar_t*>::iterator j = i->begin(); j != i->end(); ++j)     {   
                  delete []*j;     
            } 
        }
    }    
}

namespace test{
 
 template <typename T>{
      void testIt(){
        vector< vector < wchar_t*> > vecUpper; 
       // vecUpper.resize(10);  
        int count=20;
        // constructor 
        for (int i = 0; i < 10; ++i) { 
            vector<wchar_t*> vecInner;     
             for (int j = 0; j < count; ++j)     {
                 wchar_t *pItem = new wchar_t[10];  
                 vecInner.push_back(pItem);   
                 //vecUpper[i].push_back(pItem); 
             }
             vecUpper.push_back(vecInner);  
             vecInner.clear(); //加上这一句，就没有问题了！！！！！！
                    
 
        }   
        // destructor 
        for (std::vector< vector<wchar_t*> >::iterator i = vecUpper.begin(); i != vecUpper.end(); ++i) {     
            for (std::vector<wchar_t*>::iterator j = i->begin(); j != i->end(); ++j)     {   
                  delete []*j;     
            } 
        }
    }    
}
如此也没有问题
你的代码，每次vecUpper.push_back(vecInner);
没有清掉vecInner，所以vecInner越来越长，并且每次vecInner 都把保留上次所有指针，
于是 循环10次，vecUpper.push_back的 数据越来越多，而且重复，1~10 遍
于是 delete []*j; 的时候，很多指针被delete 1~10次；
重复 delete的时候就出错了！

[/code]
[解决办法]
引用:
[code=c]namespace test{
 
    void testIt(){
        vector< vector < wchar_t*> > vecUpper; 
        vecUpper.resize(10);  
        int count=20;
        // constructor 
        for (int i = 0; i < 10; ++i) { 
            vector<wchar_t*> vecInner;     
             for (int j = 0; j < count; ++j)     {
                 wchar_t *pItem = new wchar_t[10];  
                 //vecInner.push_back(pItem);   
                 vecUpper[i].push_back(pItem); 
             }  
             //vecUpper.push_back(vecInner);            
 
        }   
        // destructor 
        for (std::vector< vector<wchar_t*> >::iterator i = vecUpper.begin(); i != vecUpper.end(); ++i) {     
            for (std::vector<wchar_t*>::iterator j = i->begin(); j != i->end(); ++j)     {   
                  delete []*j;     
            } 
        }
    }    
}

namespace test{
 
 template <typename T>{
      void testIt(){
        vector< vector < wchar_t*> > vecUpper; 
       // vecUpper.resize(10);  
        int count=20;
        // constructor 
        for (int i = 0; i < 10; ++i) { 
            vector<wchar_t*> vecInner;     
             for (int j = 0; j < count; ++j)     {
                 wchar_t *pItem = new wchar_t[10];  
                 vecInner.push_back(pItem);   
                 //vecUpper[i].push_back(pItem); 
             }
             vecUpper.push_back(vecInner);  
             vecInner.clear(); //加上这一句，就没有问题了！！！！！！
                   
        }   
        // destructor  
 
        for (std::vector< vector<wchar_t*> >::iterator i = vecUpper.begin(); i != vecUpper.end(); ++i) {     
            for (std::vector<wchar_t*>::iterator j = i->begin(); j != i->end(); ++j)     {   
                  delete []*j;     
            } 
        }
    }    
}
如此也没有问题
你的代码，每次vecUpper.push_back(vecInner);
没有清掉vecInner，所以vecInner越来越长，并且每次vecInner 都把保留上次所有指针，
于是 循环10次，vecUpper.push_back的 数据越来越多，而且重复，1~10 遍
于是 delete []*j; 的时候，很多指针被delete 1~10次；
重复 delete的时候就出错了！

[/code]
………………每个vecInner都是独立的，看清楚……
[解决办法]

[解决办法]
引用:
Quote: 引用:

[code=c]namespace test{
 
    void testIt(){
        vector< vector < wchar_t*> > vecUpper; 
        vecUpper.resize(10);  
        int count=20;
        // constructor  
 
        for (int i = 0; i < 10; ++i) { 
            vector<wchar_t*> vecInner;     
             for (int j = 0; j < count; ++j)     {
                 wchar_t *pItem = new wchar_t[10];  
                 //vecInner.push_back(pItem);   
                 vecUpper[i].push_back(pItem); 
             }  
             //vecUpper.push_back(vecInner);           
        }   
        // destructor 
        for (std::vector< vector<wchar_t*> >::iterator i = vecUpper.begin(); i != vecUpper.end(); ++i) {     
            for (std::vector<wchar_t*>::iterator j = i->begin(); j != i->end(); ++j)     {   
                  delete []*j;     
            } 
        }
    }    
}

namespace test{
 
 template <typename T>{
      void testIt(){
        vector< vector < wchar_t*> > vecUpper; 
       // vecUpper.resize(10);  
        int count=20;
        // constructor 
        for (int i = 0; i < 10; ++i) { 
            vector<wchar_t*> vecInner;      
 
             for (int j = 0; j < count; ++j)     {
                 wchar_t *pItem = new wchar_t[10];  
                 vecInner.push_back(pItem);   
                 //vecUpper[i].push_back(pItem); 
             }
             vecUpper.push_back(vecInner);  
             vecInner.clear(); //加上这一句，就没有问题了！！！！！！
                   
        }   
        // destructor 
        for (std::vector< vector<wchar_t*> >::iterator i = vecUpper.begin(); i != vecUpper.end(); ++i) {     
            for (std::vector<wchar_t*>::iterator j = i->begin(); j != i->end(); ++j)     {   
                  delete []*j;     
            } 
        }
    }    
}
如此也没有问题
你的代码，每次vecUpper.push_back(vecInner);
没有清掉vecInner，所以vecInner越来越长，并且每次vecInner 都把保留上次所有指针，
于是 循环10次，vecUpper.push_back的 数据越来越多，而且重复，1~10 遍
于是 delete []*j; 的时候，很多指针被delete 1~10次；
重复 delete的时候就出错了！

[/code]
………………每个vecInner都是独立的，看清楚……

Dev C 就是会出错，这是编译器，把定义提到for 循环外部了！！

[解决办法]
引用:
Quote: 引用:

Quote: 引用:

[code=c]namespace test{
 
    void testIt(){
        vector< vector < wchar_t*> > vecUpper;  
 
        vecUpper.resize(10);  
        int count=20;
        // constructor 
        for (int i = 0; i < 10; ++i) { 
            vector<wchar_t*> vecInner;     
             for (int j = 0; j < count; ++j)     {
                 wchar_t *pItem = new wchar_t[10];  
                 //vecInner.push_back(pItem);   
                 vecUpper[i].push_back(pItem); 
             }  
             //vecUpper.push_back(vecInner);           
        }   
        // destructor 
        for (std::vector< vector<wchar_t*> >::iterator i = vecUpper.begin(); i != vecUpper.end(); ++i) {     
            for (std::vector<wchar_t*>::iterator j = i->begin(); j != i->end(); ++j)     {   
                  delete []*j;     
            } 
        }
    }    
}

namespace test{
 
 template <typename T>{
      void testIt(){
        vector< vector < wchar_t*> > vecUpper; 
       // vecUpper.resize(10);  
        int count=20;
        // constructor 
        for (int i = 0; i < 10; ++i) {  
 
            vector<wchar_t*> vecInner;     
             for (int j = 0; j < count; ++j)     {
                 wchar_t *pItem = new wchar_t[10];  
                 vecInner.push_back(pItem);   
                 //vecUpper[i].push_back(pItem); 
             }
             vecUpper.push_back(vecInner);  
             vecInner.clear(); //加上这一句，就没有问题了！！！！！！
                   
        }   
        // destructor 
        for (std::vector< vector<wchar_t*> >::iterator i = vecUpper.begin(); i != vecUpper.end(); ++i) {     
            for (std::vector<wchar_t*>::iterator j = i->begin(); j != i->end(); ++j)     {   
                  delete []*j;     
            } 
        }
    }    
}
如此也没有问题
你的代码，每次vecUpper.push_back(vecInner);
没有清掉vecInner，所以vecInner越来越长，并且每次vecInner 都把保留上次所有指针，
于是 循环10次，vecUpper.push_back的 数据越来越多，而且重复，1~10 遍
于是 delete []*j; 的时候，很多指针被delete 1~10次；
重复 delete的时候就出错了！

[/code]
………………每个vecInner都是独立的，看清楚……

Dev C 就是会出错，这是编译器，把定义提到for 循环外部了！！
编译器的问题还怪lz代码写的不好？lz有说自己用的是dev C吗？

读书人网 >C++

热点推荐

触屏版 | 电脑版

读书人网 m.reader8.net