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);
    }
}

queue.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

queuetemplate.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>可以工作）即使你使用命名空间std（在标题中，这是错误的）你需要实现复制和分配，你可能希望它是一个“深层”副本：

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;
}

创建自定义对象队列队列（使用自定义队列模板）

1 个答案: