Создание очереди из очереди пользовательских объектов (с использованием пользовательского шаблона очереди)

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