Question

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

我的多个类实例：

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[]和regularTotalFragCost，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,

以下是他们现在的情况：

{{1}}

Answer 1

vector<FragmentCostParameters> FCPs(6);

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

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

在索引6处增加值

Answer 2

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

而是返回std::array：

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

return fragments;

Answer 3

提示：推送FCP后你的矢量有多大？

向量中的所有后推值都会更改为默认值

3 个答案: