如何动态创建方法，在运行时

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”现在阵列和的，而不是“加”我做的标量增加。在运行时有时我需要“一个”，但不能“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; 

其中FLAGA = 1，如果你想用“A”中添加或0，如果你不希望它被包含（同为FlagB和FlagC）。如果数组'a'非常大，这是昂贵的。

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

编辑2 我还忘了补充一点，另外的实施过程中，我可以不使用任何条件语句（这会在CUDA内核使用，我不能有任何线程diverngance - 我希望避免提及CUDA，因为这完全是一个C++的问题）

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

编辑4 如果有人拍了一下我的解决方案，我将不胜感激 - 也许它太“异国情调”，有一个更简单的实现同样的目的方法。感谢所有的建议！

编辑5 感谢其他用户，我查看了战略设计模式 - 这正是我用于解决此问题的解决方案。之前我从来没有听说过这个消息，最终反思了一个已经完成的问题（花了一段时间让某个人提到它）。所以解决方案： 在运行时确定算法=战略设计模式。

Answer 1

您提供您的类的方法GetSumOfActiveElements，不只是名字说什么。你可以让这个类变为虚拟的并为每个场景创建子类，或者让这个类以其他方式有效地管理内存。

Answer 2

元素的std::vector怎么样？

问题规格有点不清楚，至少可以说，但我认为这将适用于你。

干杯&心连心，

Answer 3

这是粗略的代码大纲吗？

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 4

什么这样的事情？

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 5

所以我觉得我得到了它 -

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-> AddValues（）”执行添加。实现可以由程序开始时的标志确定，然后我可以为每个需要满足的条件编写不同的类，然后让我的多态类继承基类的属性。

对不起，如果我没有完全定义我的问题，或声明是模糊的 - 我真的不知道如何做我正在解释，但知道这是可能的。这是否正确？有没有更高效的方法？

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