Cocos2d-x3.1Vector的使用

//.h
class VectorUnitLayout : public Layout
{
public:
    CREATE_FUNC(VectorUnitLayout);
    virtual bool init();
    void constFunc(const Vector<Node*> &vec) const;
    
};

//.cpp
bool VectorUnitLayout::init()
{
    bool bRet = false;
    do{
        CC_BREAK_IF(!Layout::init());
        Vector<Node*> vec;
        CCASSERT(vec.empty(), "");
        CCASSERT(vec.capacity() == 0, "");//容器剩余容量
        CCASSERT(vec.size() == 0, "");
        CCASSERT(vec.max_size() > 0, "");
        
        auto node1 = Node::create();//引用计数为1
        node1->setTag(1);
        vec.pushBack(node1);//引用计数+1
        CCASSERT(node1->getReferenceCount() == 2, "");//得到引用计数
        
        auto node2 = Node::create();
        node2->setTag(2);
        vec.pushBack(node2);
        CCASSERT(vec.getIndex(node1) == 0, "");
        CCASSERT(vec.getIndex(node2) == 1, "");
        
        auto node3 = Node::create();
        node3->setTag(3);
        vec.insert(1, node3);
        CCASSERT(vec.at(0)->getTag() == 1, "");
        CCASSERT(vec.at(1)->getTag() == 3, "");
        CCASSERT(vec.at(2)->getTag() == 2, "");

        //Test copy constructor
        Vector<Node*> vec2(vec);
        CCASSERT(vec2.size() == vec.size(), "");
        ssize_t size = vec.size();
        for(ssize_t i = 0; i < size; i++)
        {
            CCASSERT(vec2.at(i) == vec.at(i), "");
            CCASSERT(vec.at(i)->getReferenceCount() == 3, "");
            CCASSERT(vec2.at(i)->getReferenceCount() == 3, "");
        }
        
        //Test copy assignment operator
        Vector<Node*> vec3;
        vec3 = vec2;
        CCASSERT(vec3.size() == vec2.size(), "");
        size = vec3.size();
        for(ssize_t i = 0; i < size; ++i)
        {
            CCASSERT(vec3.at(i) == vec2.at(i), "");
            CCASSERT(vec3.at(i)->getReferenceCount() == 4, "");
            CCASSERT(vec2.at(i)->getReferenceCount() == 4, "");
            CCASSERT(vec.at(i)->getReferenceCount() == 4, "");
        }
        
        //Test move constructor
        auto createVector = [this](){
            Vector<Node*> ret;
            for(int i = 0; i < 20; i++)
            {
                ret.pushBack(Node::create());
            }
            int j = 1000;
            for(auto& child : ret)
            {
                child->setTag(j++);
            }
            return ret;
        };
        
        Vector<Node*> vec4(createVector());
        for(const auto& child : vec4)
        {
            CC_UNUSED_PARAM(child);
            CCASSERT(child->getReferenceCount() == 2, "");
        }
        
        //Test init Vector<T> with capacity
        Vector<Node*> vec5(10);
        CCASSERT(vec5.capacity() == 10, "");
        vec.reserve(20);//储备
        CCASSERT(vec.capacity() == 20, "");
        
        CCASSERT(vec5.size() == 0, "");
        CCASSERT(vec5.empty(), "");
        
        auto toRemovedNode = Node::create();
        vec5.pushBack(toRemovedNode);
        CCASSERT(toRemovedNode->getReferenceCount() == 2, "");
        
        //Test move assignment operator
        vec5 = createVector();
        CCASSERT(toRemovedNode->getReferenceCount() == 1, "");
        CCASSERT(vec5.size() == 20, "size should be 20");
        for(const auto& child : vec5)
        {
            CC_UNUSED_PARAM(child);
            CCASSERT(child->getReferenceCount() == 2, "");
        }
        
        //Test Vector<T>::find
        CCASSERT(vec.find(node3) == (vec.begin() + 1), "");
        CCASSERT(std::find(std::begin(vec),std::end(vec),node2) == (vec.begin() + 2), "");
        CCASSERT(vec.front()->getTag() == 1, "");
        CCASSERT(vec.back()->getTag() == 2, "");
        CCASSERT(vec.getRandomObject(), "");//随机获取对象
        CCASSERT(!vec.contains(Node::create()), "");
        CCASSERT(vec.contains(node1), "");//包含
        CCASSERT(vec.contains(node2), "");//包含
        CCASSERT(vec.contains(node3), "");//包含
        CCASSERT(vec.equals(vec2), "");
        CCASSERT(vec.equals(vec3), "");
        
        //Insert
        vec5.insert(2, node1);
        CCASSERT(vec5.at(2)->getTag() == 1, "");
        CCASSERT(vec5.size() == 21, "");
        vec5.back()->setTag(100);
        vec5.popBack();
        CCASSERT(vec5.size() == 20, "");
        CCASSERT(vec5.back()->getTag() != 100, "");
        
        //Erase and clear
        Vector<Node*> vec6 = createVector();
        Vector<Node*> vec7 = vec6;
        
        CCASSERT(vec6.size() == 20, "");
        vec6.erase(vec6.begin()+1);
        CCASSERT(vec6.size() == 19, "");
        CCASSERT((*(vec6.begin() + 1))->getTag() == 1002, "");
        vec6.erase(vec6.begin() + 2, vec6.begin() + 10);
        CCASSERT(vec6.size() == 11, "");
        CCASSERT(vec6.at(0)->getTag() == 1000, "");
        CCASSERT(vec6.at(1)->getTag() == 1002, "");
        CCASSERT(vec6.at(2)->getTag() == 1011, "");
        CCASSERT(vec6.at(3)->getTag() == 1012, "");
        vec6.erase(3);
        CCASSERT(vec6.at(3)->getTag() == 1013, "");
        vec6.eraseObject(vec6.at(2));
        CCASSERT(vec6.at(2)->getTag() == 1013, "");
        vec6.clear();

        auto objA = Node::create();
        auto objB = Node::create();
        auto objC = Node::create();
        {
            Vector<Node*> array1;
            Vector<Node*> array2;
            
            array1.pushBack(objA);
            array1.pushBack(objA);
            array1.pushBack(objA);
            
            array2.pushBack(objA);//retain count is 5
            array2.pushBack(objB);//retain count is 2
            array2.pushBack(objC);//retain count is 2
            
            for(auto obj : array1)
            {
                array2.eraseObject(obj);
            }
            CCASSERT(objA->getReferenceCount() == 4, "");
        }
        CCASSERT(objA->getReferenceCount() == 1, "");
        
        {
            Vector<Node*> array1;
            array1.pushBack(objA); // retain count is 2
            array1.pushBack(objA); // retain count is 3
            array1.pushBack(objA); // retain count is 4
            CCASSERT(objA->getReferenceCount() == 4, "");
            array1.eraseObject(objA, true); // Remove all occurrences in the Vector.
            CCASSERT(objA->getReferenceCount() == 1, "");
            
            array1.pushBack(objA); // retain count is 2
            array1.pushBack(objA); // retain count is 3
            array1.pushBack(objA); // retain count is 4
            
            array1.eraseObject(objA, false);
            CCASSERT(objA->getReferenceCount() == 3, ""); // Only remove the first occurrence in the Vector.
        }
        
        //Check the retain count in vec7
        CCASSERT(vec7.size() == 20, "");
        for(const auto &child : vec7)
        {
            CC_UNUSED_PARAM(child);
            CCASSERT(child->getReferenceCount() == 2, "");
        }
        
        //sort
        Vector<Node*> vecForSort = createVector();
        std::sort(vecForSort.begin(), vecForSort.end(),[](Node* a, Node* b){
            return a->getTag() >= b->getTag();
        });
        
        for(int i = 0; i < 20; i++)
        {
            CCASSERT(vecForSort.at(i)->getTag()-1000 == (19-i), "");
        }
        
        //Reverse
        vecForSort.reverse();
        for(int i =0; i < 20; i++)
        {
            CCASSERT(vecForSort.at(i)->getTag() - 1000 == i, "");
        }
        
        //Swap
        Vector<Node*> vecForSwap = createVector();
        vecForSwap.swap(2, 4);
        CCASSERT(vecForSwap.at(2)->getTag() == 1004, "");
        CCASSERT(vecForSwap.at(4)->getTag() == 1002, "");
        vecForSwap.swap(vecForSwap.at(2), vecForSwap.at(4));
        CCASSERT(vecForSwap.at(2)->getTag() == 1002, "");
        CCASSERT(vecForSwap.at(4)->getTag() == 1004, "");
        
        //shrinkToFit缩小以适应
        Vector<Node*> vecForShrink = createVector();
        vecForShrink.reserve(100);//储备100个空间
        CCASSERT(vecForShrink.capacity() == 100, "");
        vecForShrink.pushBack(Node::create());
        vecForShrink.shrinkToFit();
        CCASSERT(vecForShrink.capacity() == 21, "");
        
        //get random object
        //set the seed by time
        
        srand((unsigned)time(nullptr));
        Vector<Node*> vecForRandom = createVector();
        log("<------begin------>");
        for(int i = 0; i < vecForRandom.size(); i++)
        {
            log("Vector: random object tag = %d",vecForRandom.getRandomObject()->getTag());
        }
        log("<-------end-------->");
        
        //self assignment自动赋值
        Vector<Node*> vecSelfAssign = createVector();
        vecSelfAssign = vecSelfAssign;
        CCASSERT(vecSelfAssign.size() == 20, "");
        for(const auto &child : vecSelfAssign)
        {
            CC_UNUSED_PARAM(child);
            CCASSERT(child->getReferenceCount() == 2, "");
        }
        
        vecSelfAssign = std::move(vecSelfAssign);
        CCASSERT(vecSelfAssign.size() == 20, "");
        
        for (const auto& child : vecSelfAssign)
        {
            CC_UNUSED_PARAM(child);
            CCASSERT(child->getReferenceCount() == 2, "");
        }
        
        //const at
        Vector<Node*> vecConstAt = createVector();
        constFunc(vecConstAt);
        
        bRet = true;
    }while(0);
    
    return bRet;
}

void VectorUnitLayout::constFunc(const Vector<cocos2d::Node *> &vec) const
{
    log("vec[8] = %d",vec.at(8)->getTag());
}