向对象添加对象会覆盖现有对象

Question

我有两个类：GenomeRankedNode和RandomRankedTPNGenerator。 RandomRankedTPNGenerator责任只是随机创建一个GenomeRankedNode。 GenomeRankedNode有四个属性：int，int，int *和int。我的主要有一个载体应该使用RandomRankedTPNGenerator填充。为了这个目的，在主，我有：

std::vector<GenomeRankedNode*> population; 
population.resize(50); 
for (int i = 0; i < popsize; i++) { 
    RandomRankedTPNGenerator* generator = new RandomRankedTPNGenerator(); 
    GenomeRankedNode node* = generator->randomNode(numParents); 
    population[i] = node; 
    delete generator; 
} 

在RandomRankedTPNGenerator中，重要的功能是randomNode（）：

GenomeRankedNode* RandomRankedTPNGenerator::randomNode(int numParents){ 
    int function = randomFunction(); //just gets a random number 
    int* weights = randomWeights(numParents); //just gets a random number 
    int variance = randomVariance(); //just gets a random number 
    GenomeRankedNode* node = new GenomeRankedNode(function, numParents, weights, variance); 
    return node; 
} 

上面的代码被产生随机GenomeRankedNode正常。问题是，在人口，当我添加的对象，现有的显然是“覆盖”（我知道他们实际上并没有被覆盖...）。另一方面，人口正在填充不同的地址。如果我使用RandomRankedTPNGenerator的不同实例创建GenomeRankedNode，GenomeRankedNode在不同的地址正在创建对象，为什么都在人口指向相同的内存空间中的指针导致价值被指出人口[我]，每一个我都一样吗？

下面是GenomeRankedNode.cpp代码：

int function; 
int* weights; 
int numNodeParents; 
int variance; 

double vars[11] = {0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5, 10, 50}; 

GenomeRankedNode::GenomeRankedNode() 
{ 
    function = 0; 
    weights = 0; 
    numNodeParents = 1; 
    variance = 0; 
} 

GenomeRankedNode::GenomeRankedNode(int inFunction, int inNumParents, int* inWeights, int inVariance) 
{ 
    function = inFunction; 
    numNodeParents = inNumParents; 
    weights = inWeights; 
    variance = inVariance; 
} 

GenomeRankedNode::GenomeRankedNode(GenomeRankedNode* inNode) 
{ 
    function = inNode->getFunction(); 
    numNodeParents = inNode->getNumParents(); 
    weights = inNode->getWeights(); 
    variance = inNode->getVariance(); 
} 

GenomeRankedNode::GenomeRankedNode(const GenomeRankedNode &inNode) 
{ 
    function = inNode.getFunction(); 
    numNodeParents = inNode.getNumParents(); 
    variance = inNode.getVariance(); 

    //deep copy 
    if (inNode.getWeights()){ 
     weights = new int[numNodeParents]; 
     for (int i = 0; i < numNodeParents; i++) 
      weights[i] = inNode.getWeights()[i]; 
    } 
} 

GenomeRankedNode& GenomeRankedNode::operator= (const GenomeRankedNode &inNode) 
{ 

    //self-assignment check 
    if (this == &inNode) 
     return *this; 

    function = inNode.getFunction(); 
    numNodeParents = inNode.getNumParents(); 
    variance = inNode.getVariance(); 

    // explicitly deallocate values 
    delete[] weights; 

    // deep copy 
    if (inNode.getWeights()){ 
     weights = new int[numNodeParents]; 
     for (int i = 0; i < numNodeParents; i++) 
      weights[i] = inNode.getWeights()[i]; 
    } 
    else 
     weights = 0; 

    return *this; 
} 

GenomeRankedNode::~GenomeRankedNode(void) 
{ 
    delete &function; 
    delete &numNodeParents; 
    delete weights; 
    delete &variance; 
} 

int GenomeRankedNode::getFunction() const 
{ 
    return function; 
} 

int* GenomeRankedNode::getWeights() const 
{ 
    return weights; 
} 

int GenomeRankedNode::getNumParents() const 
{ 
    return numNodeParents; 
} 

int GenomeRankedNode::getVariance() const 
{ 
    return variance; 
} 

void GenomeRankedNode::setWeights(int *inWeights) 
{ 
    weights = inWeights; 
} 

void GenomeRankedNode::setFunction(int inFunction) 
{ 
    function = inFunction; 
} 

void GenomeRankedNode::setVariance(int inVariance) 
{ 
    variance = inVariance; 
} 

double GenomeRankedNode::getRealVariance(int inVariance) const 
{ 
    return vars[inVariance]; 
} 

要检查不当行为，我加入到主：

for (int i = 0; i < population.size(); i++){ 
    cout << population.at(i)->toString(); 

}

鉴于population.size （）= 3，输出为：

Function: 1 
Weights: 1 1 
Variance: 2 

Function: 1 
Weights: 1 1 
Variance: 2 

Function: 1 
Weights: 1 1 
Variance: 2 

在另一方面，如果我添加一行：

cout << population.at(i)->toString(); 

中，我用它来生成随机GenomeRankedNode对象的循环，我有：

Function: 0 
Weights: 3 4 
Variance: 1 

Function: 1 
Weights: 4 1 
Variance: 3 

Function = 1 
Weights = 1 1 
Variance = 2 

鉴于此，我的结论：出于某种原因，所有创建的GenomeRankedNode指向内存中的相同插槽。因此，每当一个新的GenomeRankedNode被实例化时，所有其他指针（GenomeRankedNode *）都将更新其指针值！它类似于浅层和深层复制问题，但我不知道它起源于何处！

Answer 1

我看到的一个问题是，您将人口的第i个值设置为GenomeRankedType而不是GenomeRankedType*（您说人口存储的类型）。

所以修改的代码的顶部部分：

std::vector<GenomeRankedNode*> population; 
population.resize(50); 
for (int i = 0; i < popsize; i++) { 
    RandomRankedTPNGenerator* generator = new RandomRankedTPNGenerator(); 
    GenomeRankedNode* node = generator->randomNode(numParents); 
    population[i] = node; 
    delete generator; 
} 

让我知道如果这能帮助你！

Answer 2

我感动：

int function; 
int* weights; 
int numNodeParents; 
int variance; 

从GenomeRankedNode.cpp到GenomeRankedNode.h为私人。这解决了这个问题。