cocos2dx 3.0 ---- Vector, Map

Vector其实就是对std::vector封装而来
Map则默认是从std::unordered_map封装来的，如果想用std::map的话，则需要修改CCMap.h中的USE_STD_UNORDERED_MAP宏为0

PS: std::unordered_map 是哈希表，查找是O(1)。std::map查找是O(n)。

路径

1 2	base/CCVector.h base/CCMap.h

源代码

由于Vector和Map都是从STL封装而来，需要对原生的比较熟悉。

Vector

template<class T>
class CC_DLL Vector
{
public:
    /**
     * typedef迭代器
     */
    typedef typename std::vector<T>::iterator iterator;
    typedef typename std::vector<T>::const_iterator const_iterator;
    
    typedef typename std::vector<T>::reverse_iterator reverse_iterator;
    typedef typename std::vector<T>::const_reverse_iterator const_reverse_iterator;
    
    iterator begin() { return _data.begin(); }
    const_iterator begin() const { return _data.begin(); }
    
    iterator end() { return _data.end(); }
    const_iterator end() const { return _data.end(); }
    
    const_iterator cbegin() const { return _data.cbegin(); }
    const_iterator cend() const { return _data.cend(); }
    
    reverse_iterator rbegin() { return _data.rbegin(); }
    const_reverse_iterator rbegin() const { return _data.rbegin(); }
    
    reverse_iterator rend() { return _data.rend(); }
    const_reverse_iterator rend() const { return _data.rend(); }
    
    const_reverse_iterator crbegin() const { return _data.crbegin(); }
    const_reverse_iterator crend() const { return _data.crend(); }
    
    /* 构造函数 */
    Vector<T>()
    : _data()
    {
        /* c++11新特性 */

        /* static_assert 静态断言，用于模板调试，在编译时确定 */

        /* std::is_convertible 判断T是否是Ref的子类 */
        /* 此处默认 T 是一个对象指针类型，如果不是的话， 就直接报错了*/
        static_assert(std::is_convertible<T, Ref*>::value, "Invalid Type for cocos2d::Vector<T>!");
    }
    
    /* 带容量的构造函数 */
    explicit Vector<T>(ssize_t capacity)
    : _data()
    {
        static_assert(std::is_convertible<T, Ref*>::value, "Invalid Type for cocos2d::Vector<T>!");
        CCLOGINFO("In the default constructor with capacity of Vector.");
        reserve(capacity);
    }

    /* 析构函数 */
    ~Vector<T>()
    {
        CCLOGINFO("In the destructor of Vector.");
        clear();
    }

    /* 拷贝构造函数 */
    Vector<T>(const Vector<T>& other)
    {
        static_assert(std::is_convertible<T, Ref*>::value, "Invalid Type for cocos2d::Vector<T>!");
        CCLOGINFO("In the copy constructor!");
        _data = other._data;
        addRefForAllObjects();
    }
    
    /* c++11新特性 std::move */
    Vector<T>(Vector<T>&& other)
    {
        static_assert(std::is_convertible<T, Ref*>::value, "Invalid Type for cocos2d::Vector<T>!");
        CCLOGINFO("In the move constructor of Vector!");
        _data = std::move(other._data);
    }
    
    Vector<T>& operator=(const Vector<T>& other)
    {
        if (this != &other) {
            CCLOGINFO("In the copy assignment operator!");
            clear();
            _data = other._data;
            addRefForAllObjects();
        }
        return *this;
    }
    
    /* 赋值操作符 */
    Vector<T>& operator=(Vector<T>&& other)
    {
        if (this != &other) {
            CCLOGINFO("In the move assignment operator!");
            clear();
            _data = std::move(other._data);
        }
        return *this;
    }
    
    /* 扩容 */
    void reserve(ssize_t n)
    {
        _data.reserve(n);
    }
    
    /* 设置容量 */
    ssize_t capacity() const
    {
        return _data.capacity();
    }
    
