Question

我的代码中有一组实例，如下所示：

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;

};

在构造函数

中初始化

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

首先，这是好方法吗？

如果是，我尝试计算数组中有效实例的数量（不是NULL，而不是deleted），但我不知道如何检查_units[20]是否被删除例如。

我该怎么做？

他是我现在的办法：

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;

- 首先，这是一个好方法吗？

不，这不是一个好方法，并且整齐地显示为什么std容器和智能指针是一个很大的改进。

使用智能指针，您可以自动表达和处理所有权。

我得到了Squad管理SpaceMarines的印象，在这种情况下，您应该使用std::unique_ptr。您的Squad会看起来像

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

现在，如果您需要不同的所有权模型，可以查看std::shared_ptr和std::weak_ptr。您的模型应尽力使用std::unique_ptr。

注意：不要放弃使用

的可能性

std::vector<SpaceMarine> units;

如何计算实例数组中未删除的实例？

1 个答案: