Question

这些是我为队列实现交换和复制功能的方式。

有更好的方法吗？

template <class T>
void Queue<T>::copy(Queue<T> const & other)
{
    if(this == &other) 
        return;

    if(m_size != 0)
        this->clear();

    this->m_cap = other.m_cap;
    this->enqueue(other);
}

template <class T>
void Queue<T>::swap(Queue<T> const & other)
{
    if(this == &other)
        return;

    std::swap(this->m_front, other.m_front);
    std::swap(this->m_back, other.m_back);
    std::swap(this->m_size, other.m_size);
    std::swap(this->m_cap, other.m_cap);
}

谢谢：）

Answer 1

您应该代替实施copy方法，而应实现一个复制构造函数。复制构造函数被传递给它自己的实例是很奇怪的。如果您坚持检查，则可以使用断言。

template <class T>
Queue<T>::Queue(Queue<T> const & other)
    : m_cap(other.m_cap), m_size(0), m_front(), m_back()
{
    assert(&other != this);
    enqueue(other);
}

您的copy方法实际上是一个分配。实现赋值运算符是更自然的。这可以通过遵循复制交换习惯来实现。

template <class T>
Queue<T> & Queue<T>::operator = (Queue<T> other)
{
    swap(*this, other);
    return *this;
}

还有一种惯用的方式来实现swap（很久以前Mooing Duck教给我的东西）：

template <class T>
class Queue {
//...
    friend void swap(Queue &a, Queue &b) {
        using std::swap;
        swap(a.m_front, b.m_front);
        swap(a.m_back, b.m_back);
        swap(a.m_size, b.m_size);
        swap(a.m_cap, b.m_cap);
    }
};

这样，您可以使用依赖于参数的查询（ADL）来选择特定于类型的swap实现（如果有）。现在Queue本身就有这样的实现，由赋值运算符使用。但是，如果将Queue放在要自己实现swap的对象中，也可以使用它。

实现交换/复制功能：还有更好的方法吗？

1 个答案: