Нужна помощь в описании класов. контейнер на базе очереди. Опции

[medvedeva]

тема:Объектная реализация контейнера на основе комбинированной структуры «Упорядоченный массив динамических очередей»
есть начало, но его нужно переделать так, чтобы выполнялось след:
- информационные объекты являются квартирами дома с парой свойств Номер и Площадь
- квартиры объединяются в рамках объекта Дом (свойство - НомерДома) на основе динамической очереди
- дома объединяются в рамках объекта Улица (свойство - Название) на основе упорядоченного массива.

Для этой задачи надо спроектировать набор необходимых классов, имена которых, а также имена их свойств и методов должны
соответствовать поставленной задаче.
- в классах ввести методы доступа к закрытым свойствам
- использование динамической версии массива не является обязательным
вот начало:

uses
classes,
SysUtils;

type
T = integer;
TypizFile = file of T; // типизированный файл

TQueueItem = class // класс - элемент очереди
private
Data: T; // мои данные
Next: TQueueItem; // указатель на следующий элемент
private
constructor Create(value: T); // создание элемента очереди
end;

TQueue = class // класс очередь
private
Marker: T; // для метки очередей, для их поиска
First, Last: TQueueItem; // указатели начала и конца

public
constructor Create; // инициализация очереди
destructor Free;
procedure Put(value: T); // добавление элемента
function Get: T; // удаление
procedure Print; // просмотр
function Empty: boolean; // проверка на пустоту

// procedure Save (value: T); //сохранение в файл
// procedure Load (value: T); // загрузка из файла
end;

{Класс TCont обьявляем контейнерным классом}
TCont = class // класс-контейнер
private // свойства
mas: array of TQueue; // динамический массив
procedure Add(theQueue: TQueue);

public
Constructor Create; // создание массива указателей очередей
Procedure Add_main; // добавить новые очереди в контейнер
Procedure Delete_main;
procedure Scan_main;
// procedure Save (value: T); //сохранение контейнера в файл
// procedure Load (value: T); // загрузка из файла
end;


{========================================}
// инициализация элемента
constructor TQueueItem.Create(value: T);
begin
Data := value;
next := nil;
end;

{==========================================}
// инициализация очереди
Constructor TQueue.Create;
begin
first := nil; last := nil; // создаем пустую очередь
end;
// Освобождаем память, которую занимала очередь
destructor TQueue.Free;
begin
while not Empty do Get; // удаляем все элементы
end;

заранее спасибо!

Сообщение отредактировано: Lapp - 29.06.2011 22:04

[IUnknown]

Возможно все... В первом приближении - вот так:

... (Показать/Скрыть)

uses
   classes, SysUtils;

type
   Apts =
   record
      Number : Integer;
      S : Integer;
   end;

   TQItem = Apts;

   TQueueItem =
   class
      Data : TQItem;
      next : TQueueItem;
   public
      constructor Create (value : TQItem);
   end;

function Apt(N, S : Integer) : Apts;
begin
   result.Number := N;
   result.S := S;
end;

constructor TQueueItem.Create (value : Apts);
begin
   Data := value;
   next := nil;
end;

type
   TQueue =
   class
   private
      head, tail : TQueueItem;
      fHouse : Integer;

   public

      constructor Create (AHouse : Integer);
      destructor Destroy;

      function IsEmpty : boolean;
      function Get : TQItem;
      procedure Put (value : TQItem);

      property House : Integer read fHouse;
   end;

constructor TQueue.Create (AHouse : Integer);
begin
   fHouse := AHouse;
   head := nil; tail := nil;
end;

destructor TQueue.Destroy;
begin
   while not IsEmpty do Get;
end;

function TQueue.IsEmpty : boolean;
begin
   result := head = nil;
end;

function TQueue.Get : TQItem;
var p : TQueueItem;
begin
   if not IsEmpty then
   begin
      result := head.Data;
      p := head;
      head := head.next;
      p.Free;
   end;
end;
procedure TQueue.Put (value : TQItem);
var p : TQueueItem;
begin
   p := TQueueItem.Create (value);
   if IsEmpty then
      head := p
   else
      tail.next := p;
   Tail := p;
end;


type
   TContainer =
   class
   private
      fTitle : string;
      Arr : array of TQueue;
      function GetHouse (index : Integer) : TQueue;
      function GetCount : Integer;

   public
      constructor Create (ATitle : string);
      destructor Destroy;

      procedure Add(Q : TQueue);
      property Title : string read fTitle;
      property Count : Integer read GetCount;
      property Houses[index : Integer] : TQueue read GetHouse; default;
   end;

constructor TContainer.Create (ATitle : string);
begin
   fTitle := ATitle;
   SetLength (Arr, 0);
end;
destructor TContainer.Destroy;
var i : integer;
begin
   for i := 0 to Length(Arr) - 1 do
      Arr[i].Destroy;
   SetLength(Arr, 0);
end;

procedure TContainer.Add(Q : TQueue);
var
   i, j : Integer;
begin
   i := 0;
   while (i < Length(Arr)) and (Arr[i].House < Q.House) do inc(i);
   SetLength(Arr, Length(Arr) + 1);
   for j := Length(Arr) - 1 downto i + 1 do
      Arr[j] := Arr[j - 1];
   Arr[i] := Q;
end;

function TContainer.GetCount : Integer;
begin
   result := Length (Arr);
end;

function TContainer.GetHouse (index : Integer) : TQueue;
begin
   if (index >= 0) and (index < Length(Arr)) then
      result := Arr[index]
   else
      result := nil;
end;

var
   C : TContainer;
   Hs_01, Hs_02, Hs_06 : TQueue;
   i : Integer;
begin
   C := TContainer.Create ('Arbat');


   Hs_02 := TQueue.Create (2);
   with Hs_02 do
   begin
      Put (Apt(1, 100));
      Put (Apt(2, 120));
      Put (Apt(3, 100));
      Put (Apt(4, 150));
   end;
   C.Add (Hs_02);

   Hs_06 := TQueue.Create (6);
   with Hs_06 do
   begin
      Put (Apt(1, 100));
      Put (Apt(2, 120));
      Put (Apt(3, 100));
      Put (Apt(4, 150));
   end;
   C.Add (Hs_06);

   Hs_01 := TQueue.Create (1);
   with Hs_01 do
   begin
      Put (Apt(1, 75));
      Put (Apt(2, 80));
      Put (Apt(3, 75));
      Put (Apt(4, 90));
   end;
   C.Add (Hs_01);

   for i := 0 to C.Count - 1 do
   begin
      writeln(C[i].House);
   end;

   writeln(C.Title);
   C.Destroy;  //  Удалять очереди не надо, это сделает деструктор контейнера
end.

Теперь осталось сделать так, чтобы со всем этим было удобно работать. Для этого надо знать, как именно ты собираешься это все использовать.