模拟一堆卡片的最佳容器

Question

我正在实现一个游戏，我正在寻找一个合适的容器来模拟一堆卡片。

强制条件：

1. 容器可以随机打乱（需要random iterators，不包括std::list）
2. 容器可以分类
3. 可以弹出第一个元素（从顶部抽一张牌）
4. 可以在末尾插入元素（将卡片丢弃到底部）

到目前为止，我使用的是std::vector<District>，其中District 是代表卡值的enum class。

Live demo

#include <vector>
#include <algorithm>

namespace Citadel
{
    enum class District
    {
        UNINITIALIZED,
        FORTRESS,
        MANOR,
        // etc
    };

    class DistrictDeck
    {
    public:
        void Setup(const std::vector<District>& availableDistricts)
        {
            // Simplified filling...
            for (const auto district : availableDistricts)
            {
                pileOfCards_.push_back(district);
            }

            // Once all cards have been pushed, shuffle them
            std::random_shuffle(std::begin(pileOfCards_), std::end(pileOfCards_));
        }

        // Pick a district card from top of the stack
        District Draw()
        {
            District district = District::UNINITIALIZED;

            if (pileOfCards_.size() > 0)
            {
                district = pileOfCards_.front();
                pileOfCards_.erase(std::begin(pileOfCards_));
            }

            return district;
        }

        // Put a district card below the bottom of the stack
        void Discard(const District district)
        {
            pileOfCards_.push_back(district);
        }

    private:
        std::vector<District> pileOfCards_;
    };
}

int main()
{
}

在我的确切情况下，哪个容器可以替换 std::vector？

Answer 1

Vector 可以很好地满足您的目的。使用Fisher Yates Shuffle 可以最佳地执行洗牌 (O(n))。

我还应该注意，基于 std::random_shuffle 的复杂性，这看起来已经是您正在使用的。

Answer 2

首先，保留向量可能是一个不错的选择。

如果您必须经常移除卡片堆开头的元素，并且希望避免向量所需的大量移动，那么您可以选择 deque：

deque<int> q; 
default_random_engine rndgen;
q.push_front(11);
q.push_back(12);                     // requirement 4
q.push_front(15);
q.push_front(20); 
cout << q.front() <<endl;            // requirement 3
q.pop_front();                       //    "   "
cout << q.at(2)<<endl;               // + random access
sort(q.begin(), q.end());            // requirement 2
shuffle(q.begin(), q.end(), rndgen); // requirement 1

live demo

值得一提的是：双端队列具有随机迭代器，在恒定时间内在队列的开头或结尾执行插入/访问，虽然插入可能会使迭代器无效，但对元素的指针和引用仍然有效。

Answer 3

保持矢量怎么样？这似乎是一个合理的选择——你希望在那里保留多少张卡片？连续存储通常更可取，因为这样可以避免大多数内存访问性能问题。

如果您知道要使用的最大卡片数，也可以使用 std::array 或纯数组。

与往常一样，衡量您的表现，看看您是否确实存在性能问题。