    /* 当前大小 */
    ssize_t size() const
    {
        return  _data.size();
    }
    
    /* 是否为空 */
    bool empty() const
    {
        return _data.empty();
    }
    
    /* 最大size, 不是实际大小 */
    ssize_t max_size() const
    {
        return _data.max_size();
    }
    
    /* 找下标 */
    ssize_t getIndex(T object) const
    {
        auto iter = std::find(_data.begin(), _data.end(), object);
        if (iter != _data.end())
            return iter - _data.begin();

        return -1;
    }

    /* 查找 */
    const_iterator find(T object) const
    {
        return std::find(_data.begin(), _data.end(), object);
    }
    
    iterator find(T object)
    {
        return std::find(_data.begin(), _data.end(), object);
    }
    
    /* 根据下标返回元素 */
    T at(ssize_t index) const
    {
        CCASSERT( index >= 0 && index < size(), "index out of range in getObjectAtIndex()");
        return _data[index];
    }

    /* 返回第一个元素 */
    T front() const
    {
        return _data.front();
    }
    
    /* 最后一个元素 */
    T back() const
    {
        return _data.back();
    }

    /* 随机返回一个元素 */
    T getRandomObject() const
    {
        if (!_data.empty())
        {
            ssize_t randIdx = rand() % _data.size();
            return *(_data.begin() + randIdx);
        }
        return nullptr;
    }

    /* 查找是否有该元素 */
    bool contains(T object) const
    {
        return( std::find(_data.begin(), _data.end(), object) != _data.end() );
    }

    /* 判断两个Vector是否相等 */
    bool equals(const Vector<T> &other)
    {
        ssize_t s = this->size();
        if (s != other.size())
            return false;
        
        for (ssize_t i = 0; i < s; i++)
        {
            if (this->at(i) != other.at(i))
            {
                return false;
            }
        }
        return true;
    }

    /* 入栈 */
    void pushBack(T object)
    {
        CCASSERT(object != nullptr, "The object should not be nullptr");
        _data.push_back( object );
        object->retain();
    }
    
    /* 从另外一个Vector加入到当前Vector */
    void pushBack(const Vector<T>& other)
    {
        for(const auto &obj : other) {
            _data.push_back(obj);
            obj->retain();
        }
    }

    /* 根据下标插入元素 */
    void insert(ssize_t index, T object)
    {
        CCASSERT(index >= 0 && index <= size(), "Invalid index!");
        CCASSERT(object != nullptr, "The object should not be nullptr");
        _data.insert((std::begin(_data) + index), object);
        object->retain();
    }
    
    /* 出栈 */
    void popBack()
    {
        CCASSERT(!_data.empty(), "no objects added");
        auto last = _data.back();
        _data.pop_back();
        last->release();
    }
    
    /* 删除某对象 */
    /* removeAll 是表示是否删除所有相同值的对象 */
    void eraseObject(T object, bool removeAll = false)
    {
        CCASSERT(object != nullptr, "The object should not be nullptr");
        
        if (removeAll)
        {
            for (auto iter = _data.begin(); iter != _data.end();)
            {
                if ((*iter) == object)
                {
                    iter = _data.erase(iter);
                    object->release();
                }
                else
                {
                    ++iter;
                }
            }
        }
        else
        {
            auto iter = std::find(_data.begin(), _data.end(), object);
            if (iter != _data.end())
            {
                _data.erase(iter);
                object->release();
            }
        }
    }

    /* 根据迭代器删除元素 */
    iterator erase(iterator position)
    {
        CCASSERT(position >= _data.begin() && position < _data.end(), "Invalid position!");
        (*position)->release();
        return _data.erase(position);
    }
    
    /* 删除两个迭代器之间的元素 */
    iterator erase(iterator first, iterator last)
    {
        for (auto iter = first; iter != last; ++iter)
        {
            (*iter)->release();
        }
        
        return _data.erase(first, last);
    }
    
