c++ - 创建自定义对象队列的队列(使用自定义队列模板)

Question

我正在使用以下代码构造一个包含 10 个队列的队列，每个队列包含 10 个 person 对象，这些对象由三个成员变量组成。每个成员变量都与其他变量不同。稍后，我使用一对嵌套的 for 循环遍历队列以打印出所有属性，但是当我这样做时，我收到的不是 100 个唯一不同的值，而是一组垃圾数据。我尝试了很多方法来诊断问题，但无济于事。有人可以检查下面的代码，看看他们是否能发现我哪里出错了吗？

注意:原始代码比这更复杂，但我已经确定将队列添加到“主队列”是问题的根源，所以我稍微简化了代码以使其更容易集中在重要的部分。如果有人需要任何进一步的信息，请告诉我。

string UserChoiceStr;
int UserChoiceInt;
bool Valid = false;

queue<book> BookList;
queue<string> WaitingListIndex;
queue<queue<person> > WaitingLists;     

int main()
{
    Initialise();
    MainMenu();
    return 0;
}

void Initialise()
{
    queue<person> PersonQueue;

    for (int count1 = 1; count1 <= 10; count1 ++)
    {           
        for (int count2 = 1; count2 <= 10; count2 ++)
        {               
            person PersonObject(1, "String goes here", 2);
            PersonQueue.Add(PersonObject);
        }
        WaitingLists.Add(PersonQueue);
    }
}

队列.h:

#ifndef QUEUE_H
#define QUEUE_H
using namespace std;
template <class Type>
class queue
{
private:
    Type *Contents;
    int Front, Back;
    int QueueSize;
public:
    queue(int queuesize = 10);
    ~queue();
    bool Empty() const;
    bool Full() const;
    bool Remove(Type&);
    bool Add(Type&);

};
#endif

队列模板.h

#ifndef QUEUETEMPLATE_H
#define QUEUETEMPLATE_H
#include "queue.h"
using namespace std;

// Constructor
template <class Type>
queue<Type> :: queue(int queuesize): 
    Front(0), Back(0),
    QueueSize(queuesize),
    Contents(new Type[queuesize + 1])
{}

// Destructor
template <class Type>
queue<Type> :: ~queue()
{
    delete[] Contents;
}

// Tests
template <class Type>
bool queue<Type> :: Empty() const
{
    return (Front == Back) ? true : false;
}

template <class Type>
bool queue<Type> :: Full() const
{
    return ((1 + Back) % (QueueSize + 1) == Front) ? true : false;
}

// Push and pop
template <class Type>
bool queue<Type> :: Remove(Type& FrontElement)
{
    if (Empty())
    {
        return false;
    }
    else
    {
        FrontElement = Contents[Front];
        Front = (Front + 1) % (QueueSize + 1);
        return true;
    }
}

template <class Type>
bool queue<Type> :: Add(Type& NewElement)
{
    if(Full())
    {
        return false;
    }
    else
    {
        Contents[Back] = NewElement;
        Back = (Back + 1) % (QueueSize + 1);
        return true;
    }
}
#endif

Answer 1

你会遇到各种队列的问题，因为队列没有正确实现它的复制和分配语义。

无论何时复制，您都将复制您分配的指针，然后您的临时文件将被删除并带走该指针，留下带有悬挂指针的拷贝。

您的代码没有崩溃是相当令人惊讶的。

考虑到 STL 可能被禁止(所以你不能有 vector<Type> 会起作用)，即使你放入 using namespace std (在 header 中，这是错误的)你需要实现复制和分配，并且你因此可能希望它是一个“深”拷贝:

template< typename Type >
queue<Type>::queue( const queue<Type> & other ) :
    Contents( new Type[other.QueueSize + 1 ] ),
    Front( other.Front ),
    Back( other.Back ),
    QueueSize( other.QueueSize )
{
}

template< typename Type >
void queue<Type>::swap( queue<Type> & other ) :
{
   // use std::swap for each element or
   Type * tempContents = other.Contents;
   other.Contents = Contents;
   Contents = tempContents;

   // do the same for all the integral values
}

// not the most efficient implementation but it is safe
template< typename Type >
queue<Type> & operator=( const queue<Type> & other )
{
     queue<Type> temp( other );
     swap( temp );
     return *this;
}