如何動態創建方法，在運行時

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