为什么在这种情况下内存分配失败？

Question

我已经调试该程序很长时间了，但是我仍然无法弄清为什么内存分配失败。因此，这是我的代码的一部分：

for(int k = 0; k < cur_Candidates.size(); k++)  
{
    bool flag = false;
    QuickSI_SGI(cur_Candidates[k],flag, datacodes);         
    if( flag == true )
    {
        CurGlobalVariables.Answers.push_back(cur_Candidates[k]);

    }
}

上面的代码是一个循环， QuickSI_SGI(cur_Candidates[k],flag, datacodes)都调用函数QuickSI_SGI(cur_Candidates[k],flag, datacodes) 。

据我所知，当函数返回时，分配给该函数的空间将被释放。但是，当我调试程序时，我发现使用的内存随着循环的进行而增加。不幸的是，这是一个长循环！循环失败，程序失败并警告内存分配失败！ 我对此很困惑。

---

很抱歉，我没有在函数QuickSI_SGI()告知详细信息，该函数中没有“ new”或“ malloc”语句，并且我仅在函数中使用了vector，并且警告是为vector分配内存失败。 cur_Candidates是包含整数cur_Candidates的向量。 CurGlobalVariables.Answers与cur_Candidates相同。 我正在使用VS2010，CPU：Intel i5，内存：8GB。

---

这是函数：

Status PrefixQuickSI::QuickSI_SGI(int cur_graphid, bool &flag, QISequence       datacodes[10000])           
{
Status st;
int cur_size, query_size; 
ECVector<char> cur_UsageTab; 
cur_UsageTab.clear(); 
ECVector<SequenceIndex> cur_MappingTab;
cur_MappingTab.clear();
cur_size = CurGlobalVariables._sequence.size();  
int graphsize = cur_size + datacodes[cur_graphid].numOfPrefixNode;
if((graphsize - 1) > m_QueryGraph->V())     
{   
    flag = false;
    return OK;  
}

for(int i = 0; i < m_UsageTab.size(); i ++)   
    cur_UsageTab.push_back(m_UsageTab[i]);
for(int i = 0; i < m_MappingTab.size(); i ++) 
{
    if(i == cur_size)
        cur_MappingTab.push_back(NO_SEQUENCE_INDEX);
    cur_MappingTab.push_back(m_MappingTab[i]);
}

std::vector<_QISymbol>  cur_sequence;
cur_sequence.clear();

for(int i = 0; i < CurGlobalVariables._sequence.size(); i ++)  
    cur_sequence.push_back(CurGlobalVariables._sequence[i]);
int depth = 0;
st = my_QucikSI(cur_sequence, datacodes[cur_graphid], depth, cur_size,cur_UsageTab,cur_MappingTab, flag);

if (flag==true)
{
    return OK;
}       
else
{
    flag = false;
    return OK;
}
return OK;

}

这是另一个功能：

Status  PrefixQuickSI::my_QucikSI(std::vector<_QISymbol> &cur_sequence, QISequence &graphcode, int  &depth, int feature_size, ECVector<char> cur_UsageTab, ECVector<SequenceIndex> cur_MappingTab, bool &flag)
{
Status st;
int vcnt = m_QueryGraph->V();
_QISymbol T;
if(depth == 0)                                      
{
    T.tSymbol = graphcode.sequence[depth]->tSymbol; 
    T.rSymbols.clear();
    for(int i = 0; i < graphcode.sequence[depth]->numOfRSymbol; i++)
    {
        int  v1,v2;
        Label elabel;
        v1 = graphcode.sequence[depth]->rSymbol[i].val;
        v2 = graphcode.sequence[depth]->rSymbol[i+1].val;
        elabel = graphcode.sequence[depth]->rSymbol[i].lable;
        if(m_QueryGraph->getELabel(cur_MappingTab[v1],cur_MappingTab[v2]) != elabel)
        {   
            flag = false;
            return OK;
        }
        T.rSymbols.push_back(graphcode.sequence[depth]->rSymbol[i]);
        T.rSymbols.push_back(graphcode.sequence[depth]->rSymbol[i+1]);
        i++;                

    }
    depth++;
    cur_sequence.push_back(T);

    if(depth == graphcode.numOfPrefixNode)
    {
        flag =true;
        return OK;
    }
    else
    {
        st = my_QucikSI(cur_sequence, graphcode,depth, feature_size, cur_UsageTab, cur_MappingTab, flag);
        if(flag == true)
        {
            return OK;
        }
        else
        {
            flag = false;
            return OK;
        }
    }
}
else
{
    T.tSymbol = graphcode.sequence[depth]->tSymbol;   
    for( int j = 0; j < graphcode.sequence[depth]->numOfRSymbol; ++j )  
    {
        RSymbol rSymbol;
        rSymbol = graphcode.sequence[depth]->rSymbol[j];
        T.rSymbols.push_back(rSymbol);
    } 

    int pV;
    VertexIDSet Vcandiates;

    for( int i = 0; i < vcnt; i++ )
    {
        pV = T.tSymbol.p;       
        if( cur_UsageTab[i] > 0 || m_QueryGraph->getLabel(i) != T.tSymbol.l || m_QueryGraph->getELabel(i, cur_MappingTab[pV]) != T.tSymbol.pl)
            continue;
        Vcandiates.insert(i);
    }
    if(Vcandiates.size() == 0)
    {
        flag = false;
        return OK;
    }

    for( VertexIDSet::const_iterator v = Vcandiates.begin(); v != Vcandiates.end(); v++ ) 
    {
        bool mis_match = false;
        for( std::vector<RSymbol>::const_iterator r = T.rSymbols.begin(); r != T.rSymbols.end(); r++ )
        {
            if( !MatchREntry(cur_sequence, *v, *r) )
            {
                mis_match = true;
                break;
            }
        }
        if( mis_match ) 
            continue;
        cur_MappingTab[feature_size + depth] = *v;
        cur_UsageTab[*v] = 1;
        depth++; 
        cur_sequence.push_back(T);
        if(depth == graphcode.numOfPrefixNode)
        {
            flag = true;
            return OK;
        }
        else
        {
            st = my_QucikSI(cur_sequence, graphcode,depth, feature_size, cur_UsageTab, cur_MappingTab,flag);
            if(flag == true)
            {
                return OK;
            }
            else
            {
                cur_UsageTab[*v] = 0;
                depth--;
                cur_sequence.pop_back();
            }
        }

    }
}

return OK;

}

Answer 1

在函数中，参数和局部变量分配在堆栈上。

这些变量的内存在函数返回时自动释放。

如果您的函数使用new关键字分配内存，那么该内存将分配在堆上，您必须使用delete关键字自己释放它。

例如：

void QuickSI_SGI(int value){ // 'value' will be destroyed on return
  string text="Some text";   // 'text' will be destroyed on return
  char* list=new char[10];   // This allocates 10 bytes on the heap
                             //  and a pointer to them on the stack.
                             // The pointer will be destroyed like
                             //  every other local variable, but
                             //  those 10 bytes won't.
  delete list;               // So you need to manually free that
  return;                    //  memory before return
}