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()中说明细节，没有＆＃34;新的＆＃34;或＆＃34; malloc＆＃34;函数中的语句，我只是在函数中使用向量，警告是为向量分配内存失败。 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
}

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

1 个答案: