"onEachSubelement (...)" metoda C++

Question

często pakować jakieś dane do class aby uniknąć błędów z publicznym dostępem do Globalnej/i dostarczyć pewne wspólne sposoby na to, np:

class GameArea{ 
    std::vector<Enemy*> enemies; 
    std::wstring name; 
public: 
    void makeAllEnemiesScared(); 
    Enemy * getEnemy(unsigned index); 
}; 

GameArea jest tylko uproszczony przykład tutaj. Byłby to rodzaj niestandardowego kontenera/menager z pewnymi specjalistycznymi metodami (ale to nie tylko kontener).

Idealną sytuacją jest, gdy wiem, jakie operacje będą wykonywane na każdym Enemy naraz i występują one w kilku miejscach, więc mogę zadeklarować je w GameArea bezpośrednio (jak makeAllEnemiesScared()).

W innych przypadkach mogę iść z:

for(unsigned i=0; i<gameArea->getEnemiesCount(); i++){ 
    Enemy * enemy = gameArea->getEnemy(i); 
    ... 
} 

Ale cierpi z niektórych wad:

• Nie mogę korzystać z C++ 11 czystego & piękny for(auto &Enemy : enemies) pętli
• To nie jest wydajne (tyle połączeń do getEnemy(index)),
• To nie jest przeznaczenie dla getEnemy(index) do iterowania rzucania wszystkimi elementami - jest to użyteczne w przypadku, gdy chcemy wybrać pojedyncze lub kilka z nich, ma również sprawdzić dla index < enemies.size() wewnątrz - to jest okropne, aby sprawdzić to na każdym elemencie w pętli.

UWAGA: myślę o przypadkach, gdy robię coś wyjątkowego (nie warto stworzyć metodę oddzielony w GameArea, ale na każdym elemencie z GameArea::enemies).

Myślałem o pewnej metodzie GameArea::onEachEnemy(... function ...), która ma function (a może lepiej lambda?) Jako parametr. Czy to dobre rozwiązanie?

A może należy zastosować inne podejście? Podobnie jak zwrot std::vector z GameArea - który wygląda dla mnie trochę "brzydko". Nie chcę, aby użytkownik myślał, że może bezpośrednio dodawać lub usuwać elementy do/z tego numeru.

Answer 1

dobre rozwiązanie, które nie wystawiać wewnętrzne swoich klasach jest, jak sugeruje, funkcja nazywając akcję dla każdego obiektu:

class GameArea { 
... 
    template<typename Func> void ForEachEnemy(Func f) 
    { 
    std::for_each(enemies.begin(), enemies.end(), f); 
    } 
... 

Następnie można przekazać cokolwiek chcesz jako argumentu - ForEachEnemy funkcji globalnej boost::bind wyniku itp

Answer 2

Jeśli wystawiać sam wektor, albo przynajmniej iteratorów begin i end, można użyć std::for_each

Następnie należy użyć tego jako

std::for_each(std::begin(enemies), std::end(enemies), foo); 

gdzie foo jest funkcja chcesz wezwać każdy Enemy.

Znowu pamiętać, nie trzeba narażać sam wektor, można zrobić metod w GameArea dostać iteratory więc połączenie może być jak

std::for_each(gameArea->GetEnemyBegin(), gameArea->GetEnemyEnd(), foo); 

Answer 3

Być może warto wziąć pod uwagę wzór Iterator. W ten sposób możesz zachować hermetyzację, ale nadal masz coś wygodnego w użyciu.

Możesz wystawiać standardowe iteratory kontenerów lub jeśli chcesz kompletną enkapsulację, napisz Iterator samodzielnie. Jeśli piszesz iterator poprawnie można nawet użyć C++ 11 Zakres opartej na pętlach:

#include <vector> 
#include <string> 
#include <iostream> 

struct Enemy{ std::string name; }; 

class EnemyIterator { 
    friend class GameArea; 
private: 
    std::vector<Enemy>::iterator iterator; 
    EnemyIterator(std::vector<Enemy>::iterator it) : iterator(it){} 
public: 
    EnemyIterator& operator++() { ++iterator; return *this; } 
    Enemy& operator*() { return *iterator; } 
    friend bool operator!=(EnemyIterator lhs, EnemyIterator rhs) { 
    return lhs.iterator != rhs.iterator; 
    } 
}; 

class GameArea{ 
    std::vector<Enemy> enemies; 
public: 
    EnemyIterator begin() { return EnemyIterator(enemies.begin()); } 
    EnemyIterator end() { return EnemyIterator(enemies.end()); } 
    void addEnemy(std::string name) {enemies.push_back(Enemy{name}); } 
}; 

int main() { 
    GameArea area; 
    area.addEnemy("Kobold"); 
    area.addEnemy("Wraith"); 
    area.addEnemy("Ork"); 
    for (auto& enemy : area) 
     std::cout << enemy.name << "\n"; 
} 

Aby C++ 11 wahał pętle oparte na pracy z GameArea trzeba zrobić jeden:

• określić początek i funkcje składowe end
• definiują początek i koniec funkcji trzecich w tej samej przestrzeni nazw
• specjalizują się std :: rozpocząć i std :: end