代码之家 › 专栏 › 技术社区 › Marm0t

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

cuda object class c++

Marm0t · 技术社区 · 15 年前

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'现在是数组,我做标量加法而不是'adding'。运行时有时我需要“a”而不是“b”或“c”,这样我就可以重写为:

Value+=AddElement.get_a();

有没有一种方法来选择我要初始化并在运行时稍后使用的元素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;如果不希望包含'a',FlagA=0(FlagB和FlagC相同)。如果数组“a”非常大,这将非常昂贵。

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

编辑2

编辑3 我相信我需要做的是使用虚拟函数。我想以同样的方式调用这个函数,只是让它执行一个特定于案例的函数。

编辑4 如果有人看一下我的解决方案,我会很感激——也许它太“异国情调”,而且有一个更简单的方法来实现同样的目的。谢谢你的建议!

编辑5 多亏了另一个用户,我研究了战略设计模式——这正是我用来解决这个问题的解决方案。我以前从来没听说过这个问题,最后我重新思考了一个已经解决的问题(花了一段时间才有人提到这个问题)。所以解决办法是:

5 回复 | 直到 15 年前

Björn Pollex 15 年前

你给你的班级提供了一个方法 GetSumOfActiveElements 这个名字就是这么说的。您可以使这个类成为虚拟的,并为每个场景创建子类,或者让这个类以其他方式有效地管理内存。

Steve Townsend 15 年前

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> .

如果你允许附加条件,你可以 vector

Chubsdad 15 年前

这个粗略的代码大纲对你有用吗?

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++]))();
}

编辑二:@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
}

Marm0t 15 年前

所以我想我明白了-

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。。。

Cheers and hth. - Alf 15 年前

std::vector 元素?

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