Question

我有一节课，说

class AddElement{
    int a,b,c;
}

使用设置/获取a，b，c的方法......我的问题肯定是一个逻辑问题 - 比如我按如下方式实现AddElement：

int Value=1;
Value+=AddElement.get_a()+AddElement.get_b()+AddElement.get_b();

现在想象我想做上面的事情，除了'a，b，c'现在是数组，而不是'添加'我做标量加法。在运行时有时我需要'a'而不是'b'或'c'，所以我可以重写为：

Value+=AddElement.get_a();

（当然+ =被重载以表示标量加法...而且值与a的大小相同） - 其他时候我可能只需要添加b或c等...

有没有办法选择哪些元素a，b，c，我想初始化并在运行时使用？（即如果我不打算使用它，我不想malloc一个巨大的数组。）

最后我需要一个具有a，b，c然后可以对a，b或c的任意组合进行操作的方法的类 - 让用户在运行时定义他们需要的方法（通过某种标志）或配置文件）。

目前我正在做以下事情：

Value+=AddElement.get_a()*FlagA+AddElement.get_b()*FlagB+AddElement.get_c()*FlagC;

如果你想在加法中使用'a'，那么FlagA = 1;如果你不想包含它，则为0（对于FlagB和FlagC，它是相同的）。如果数组'a'非常大，则成本很高。

我可能只是想不够努力，但这个问题一直困扰着我。如果你需要我更好地定义问题，我会尝试，但我相信这足以让我明白我的观点。

编辑2 我也忘了添加我在添加的实现过程中不能使用任何条件（这将在CUDA内核中使用，我不能有任何线程分歧 - 我希望避免提及CUDA，因为这是完全是一个c ++问题）

编辑3 我相信我需要做的是使用虚函数。我想以相同的方式调用该函数，除非它执行特定于案例的函数。

编辑4 如果有人看了我的解决方案，我将不胜感激 - 也许它太'异国情调'而且有一种更简单的方法来实现同样的目的。感谢您的所有建议！

编辑5 感谢另一位用户，我查看了战略设计模式 - 这正是我用于此问题的解决方案。我之前从未听说过，最后重新思考已经完成的问题（花了一些时间让某人提一下这个问题）。所以解决方案：在运行时确定算法=战略设计模式。

Answer 1

您为自己的班级提供的方法GetSumOfActiveElements正如名称所示。您可以将此类设置为虚拟并为每个方案创建子类，或让类以其他方式有效地管理内存。

Answer 2

这个粗略的代码大纲是否适合您？

struct S{
    int getx() {return 0;}
    int gety() {return 0;}
    int getz() {return 0;}
};

int main(){
    int (S::*p[3])(); // allocate as per need
    p[0] = &S::getx;  // populate as per need at run time
    p[1] = &S::gety;
    p[2] = 0;

    int val = 1;
    S obj;

    int nCount = 0;

    while(p[nCount] != 0)
        val += (obj.*(p[nCount++]))();
}

编辑2：@Steve Townsend：没错。我错过了有条件的东西。

这个怎么样。

struct S{
    int getx() {return 0;}
    int gety() {return 0;}
    int getz() {return 0;}
    S(){}
    S(S &obj, int (S::*p)()){
        val += (obj.*p)();
    }
    static int val;
};

int S::val = 0;

int main(){
    S obj;
    S buf[] = {S(obj, &S::getx), S(obj, &S::gety)};  // the magic happens here in
                                                      // the constructor
}

Answer 3

这样的事情怎么样？

vector<pair<int, bool>> values(3);
values[0].first = 1;
values[0].second = false;

values[1].first = 2;
values[1].second = true;

values[2].first = 3;
values[2].second = false;

int sum = values[0].first * values[0].second + 
          values[1].first * values[1].second + 
          values[2].first * values[2].second;

您可以使用仿函数和<algorithm>来使其更清晰/可扩展。

我不清楚为什么条件是坏事 - 我认为乘法将会更加昂贵。这是CUDA限制还是特质？

如果您允许条件，则可以使vector成员成为封装值和使用中标志的类，并使用过滤算法根据需要执行聚合。

Answer 4

所以我想我明白了 -

struct S{
    int x,y;
    bool needx,needy;
};

class AnyFunction {
    protected:
        S Vals;
        int TotalValue;
    public:
        virtual void SetValues(void) =0;
        virtual void AddValues(void) =0;
}

class ImplementationFunc1 : public AnyFunction {
    public:
    void SetValues(S * Vals) { S.x=Vals->xval; }
    void AddValues(void){ TotalValue+=Vals->x; }
}

class ImplementationFunc2 : public AnyFunction {
    public:
    void SetValues(S * Vals) {S.x=Vals->xval;S.y=Vals->yval;}
    void AddValues(void){ TotalValue+=(Vals->x+Vals->y); }
}

int main(){
S SVals;
AnyFunction * APointerToAnyFunction;
// read a file that says if we need either x or y
SVals.needx=true; // (i.e. read from file)
SVals.needy=false; // (read from file)

if(Svals.needx){
    SVals.x=Xfromfile;
    if (Svals.needy){
        ImplementationFunc2 Imp1;
        SVals.y=yfromfile;
        APointerToAnyFunction=&Imp1;
    }
    else{
        ImplementationFunc1 Imp2;
        APointerToAnyFunction=&Imp2;
   }
}
...
// blah set some values
...

// So now I can call the function the same way (i.e. the call is always the same, no matter what kind of addition it needs to do), but I have all
// the logic for the conditions done _outside_ the addition
APointerToAnyFunction->AddValues();

所以基本上应该这样做！不，我可以使用该调用：“APointerToAnyFunction-＆gt; AddValues（）”执行添加。实现可以通过程序开头的标志来确定，然后我可以为我需要满足的每个条件编写一个不同的类，然后让我的多态类继承基类的属性。

很抱歉，如果我没有完全定义我的问题，或者声明含糊不清 - 我真的不知道如何做我正在解释的内容，但知道这是可能的。这是正确的方法吗？有更有效的方法吗？

感谢所有回复的人。当然，当x和y是数组时，我会在必要时动态分配x和y ......

Answer 5

std::vector个元素怎么样？

问题规范有点不清楚，至少可以说，但我认为会对你有用。

干杯＆amp;第h。，

如何动态创建方法来操作在运行时初始化的类对象

5 个答案: