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

Question

I have been debugging the program for a long time,but I still cannot figure out why does memory allocation fail.So,here is part of my code:

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]);

    }
}

The code above is a loop which calls function QuickSI_SGI(cur_Candidates[k],flag, datacodes) every time.

As far as I know,when function returns,space allocated for that function will be freed.But when I debug the program,I find that used memory increases as the loop goes on.And unfortunately,this is a long loop!In the middle of the loop,the program fails and warns that memory allocation fails! I'm really confused about this.

---

I'm sorry that I did not tell details in function QuickSI_SGI() ,there is no "new" or "malloc" statement in the function,and I just used vectors in the function,and the warning is for allocating memory for vector fails. cur_Candidates is a vector containing integers, CurGlobalVariables.Answers is the same like cur_Candidates . I'm using VS2010,CPU:Intel i5,memory:8GB.

---

Here is the function:

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;

}

and here is another function:

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

In a function, arguments and local variables are allocated on the stack.

Memory for these variables is automatically freed as the function returns.

If your function allocates memory with the new keyword, that memory is allocated on the heap and you'll have to free it yourself using the delete keyword.

For example:

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
}