0

为了解决这个问题内存管理不好？类成员(boolean)值大于1，在递归函数中，我在Valgrind下跑了整个程序，发现在这一步之前出现了一些内存泄漏问题。在函数 CMFLoader 中发现了 2 个“绝对丢失”的问题。

（这里MyDataset是一个Molecule对象的向量，每个Molecule对象都包含一个Elements对象）

在 CMFLoader::loadFile(vector& MyDataset) 中，我原来有

MyDataset.push_back( readMolecule( in_file, word );

其中 CMFLoader::readMolecule 返回一个 Molecule 对象。在 readMolecule 函数中，创建了一个新的 Molecule 对象（但直到 main 的最后才被删除，稍后会详细介绍）

Molecule* CMFLoader::readMolecule( ifstream& in_file, string id)
{
Molecule* my_mol = new Molecule( id );
// statements, somewhere along the readFormula function is called
my_mol->setFormula( readFormula( ss ) );
return my_mol;
}

其中 CMFLoader::readFormula 返回一个 Element 对象，并且有一个 Molecule::setFormula 函数将其保存到 Molecule 对象。在读取公式

Elements* CMFLoader::readFormula( stringstream& ss )
{
Elements* my_formula = new Elements();
...
return my_formula;
}

我遇到了问题here中描述的问题，稍后在主程序中。具体问题发生在 HammettCheck::checkHammett 步骤。然后我将上面的 CMFLoader 函数更改为类似的东西。之前遇到的问题好像都消失了（但后来程序中出现了其他问题，无疑与内存泄漏有关）：

在 CMFLoader::loadFile

Molecule* new_mol = new Molecule(word);
    MyDataset.push_back( readMolecule( in_file, word ,new_mol) );

其中 readMolecule 现在接受一个新参数 Molecule* 并且新运算符在函数中被删除。同样，在 readFormula 中，我现在有

 Elements* new_formula = new Elements();
my_mol->setFormula( readFormula( ss, new_formula ) );

等等

现在当然没有消除内存泄漏问题！但是，我不能在任何 CMFLoader 函数中放入删除运算符，因为这些对象稍后会在主程序中使用。具体来说，Elements* 一直使用到 ConjugationCheck::checkConjugation 步骤，Molecule* 一直使用到程序结束。

主程序是这样的

int main(int argc, char* argv[]){
//initialising an empty array to store our molecules.
vector<Molecule*> MyDataset;

//Read command line inputs.
InputReader* MyInputs = new InputReader();
if( !MyInputs->readInputs(argc, argv) ) {delete MyInputs;return -1;}

//Load CMF file.
CMFLoader* MyLoader = new CMFLoader( MyInputs );
unsigned int min_same_grp = MyLoader->getmin(); //define minimum no of same hammett groups for structure
if( !MyLoader->loadFile( MyDataset ) ) {delete MyLoader;delete MyInputs;return -1;}
delete MyLoader;

cout << MyDataset.size() << " molecules loaded" << endl;

//Remove molecules which are too large.
BigFilter* MyBigFilter = new BigFilter( MyInputs );
if( !MyBigFilter->filterBigLigands( MyDataset ) ) {delete MyBigFilter;delete MyInputs;return -1;}
delete MyBigFilter;

cout << "Molecules left after big ligand filter: " << MyDataset.size() << endl;

//Mark any Hammetts groups found in molecules.
HammettCheck* MyHammettCheck = new HammettCheck(min_same_grp);
if( !MyHammettCheck->loadHammetts() ) {delete MyHammettCheck;delete MyInputs;return -1;}
if( !MyHammettCheck->checkHammett( MyDataset ) ) {delete MyHammettCheck;delete MyInputs;return -1;}
delete MyHammettCheck;

cout << "Molecules containing Hammett Groups: " << MyDataset.size() << endl;

ConjugationCheck* MyConjugationCheck = new ConjugationCheck(min_same_grp);
if( !MyConjugationCheck->checkConjugation( MyDataset ) ) {delete MyConjugationCheck;delete MyInputs;return -1;}
delete MyConjugationCheck;

cout << "Molecules containing conjugated Hammett Groups: " << MyDataset.size() << endl;

DataAdder* MyDataAdder = new DataAdder( MyInputs );
if( !MyDataAdder->addData( MyDataset ) ) {delete MyDataAdder; delete MyInputs;return -1;}
delete MyDataAdder;

//Sorts molecules based on their NLO rating given by NLOCompare.
if (min_same_grp ==1) {sort(MyDataset.begin(), MyDataset.end(), NLOCompare);}
else {sort(MyDataset.begin(), MyDataset.end(), OctuNLOCompare);}

//Saves a new CIF file containing just the predicted NLO molecules.
FileSaver* MyFileSaver = new FileSaver( MyInputs );
if( !MyFileSaver->saveFile( MyDataset ) ) {delete MyFileSaver;delete MyInputs;return -1;}
delete MyFileSaver;

/*
Saves a txt file which can be imported into Excel, showing the
paths to each of the selected Hammett groups in a molecule.
*/
ExcelSaver* MyExcelSaver = new ExcelSaver( MyInputs );
if( !MyExcelSaver->saveFile( MyDataset ) ) {delete MyExcelSaver;delete MyInputs;return -1;}
delete MyExcelSaver;

//Cleans the memory before exiting the program.
for(unsigned int i=0; i < MyDataset.size(); i++){
    delete MyDataset[i];
}
delete MyInputs;
return 0;
}

在程序的各个点，如果 Molecule MyDataset[i] 不符合某些条件，则使用以下方法将其删除

MyDataset.pop_back();

所以这将调用分子析构函数，它看起来像这样

Molecule::~Molecule(void)
{
//Deletes all atoms in molecule.
for(unsigned int i=0; i < mol_atoms.size(); i++){
    delete mol_atoms[i];
}

//Deletes all bonds in molecule.
for(unsigned int i=0; i < mol_bonds.size(); i++){
    delete mol_bonds[i];
}

//Deletes the class of elements contained.
delete mol_formula;
}

我不确定这里出了什么问题。我应该如何解决内存泄漏问题？

我的 Valgrind Memcheck 泄漏总结中的“绝对丢失”问题

==34809== 400 (96 direct, 304 indirect) bytes in 2 blocks are definitely lost in loss record 24 of 33
==34809==    at 0x1000A0679: malloc (vg_replace_malloc.c:266)
==34809==    by 0x1000F7F04: operator new(unsigned long) (in /usr/lib/libstdc++.6.0.9.dylib)
==34809==    by 0x10000A3B4: CMFLoader::readMolecule(std::basic_ifstream<char, std::char_traits<char> >&, std::string, Molecule*) (in ./OctuDiscovery)
==34809==    by 0x10000B9EE: CMFLoader::loadFile(std::vector<Molecule*, std::allocator<Molecule*> >&) (in ./OctuDiscovery)
==34809==    by 0x10000282E: main (in ./OctuDiscovery)

==34809== 12,833 (152 direct, 12,681 indirect) bytes in 1 blocks are definitely lost in loss record 33 of 33
==34809==    at 0x1000A0679: malloc (vg_replace_malloc.c:266)
==34809==    by 0x1000F7F04: operator new(unsigned long) (in /usr/lib/libstdc++.6.0.9.dylib)
==34809==    by 0x10000B93B: CMFLoader::loadFile(std::vector<Molecule*, std::allocator<Molecule*> >&) (in ./OctuDiscovery)
==34809==    by 0x10000282E: main (in ./OctuDiscovery)
4

2 回答 2

2

评论多于答案，但评论太长：
在下一个函数中，使用动态内存没有意义：

Molecule* CMFLoader::readMolecule( ifstream& in_file, string id)
{
Molecule* my_mol = new Molecule( id );
// statements, somewhere along the readFormula function is called
my_mol->setFormula( readFormula( ss ) );
return my_mol;
}

您可以将其替换为：

Molecule CMFLoader::readMolecule( ifstream& in_file, string id)
{
Molecule my_mol( id );
// statements, somewhere along the readFormula function is called
my_mol.setFormula( readFormula( ss ) );
return my_mol;
}

这已经解决了 1 个可能的内存泄漏问题，但可能存在需要/首选动态内存版本的原因，在这种情况下，应该使用已经提到的 unique_ptr。

于 2012-05-11T11:33:41.673 回答
1

如果您想做这样的事情，我建议您看一下 std::auto_ptr 类，或者至少看一下智能指针或自动指针的概念。您应该依赖 RAII (Resource Aquisition Is Initialization) 范式，这意味着内存管理应该由对象自己完成：尽可能避免使用基本指针和自写内存管理代码。

于 2012-05-11T11:25:26.693 回答