0

为了减少代码中的多个函数（几乎相同），我决定将它们全部合并到一个函数中，该函数接受一个附加参数（实际上是一个具有多个参数的类），然后使用这些值来模仿多个功能将完成。然后，长话短说，我将这些类声明中的每一个放入一个向量中，现在我的程序似乎功能失调。

我的一个类的多个实例：

FragmentCostParameters commonFCP = FragmentCostParameters(.05, 0);
FragmentCostParameters rareFCP = FragmentCostParameters(.05, 50);
FragmentCostParameters uniqueFCP = FragmentCostParameters(.05, 125);
FragmentCostParameters legendaryFCP = FragmentCostParameters(.02, 175);
FragmentCostParameters crystallineFCP = FragmentCostParameters(.02, 250);
FragmentCostParameters superEliteFCP = FragmentCostParameters(.02, 300);

通过以下方式将其放入向量中：

vector<FragmentCostParameters> FCPs(6);

FCPs.push_back(FragmentCostParameters(.05, 0));
FCPs.push_back(FragmentCostParameters(.05, 50));
FCPs.push_back(FragmentCostParameters(.05, 125));
FCPs.push_back(FragmentCostParameters(.02, 175));
FCPs.push_back(FragmentCostParameters(.02, 250));
FCPs.push_back(FragmentCostParameters(.02, 300));

此外，该类定义如下：

class FragmentCostParameters {
public:
    double multFactor;
    double subtractFactor;
    FragmentCostParameters(double _multFactor, double _subtractFactor){
        multFactor = _multFactor;
        subtractFactor = _subtractFactor;
    }
    FragmentCostParameters(){
        multFactor = .05;
        subtractFactor = 0;
    }

};

现在，您会注意到 的默认构造函数FragmentCostParameters涉及设置multFactor = .05和subtractFactor = 0。但是，似乎无论我推回什么，我的向量中的每个值都会变异为这些值。至少，这就是 VS 2011 告诉我的值，当我在以下函数的本地范围内查看它们时（这是唯一使用它们的地方）。

int FragmentCost(double skillLevel, int duration, FragmentCostParameters FCP){
    return max((int)(ceil(FCP.multFactor*(skillLevel-FCP.subtractFactor))*ceil(duration/30.0)) , 0);
}

唯一调用 FragmentCost 的地方是来自下面的这个函数，它应该传递不同的值.. 但是在这个过程中的某个地方，当我查看 FragmentCost 中的局部变量时，它们始终是类的构造函数中的默认值.

//given a skill level + duration, will return an array with the fragment usage
int* regularTotalFragCost(int skillLevel, int duration){
    int fragments[7] = {0,0,0,0,0,0,0};
    fragments[0]+= FragmentCost(skillLevel,duration, FCPs[0]);
    fragments[1]+= FragmentCost(skillLevel,duration, FCPs[0]);
    fragments[0]+= FragmentCost(skillLevel,duration, FCPs[1]);
    fragments[2]+= FragmentCost(skillLevel,duration, FCPs[1]);
    fragments[0]+= FragmentCost(skillLevel,duration, FCPs[2]);
    fragments[3]+= FragmentCost(skillLevel,duration, FCPs[2]);
    fragments[0]+= FragmentCost(skillLevel,duration, FCPs[3]);
    fragments[4]+= FragmentCost(skillLevel,duration, FCPs[3]);
    fragments[0]+= FragmentCost(skillLevel,duration, FCPs[4]);
    fragments[5]+= FragmentCost(skillLevel,duration, FCPs[4]);
    fragments[0]+= FragmentCost(skillLevel,duration, FCPs[5]);  
    fragments[6]+= FragmentCost(skillLevel,duration, FCPs[5]);
    return fragments;
}

出于某种原因，我觉得我在某个地方犯了一个非常愚蠢的错误，但对于我的生活，我似乎无法弄清楚。我将不胜感激任何人可以提供的任何帮助和/或建议。

编辑：如果一切正常，这就是fragments[]inregularTotalFragCost的值应该skillLevel = 250是什么，使用几个测试值（和duration = 30）

FCPs[0] : Fragments: 13, 13, 0, 0, 0, 0, 0, 
FCPs[1] : Fragments: 17, 15, 2, 0, 0, 0, 0, 
FCPs[2] : Fragments: 20, 14, 5, 1, 0, 0, 0, 
FCPs[3] : Fragments: 29, 14, 9, 5, 1, 0, 0, 
FCPs[4] : Fragments: 32, 13, 10, 7, 2, 0, 0, 
FCPs[5] : Fragments: 32, 13, 10, 7, 2, 0, 0,

这是他们现在的情况：

FCPs[0] : Fragments: 78, 13, 13, 13, 13, 13, 13, 
FCPs[1] : Fragments: 78, 13, 13, 13, 13, 13, 13, 
FCPs[2] : Fragments: 78, 13, 13, 13, 13, 13, 13, 
FCPs[3] : Fragments: 78, 13, 13, 13, 13, 13, 13, 
FCPs[4] : Fragments: 78, 13, 13, 13, 13, 13, 13, 
FCPs[5] : Fragments: 78, 13, 13, 13, 13, 13, 13,
4

3 回答 3

4 
vector<FragmentCostParameters> FCPs(6);

创建一个包含 6 个默认构造值的向量，编号为 0-5。

FCPs.push_back(FragmentCostParameters(.05, 0));

在索引 6 处增加价值

于 2013-09-15T02:01:53.600 回答
3

int fragments[7]是堆栈上的局部变量。一旦该函数返回，该内存就不再有效。您正在返回一个指向该局部变量的指针，并且对该内存的任何访问都是未定义的行为。

相反，返回一个std::array：

std::array<int, 7> fragments = {}; // value initialize

return fragments;
于 2013-09-15T01:57:37.790 回答
0

提示：在你 push_back 你的 FCP 之后你的向量有多大？

于 2013-09-15T02:01:13.243 回答