"onEachSubelement (...)" metodo per C++

Question

Spesso mi imballo alcuni dati in class per evitare errori con accesso pubblico/globale e per fornire alcuni metodi comuni su di esso, ad esempio:

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

GameArea è solo un esempio semplificato qui. Sarebbe una specie di container/menager personalizzato con alcuni metodi specializzati (ma non è solo un contenitore).

La situazione ideale è quando so che cosa saranno eseguite operazioni su ogni Enemy subito e si verificano in diversi luoghi modo che io possa dichiarare GameArea direttamente (come makeAllEnemiesScared()).

Per gli altri casi posso andare con:

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

Ma soffre di alcuni svantaggi:

• non posso usare C++ 11 pulito & bello for(auto &Enemy : enemies) ciclo,
• Non è efficiente (così tante chiamate allo getEnemy(index)),
• Non è un scopo per getEnemy(index) per iterare gettare tutti gli elementi - è utile nel caso in cui vogliamo selezionare solo uno o alcuni di essi, ha anche il controllo per index < enemies.size() all'interno - è terribile controllarlo su ogni elemento in loop.

NOTA: penso a casi in cui faccio qualcosa di molto speciale (non vale la pena la creazione di metodo separato in GameArea, ma su ogni elemento diGameArea::enemies).

Ho pensato ad un metodo GameArea::onEachEnemy(... function ...) che prende come parametro un function (o forse meglio un lambda?). Questa è una buona soluzione?

O forse un approccio diverso dovrebbe essere usato qui? Come restituire il std::vector da GameArea - che mi sembra un po '"brutto". Non voglio che l'utente pensi che possa effettivamente aggiungere o rimuovere elementi da/a quello vector direttamente.

Answer 1

Una buona soluzione, che non espone interni delle classi è, come lei ha suggerito, una funzione di chiamata di un'azione per ogni oggetto:

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

Poi si può passare tutto quello che vuoi come ForEachEnemy argomento - funzione globale, boost::bind risultato ecc

Answer 2

Se si espone il vettore stesso, o almeno iteratori begin e end, è possibile utilizzare std::for_each

allora si potrebbe utilizzare questo come

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

dove foo è la funzione che si desidera chiamare su ogni Enemy.

notare Anche in questo caso non c'è bisogno di esporre il vettore stesso, si potrebbe fare metodi in GameArea per ottenere iteratori quindi la chiamata potrebbe essere come

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

Answer 3

Si potrebbe prendere in considerazione il modello Iterator. In questo modo puoi mantenere l'incapsulamento ma hai ancora qualcosa che è comodo da usare.

È possibile visualizzare gli iteratori di contenitore standard oppure, se si desidera completare l'incapsulamento, scrivere personalmente l'Iterator. Se si scrive correttamente l'Iterator si può anche utilizzare C++ 11 gamma-based per cicli:

#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"; 
} 

Affinché C++ 11 variava-based per i cicli di lavorare con GameArea è necessario fare una delle seguenti:

• definire inizio e funzioni membro finali
• define iniziano e finiscono le funzioni di terzi nello stesso namespace
• specializzati std :: iniziare e std :: end