    /* 根据下标删除元素 */
    iterator erase(ssize_t index)
    {
        CCASSERT(!_data.empty() && index >=0 && index < size(), "Invalid index!");
        auto it = std::next( begin(), index );
        /* 先release下 */
        (*it)->release();
        return _data.erase(it);
    }

    /* 遍历所有元素 */
    /* 将所有元素release一下 */
    /* 清空数组 */
    void clear()
    {
        for( auto it = std::begin(_data); it != std::end(_data); ++it ) {
            (*it)->release();
        }
        _data.clear();
    }

    /* 根据元素地址交换对象 */
    void swap(T object1, T object2)
    {
        ssize_t idx1 = getIndex(object1);
        ssize_t idx2 = getIndex(object2);

        CCASSERT(idx1>=0 && idx2>=0, "invalid object index");

        std::swap( _data[idx1], _data[idx2] );
    }
    
    /* 根据元素下标交换对象 */
    void swap(ssize_t index1, ssize_t index2)
    {
        CCASSERT(index1 >=0 && index1 < size() && index2 >= 0 && index2 < size(), "Invalid indices");

        std::swap( _data[index1], _data[index2] );
    }

    /* 替换对象 */
    void replace(ssize_t index, T object)
    {
        CCASSERT(index >= 0 && index < size(), "Invalid index!");
        CCASSERT(object != nullptr, "The object should not be nullptr");
        
        _data[index]->release();
        _data[index] = object;
        object->retain();
    }

    /* 反转数组 */
    void reverse()
    {
        std::reverse( std::begin(_data), std::end(_data) );
    }
    
    /** Shrinks the vector so the memory footprint corresponds with the number of items */
    void shrinkToFit()
    {
        _data.shrink_to_fit();
    }
    
protected:
    
    /* 为Vector中的所有对象retian一下下 */
    void addRefForAllObjects()
    {
        for(const auto &obj : _data) {
            obj->retain();
        }
    }
    
    std::vector<T> _data;
};

上述代码中有许多c++11的特性，先来看看构造函数中的代码

1	static_assert(std::is_convertible<T, Ref*>::value, "ERROR INFO");

static_assert是静态断言，用于模板编程的调试，在编译时就可以引发断言
std::is_convertible是判断*T类是否为Ref的子类，因为在Vector中的操作包含retain/release

比如说我们写如下下面就会报错

class A : public cocos2d::Ref
{
public:
    A() {};
    ~A() {};
};

int main() 
{
    cocos2d::Vector<A*> va; // 正确方法
    cocos2d::Vector<A> va;  // 直接编译报错！
    return 0;
}

有时候需要自定义类型且不从cocos2d::Ref继承过来，就只能用std::vector了。

然后，我比较疑惑的地方在于std::move什么的。
还是附上一些链接

cppreference – std::move
关于C++11中的std::move和std::forward

源码中注释掉了这么一段代码

T& operator[](int index)
{
    return _data[index];
}

const T& operator[](int index) const
{
    return _data[index];
}

不对[]运算符进行重载的原因在于，你在用[]的时候无法判断是否应该retain/release
所以源码的注释中也提示不要使用下标运算符。

就比如说一下代码：

cocos2d::Vector<Sprite*> sv;

Sprite *pS = Sprite::create();

sv.pushBack(pS);

/* 这个时候不需要retain/release */
sv[0];

/* 这个时候就需要了 */
sv[0] = Sprite::create(); // 用 replace 来替代

Map

关于Map的话，从封装的思路上和Vector是一样的。

不要用[]运算符
对于Map中的*V必须是Ref的子类

唯一值得关注的就是Map中有一个USE_STD_UNORDERED_MAP的宏去控制是否需要使用std::map，因为默认是使用std::unordered_map的。

这里就不贴上代码了。

总结

其实对于Vector和Map，我用的不是很多，大多时候就直接使用STL。
分析Vector和Map实际上还是对阅读源码有帮助。

Hexococos2dx 3.0 ---- Vector, Map 2014-12-10

路径

源代码

Vector

Map

总结