Wie zähle ich nicht gelöschte Instanzen im Array von Instanzen?

Question

Ich habe eine Reihe von Fällen, in meinem Code wie folgt aus:

class Squad : public ISquad 
{ 
    public: 
     Squad(void); 
     Squad(Squad const & src); 
     virtual ~Squad(void); 

     int    getCount(void) const; 
     int    push(ISpaceMarine*); 
     ISpaceMarine* getUnit(int) const; 

     ISpaceMarine**    getUnits(void) const; 
     int       getCapacity(void) const; 

     Squad &  operator=(Squad const & rhs);  

    private: 
     ISpaceMarine **_units; // HERE IS THE ARRAY OF INSTANCES 
     int const  _squadCapacity; 

}; 

wie diese Initialized im Konstruktor

Squad::Squad(void) : _units(new ISpaceMarine*[64]), _squadCapacity(64) 
{ 
    return; 
} 

Erstens ist das der gute Weg zu tun?

Wenn ja, versuche ich die Anzahl der gültigen Instanzen im Array zu zählen (nicht NULL, nicht deleted), aber ich weiß nicht, wie man zum Beispiel überprüft, ob _units[20] gelöscht wird.

Wie kann ich es tun?

Er ist meine aktuelle Art und Weise zu tun:

int       Squad::getCount(void) const 
{ 
    int  count = 0; 
    while (this->_units[count] != NULL && count < this->_squadCapacity) 
     count++; 
    return count; 
} 

Answer 1

ISpaceMarine **_units; // HERE IS THE ARRAY OF INSTANCES 
    int const  _squadCapacity; 

- Erstens ist das der gute Weg zu tun?

Nein, das ist kein guter Weg, um zu zeigen, warum die Standard Container und Smart Pointer eine große Verbesserung darstellen.

Mit intelligenten Zeigern drücken Sie aus und befassen sich automatisch mit Eigentumsrechten.

Ich habe den Eindruck, die verwaltet die SpaceMarines, in diesem Fall sollten Sie std::unique_ptr verwenden. Ihre Squad wird dann so aussehen wie

class Squad : public ISquad 
{ 
    public: 
    size_t    getCount() const; 
    void    push(ISpaceMarine&&); 
    using SpaceMarineIterator = std::vector<std::unique_ptr<SpaceMarine>>::iterator; 
    // A typedef/using for this iterator would be appropriate. 
    SpaceMarineIterator getUnit(int) const; 
    // And this 
    SpaceMarineIterator begin() const; 
    SpaceMarineIterator end() const; 

    size_t       getCapacity() const; 
    // no need for copy assign either. 
    //Squad &  operator=(Squad const & rhs);  

    private: 
    std::vector<std::unique_ptr<ISpaceMarine>> units; 
    // No need for capacity. 
}; 

Nun, wenn Sie ein anderes Modell für den Besitz benötigen können Sie sich in std::shared_ptr und std::weak_ptr. Ihr Modell sollte sich jedoch bemühen, mit std::unique_ptr zu arbeiten.

Hinweis: Entsorgen Sie die Möglichkeit,

std::vector<SpaceMarine> units;