c++ - 正在分配指针的测试类析构函数？

Question

所以我的代码有问题。我想将我的指针数组中的一个值传递给一个函数，这样原始对象就不会被“干扰”(如果我传递引用，我的代码工作得很好；我只是想以不同的方式作为学习练习).执行返回后，出现错误:

“对象 0x100105790 错误:未分配正在释放的指针*** 在 malloc_error_break 中设置断点进行调试。

我知道这是因为当值在函数返回时超出范围，为对象调用析构函数但我的析构函数假定一个分配的指针，因此错误。我很好奇是否有办法测试基因组是否已经分配。如果不是，我会为析构函数做其他事情吗？这甚至是一个值得烦恼的问题，因为我已经通过传递引用来让它工作了吗？该功能实际上并没有破坏性；我只是想做一些把戏。我不喜欢走捷径。

//class destructor for int genome[]
Organism::~Organism() {
    //cout << "Deleting this: " << this << endl;
    if (this->genome != NULL) {
         delete [] this->genome;
    }
}

//declare genome pointer
int *genome;
/**
 * Default constructor for class
 */
Organism::Organism() {
    this->fitness = 0;
    this->size = 0;
    this->genome = NULL;
}
//another constructor for if only the size of genome is defined
Organism::Organism(int size) {
    this->fitness = 0;
    this->size = size;
    this->genome = new int[size];
}
//another constructor for when all starting values are defined
Organism::Organism(int size, int *genome) {
    this->fitness = 0;
    this->size = size;
    this->genome = new int[size];

    for (int i = 0; i < size; i++) {
        this->genome[i] = genome[i];
    }
 }

//initialize and populate reproducible from already existing array start_pop     (this has been verified as being properly allocated and values initiated)
vector<Organism*> reproduceable (0);
    for (int i = 0; i < start_pop.size(); i++) {
        if (start_pop[i]->get_fitness() > threshold) {
            reproduceable.push_back(start_pop[i]);
        }
    }

//function definition
Organism* reproduce(Organism, Organism);

//function call in main()
offspring.push_back(reproduce(*reproduceable[i], *reproduceable[i+1]));

//function implementation
Organism* reproduce(Organism a, Organism b) {
    int genome[4];

    //randomly decide on where to split parent genomes
    int split = rand() % 5;
    for (int i = 0; i < a.get_size(); i++) {
        if (i < split) {
            genome[i] = a.get_genome()[i];
        } else {
            genome[i] = b.get_genome()[i];
        }
    }
    //now cause random mutation in 2% of the population
    if ((rand() % 100 + 1) <= 2) {
        int rand_index = rand() % 5;
        int mutation = rand() % 6 + 1;

        genome[rand_index] = mutation;
    }

    Organism *child = new Organism(4, genome); //need to add genome
    return child;
}

编辑以添加默认构造函数和数组初始化以实现可重现

Answer 1

您的问题出在这一行:

offspring.push_back(reproduce(*reproduceable[i], *reproduceable[i+1]));

请注意，您将两个 reproduceable 按值传递给一个函数。该函数的签名是

Organism* reproduce(Organism a, Organism b)

它需要两个 Organism 的值，这意味着对于两个 Organism 都将调用一个复制构造函数。由于您没有定义复制构造函数，因此将创建一个默认复制构造函数，它只是将一个生物体的内容复制到另一个生物体中，包括指向基因组的指针。问题是现在两个 Organism 都将被释放——一个是函数本地的，一个是传递给它的，导致双倍释放分配给基因组的内存。有两种解决方法:

1. 使签名成为

Organism* reproduce(const Organism &a, const Organism &b)

这样你的 Organism 就不会被复制，因此不会被双重释放。 (根据你的问题，我假设你已经尝试过，并且对第二种解决方案感兴趣:))

1. 实现自定义复制构造函数，创建一个新数组，就像这样

Organism::Organism(const Organism& a)
{
     this->fitness = a.fitness;
     this->size = a.size;
     this->genome = new int[this->size];
     for (int i = 0; i < this->size; ++ i)
         this->genome[i] = a.genome[i];
}

这样，当您将有机体传递给您的函数时，您的自定义复制构造函数将被调用，并且函数本地有机体的 genome 将被单独分配。