Реализация шаблонной очереди. Формирование линейного списка для группы студентов, содержащего информацию: номер группы, ФИО студента и средний балл за сессию

кафедра 304

Лабораторная работа № 4

по предмету «Программное обеспечение вычислительных систем»

Выполнила студентка 325 гр.

Старцева А. В.

Проверил  ст. преподаватель каф 304

Подоляка А. Н.

______________________

Реализация шаблонной очереди

11  Вариант

Сформировать линейный список для группы студентов, содержащий информацию:
1) номер группы, 2) Ф.И.О. студента, 3) средний балл за сессию.

Реализация программы:

#include "stdafx.h"

void main()

{

      setlocale(LC_ALL, "Russian");

      MyLinearList <Box> list;

      Box box(1,1,1);

      list.push_back(box);

      box.ReBuild(2,2,2);

      list.push_back(box);

      box.ReBuild(3,3,3);

      list.push_back(box);

      box.ReBuild(4,4,4);

      list.push_back(box);

      box.ReBuild(5,5,5);

      list.push_back(box);

      int i=1;

      while(list.Size())

      {

            cout<<i++<<": "<<list.get_first()<<".\n";

            list.pop_front();

      }

      system("pause");

}

//MyLinearList.h

#pragma once

#include "LNode.h"

template<typename typeName>

class MyLinearList

{

private:

      typeName inform;

      LNode<typeName>* head;

      LNode<typeName>* tail;

      unsigned int size;

      LNode<typeName>* GetPrevIndex(unsigned int index);

      void Add(typeName n_inform);

      void AddAt(typeName n_inform, unsigned int index);

      typeName& GetAtIndex(unsigned int index);

      void Release(unsigned int index);

public:

      MyLinearList(void);

      void push_back(typeName n_inform);

      void pop_front();

      typeName& get_first();

      unsigned int Size();

      //

      ~MyLinearList(void);

};

template<typename typeName> void MyLinearList<typeName>::push_back(typeName n_inform)

{

      Add(n_inform);

}

template<typename typeName> void MyLinearList<typeName>::pop_front()

{

      Release(0);

}

template<typename typeName> typeName& MyLinearList<typeName>::get_first()

{

      return GetAtIndex(0);

}

template<typename typeName> void MyLinearList<typeName>::Release(unsigned int index)

{

      if(size>index)

      {

            LNode<typeName>* for_release = GetPrevIndex(index)->GetNext();

            LNode<typeName>* left = for_release->GetPrev();

            LNode<typeName>* right = for_release->GetNext();

            delete for_release;

            size--;

            left->SetNext(right);

            right->SetPrev(left);

      }

}

template<typename typeName> MyLinearList<typeName>::MyLinearList(void)

{

      size = 0;

      head = new LNode<typeName>();

      tail = new LNode<typeName>();

      //inic. head

      head->SetNext(tail);

      head->SetPrev(NULL);

      //inic. tail

      tail->SetPrev(head);

      tail->SetNext(NULL);

}

template<typename typeName> void MyLinearList<typeName>::Add(typeName n_inform)

{

      //add at end

      LNode<typeName>* newnode = new LNode<typeName>(n_inform, tail->GetPrev(), tail);

      //update prev and next (insert new node)

      tail->GetPrev()->SetNext(newnode);

      tail->SetPrev(newnode);

      size++;

      //AddAt(n_inform, size);

}

template<typename typeName> void MyLinearList<typeName>::AddAt(typeName n_inform, unsigned int index)

{

      LNode<typeName>* prev = GetPrevIndex(index);

      LNode<typeName>* newnode = new LNode<typeName>(n_inform, prev, prev->GetNext());

      prev->SetNext(newnode);

      prev->GetNext()->SetPrev(newnode);

      size++;

}

template<typename typeName> LNode<typeName>* MyLinearList<typeName>::GetPrevIndex(unsigned int index)

{

      LNode<typeName>* prev = head;

      for(int i=0; i<index; i++)

            prev = prev->GetNext();

      return prev;

}

template<typename typeName> typeName& MyLinearList<typeName>::GetAtIndex(unsigned int index)

{

      return GetPrevIndex(index)->GetNext()->GetInform();

}

template<typename typeName> unsigned int MyLinearList<typeName>::Size()

{

      return size;

}

template<typename typeName> MyLinearList<typeName>::~MyLinearList(void)

{    

      LNode<typeName>* next = head->GetNext();

      delete head;

      for(int i=0; i<size; i++)

      {

            LNode<typeName>* next4next = next->GetNext();

            delete next;

            next = next4next;

      }

      delete tail;

}

//LNode.h

#pragma once

#include "Box.h"

template<typename typeName>

class LNode

{

private:

      typeName inform;

      LNode<typeName>* prev;

      LNode<typeName>* next;

      //LNode* GetNode(unsigned int index);

public:

      LNode(void);

      LNode(typeName n_inform, LNode<typeName>* n_prev, LNode<typeName>* n_next);

      void SetNext(LNode<typeName>* node);

      void SetPrev(LNode<typeName>* node);

      LNode<typeName>* GetNext();

      LNode<typeName>* GetPrev();

      typeName& GetInform();

      ~LNode(void);

};

template<typename typeName> LNode<typeName>::LNode(void)

{

}

template<typename typeName> LNode<typeName>::LNode(typeName n_inform, LNode<typeName>* n_prev, LNode<typeName>* n_next)

{

      inform = n_inform;

      prev = n_prev;

      next = n_next;

}

template<typename typeName> void LNode<typeName>::SetNext(LNode* node)

{

      next = node;

}

template<typename typeName> void LNode<typeName>::SetPrev(LNode* node)

{

      prev = node;

}

template<typename typeName> LNode<typeName>* LNode<typeName>::GetNext()

{

      return next;

}

template<typename typeName> LNode<typeName>* LNode<typeName>::GetPrev()

{

      return prev;

}

template<typename typeName> typeName& LNode<typeName>::GetInform()

{

      return inform;

}

template<typename typeName> LNode<typeName>::~LNode(void)

{}