Хочу понять ООП. есть задача, что нужно делать и как правильно нужно делать Опции

[noskovgleb]

Сама задача выглядит вот так:
Дан файл "Багаж пассажиров", который содержит данные о количестве вещей и их общем весе для каждого пассажира. Выделить пассажиров, данные которых превышают средние показатели файла.
Объясните пожалуста... код мне впринципе ненужен!

[volvo]

На всякий случай, чтоб было понятнее, что такое наследование и полиморфизм -

вот решение твоей задачи (Показать/Скрыть)

type
  PTBaseItem = ^TBaseItem;
  TBaseItem = object
    constructor init;
    destructor done; virtual;

    procedure Get(var f: text); virtual;
    procedure Print; virtual;
  end;

constructor TBaseItem.init;
begin end;
destructor TBaseItem.done;
begin end;

procedure TBaseItem.Get(var f: text);
begin end;
procedure TBaseItem.Print;
begin end;

type
  PTPassenger = ^TPassenger;
  TPassenger = object(TBaseItem)
    name: string;
    amount, weight: integer;
    constructor Init;
    destructor Done; virtual;

    procedure Get(var f: text); virtual;
    procedure Print; virtual;
  end;

constructor tpassenger.Init;
begin
  inherited; // инициализируем предка
  // все операции по выделению памяти - здесь
end;
destructor tpassenger.done;
begin
  // здесь - все операции по освобождению памяти, если нужно
  inherited; // удаляем предка
end;

procedure TPassenger.Get(var f: text);
var ch: Char;
begin
  ch := #0; name := '';
  repeat
    read(f, ch);
    if ch <> ' ' then name := name + ch;
  until ch = ' ';
  read(f, amount);
  read(f, weight);
  readln(f);
end;
procedure TPassenger.Print;
begin
  writeln(name:10, '':2, amount:5, '':2, weight:5);
end;

type
  TCompareFunc = function(p: PTBaseItem): Boolean;
  PTListItem = ^TListItem;
  TListItem = object
    info: PTBaseItem;
    next, prev: PTListItem;
    constructor CreateItem(p: PTBaseItem; _prev, _next: PTListItem);
    destructor DestroyItem;
  end;
  { Абстрактный список...
    Может хранить указатели на любых наследников TBaseItem }
  TBaseList = object
    constructor Init;
    destructor Done;

    procedure Append(p: PTPassenger);
    procedure FilterList(func: TCompareFunc);
    procedure PrintList;
  private
    head, tail: PTListItem;
    function find(func: TCompareFunc): PTListItem;
    procedure RemoveItem(p: PTListItem);
  end;


constructor TListItem.CreateItem(p: PTBaseItem; _prev, _next: PTListItem);
begin
  info := p; prev := _prev; next := _next;
end;
destructor TListItem.DestroyItem;
begin
  Dispose(info, Done);
end;

constructor TBaseList.Init;
begin
  head := nil; tail := nil;
end;
destructor TBaseList.Done;
begin
  while Assigned(head) do RemoveItem(head);
end;

procedure TBaseList.Append(p: PTPassenger);
var newItem: PTListItem;
begin
  new(newItem, CreateItem(p, tail, nil));
  if head = nil then head := newItem
  else tail^.next := newItem;

  tail := newItem;
end;

function TBaseList.find(func: TCompareFunc): PTListItem;
var
  p: PTListItem;
  ok: boolean;
begin
  p := head;
  ok := true;
  while Assigned(p) and ok do
    if func(p^.info) then ok := false
    else p := p^.next;

  find := p
end;

procedure TBaseList.RemoveItem(p: PTListItem);
var r: PTListItem;
begin
  r := p^.prev;
  if r <> nil then r^.next := p^.next
  else head := p^.next;

  r := p^.next;
  if r <> nil then r^.prev := p^.prev
  else tail := p^.prev;

  Dispose(p, DestroyItem);
  p := nil;
end;

procedure TBaseList.FilterList(func: TCompareFunc);
var p: PTListItem;
begin
  repeat
    p := find(func);
    if Assigned(p) then RemoveItem(p);
  until p = nil;
end;

procedure TBaseList.PrintList;
var p: PTListItem;
begin
  p := head;
  while Assigned(p) do begin
    p^.info^.Print;
    p := p^.next;
  end;
end;


type
  { А это - вполне себе конкретный список Пассажиров,
    с добавленным функционалом }
  TPassList = object(TBaseList)
    AverAmount, AverWeight: double;

    constructor Init;
    destructor Done;
    procedure FindAverages;
  end;


constructor TPassList.Init;
begin
  inherited Init;
  AverAmount := 0.0; AverWeight := 0;
end;
destructor TPassList.Done;
begin
  inherited Done;
end;

procedure TPassList.FindAverages;
var
  p: PTListItem;
  count: integer;
begin
  p := head;
  count := 0;
  while Assigned(p) do begin
    inc(count);
    AverAmount := AverAmount + PTPassenger(p^.info)^.amount;
    AverWeight := AverWeight + PTPassenger(p^.info)^.weight;	
    p := p^.next;
  end;
  AverAmount := AverAmount / count;
  AverWeight := AverWeight / count;
end;


{
  Помнится, тебе нужна была полиморфность? Вот она ...
  В эту процедуру передается объект любого класса-наследника TBaseItem
}
procedure Get(var obj: TBaseItem; var f: text);
begin
  obj.Get(f);
end;

var
  Lst: TPassList;

function funcFilter(p: PTBaseItem): boolean; far;
begin
  funcFilter := (PTPassenger(p)^.Amount < Lst.AverAmount) or (PTPassenger(p)^.Weight < Lst.AverWeight);
end;

var
  f: text;
  pp: PTPassenger;
begin
  writeln('start');
  assign(f, 'bagag.txt'); reset(f);
  Lst.Init;
  while not eof(f) do
  begin
    pp := new(PTPassenger, Init);
    Get(pp^, f);
    Lst.Append(pp);
  end;
  Lst.PrintList;
  Lst.FindAverages;
  writeln('Average amount:', Lst.AverAmount:10:5, ' Average weight: ', Lst.AverWeight:10:5);
  Lst.FilterList(funcFilter);
  Lst.PrintList;
  Lst.Done;
  close(f);
  readln;
end.

Тестировалось вот на таком файле:

ivanov 4 100
petrov 2 29
sidorov 5 115
kuznetzov 3 102

А теперь скажи, оно тебе надо, на простейшем примере так извращаться?