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

我已经调试这个程序很长时间了，但我仍然不明白内存分配失败的原因。因此，下面是我的部分代码：

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

    }
}

}

这是另一个功能：

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;

状态前缀QuickSi:：my_QucikSI（std:：vector&cur_sequence，QISequence&graphcode，int&depth，int feature_size，ECVector cur_UsageTab，ECVector cur_MappingTab，bool&flag）
{
状态st；
int vcnt=m_QueryGraph->V（）；
_齐符号T；
如果（深度==0）
{
T.tSymbol=图形代码序列[深度]->tSymbol；
T.rSymbols.clear（）；
对于（int i=0；inumorsymbol；i++）
{
int v1，v2；
标签elabel；
v1=graphcode.sequence[depth]->rSymbol[i].val；
v2=图形代码.序列[depth]->rSymbol[i+1].val；
elabel=graphcode.sequence[depth]>rSymbol[i].标签；
if（m_QueryGraph->getELabel（cur_MappingTab[v1]，cur_MappingTab[v2]）！=elabel）
{   
flag=false；
返回OK；
}
T.rSymbols.push_back（图形代码序列[depth]>rSymbol[i]）；
T.rSymbols.push_back（图形代码序列[depth]>rSymbol[i+1]）；
i++；
}
深度++；
电流顺序。推回（T）；
if（depth==graphcode.numOfPrefixNode）
{
flag=true；
返回OK；
}
其他的
{
st=my_QucikSI（当前序列、图形代码、深度、特征大小、当前使用选项卡、当前映射选项卡、标志）；
如果（标志==真）
{
返回OK；
}
其他的
{
flag=false；
返回OK；
}
}
}
其他的
{
T.tSymbol=图形代码序列[深度]->tSymbol；
对于（int j=0；jnumorsymbol；++j）
{
RSymbol RSymbol；
rSymbol=graphcode.sequence[depth]>rSymbol[j]；
T.rSymbols.推回（rSymbol）；
} 
int pV；
顶点集vcandites；
对于（int i=0；i0 | m|u QueryGraph->getLabel（i）！=T.tSymbol.l | m|u QueryGraph->getELabel（i，cur|u MappingTab[pV]）！=T.tSymbol.pl）
继续；
插入（i）；
}
如果（vCandites.size（）==0）
{
flag=false；
返回OK；
}
for（VertexIDSet:：const_迭代器v=vcandites.begin（）；v！=vcandites.end（）；v++）
{
bool mis_match=false；
for（std:：vector:：const_迭代器r=T.rSymbols.begin（）；r！=T.rSymbols.end（）；r++）
{
if（！MatchREntry（cur_序列，*v，*r））
{
错误匹配=正确；
打破
}
}
如果（不匹配）
继续；
当前映射选项卡[特征尺寸+深度]=*v；
cur_UsageTab[*v]=1；
深度++；
电流顺序。推回（T）；
if（depth==graphcode.numOfPrefixNode）
{
flag=true；
返回OK；
}
其他的
{
st=my_QucikSI（当前序列、图形代码、深度、特征大小、当前使用选项卡、当前映射选项卡、标志）；
如果（标志==真）
{
返回OK；
}
其他的
{
cur_UsageTab[*v]=0；
深度--；
cur_sequence.pop_back（）；
}
}
}
}
返回OK；

---

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

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

如果您的函数使用

new

关键字分配内存，那么该内存将在堆上分配，您必须使用

delete

关键字自己释放内存

例如：

void QuickSI_SGI（int-value）{//'value'将在返回时销毁
string text=“Some text”//“text”将在返回时销毁
char*list=new char[10]；//这将在堆上分配10个字节
//以及堆栈上指向它们的指针。
//指针将像这样被销毁
//其他所有局部变量，但
//这10个字节不会。
删除列表；//因此您需要手动释放该列表
return；//返回前的内存
}

当前候选项中有什么？

CurGlobalVariables.Answers

的定义是什么？

QuickSI\u SGI

做了什么？正如您已经确定的那样，在这个长循环中内存使用正在增加，询问内存分配失败的原因可能是无效的。这有点像问“为什么在吃了几天麦片之后，麦片盒是空的？”你知道分配给这个功能的空间是否很小吗？您在哪个平台上运行程序？您知道，使用

push_back

向集合添加内容将在必要时分配内存，并且在长循环中重复这样做几乎肯定会导致内存使用量不断增加？如果删除

push_back

，问题会消失吗？很抱歉，我没有提到函数

QuickSI_SGI（）

中没有“new”语句。好的，这有点复杂。当向量超出范围时，它们会破坏它们枚举的每个对象，因此问题可能存在于这些对象的析构函数中。确保对象释放为向量中使用的每个类分配的所有内容。