Отчет по практике, работа с "1С:Бухгалтерия 8.2"

  _{<список  имён полей>: <тип  полей>;}

  _....

  _{<список  имён полей>: <тип  полей>;}

  _{<объявление метода>}

  _...

  _{<объявление  метода>}

_end;

_{Описание  метода аналогично предварительному описанию функции (служебное  слово forward не используется).}

_{После описания объекта  описываются методы: procedure <имя  объекта>.<имя  метода> <параметры>}

_{<описание процедуры>}

_{Аналогично  можно описать  и метод-функцию. Методы (также как  и обычные подпрограммы) могут не иметь  параметров. Так как  методы предназначены  для работы с экземплярами объектов в них  определена служебная  переменная Self, являющаяся псевдонимом для текущего экземпляра (фактически Self - это скрытый параметр). Например, обращение к полю x из метода производится так: self.x. Если в методе нет одноимённой локальной переменной, к полям можно обращаться по названию, опуская Self и точку.}

_{Первый  пример}

_{Приведём  реализацию объекта "окно" (для  реализации интерфейса с помощью модуля crt). Мы можем считать, что окно задаётся координатами левого верхнего угла и размерами  по горизонтали и  вертикали (с учётом рамки окна), а  также иметь флаг видимости (true означает, что окно на экран выведено).}

  _{type СWindow=object}

  _{x,y:       integer; {координаты окна}}

  _{lenx,leny: integer; {размеры окна}}

  _{visible:   boolean; {флаг видимости}}

  _{procedure Init (x,y,lenx,leny: integer);}

  _{procedure Show;}

  _{function isVisible: boolean;}

_end;

_{procedure СWindow.Init (x,y,lenx,leny: integer);}

_{{Задаёт  начальные параметры  окна}}

_begin

  _Self.x:=x;

  _Self.y:=y;

  _{Self.lenx:=lenx;}

  _{Self.leny:=leny;}

  _{visible:=true;}

_end;

 

_{procedure СWindow.show;}

_{{Рисует окно}}

  _{var i,j: integer;}

_begin

  _{textbackground (BLUE);}

 

  _{gotoxy (x,y);}

  _{write ('╔'); {ALT+201}} 

  _{for i:=1 to lenx-2 do write ('═'); {ALT+205}}

  _{write ('╗') {ALT+187}}

 

  _{for j:=y+1 to y+leny-2 do}

  _begin

    _{gotoxy (x,j);}

    _{write ('║'); {ALT+186}} 

    _{for i:=1 to lenx-2 do write (' '); {ALT+205}}

    _{write ('║'); {ALT+186}} 

  _end;

 

  _{gotoxy (x,y+leny-1);}

  _{write ('╚'); {ALT+200}} 

  _{for i:=1 to lenx-2 do write ('═'); {ALT+205}}

  _{write ('╝') {ALT+188}}

 

  _{visible:=true;} 

_end;

 

_{function CWindow.isVisible: boolean;}

_begin

  _{isVisible:=visible;}

_end;

_{Для создания экземпляра данного объекта  можно использовать стандартные способы  объявления переменных и создания динамических переменных.}

_{var Window:CWindow;}

_begin

  _{Window.Init (20,5,40,10);}

  _Window.Show;

_end.

_{Наследование}

_{Важнейшим элементом объектно-ориентированного стиля является наследование. Если вспомнить уже приводившийся пример с телевизором, то наследование можно проиллюстрировать, рассмотрев новый "объект" - видео двойку, которая наследует от телевизора все его свойства, но в ней также есть и новые. Также наследуются и методы (хотя, некоторые из них изменяются: при включении, например, надо активировать не только телевизор, но и плеер). Для видеодвойки характерны и свои собственные методы.}

_{Наш пример класса CWindow можно  расширить, создав новый класс CWindowText, который будет соответствовать окну с текстом (состоящим ровно из одной строки). В этом случае надо будет изменить методы. Ситуацию введения нового метода, который будет иметь тоже название, что и унаследованный мы будем называть переопределением.}

_{Приведу описание нового объекта:}

_{type CWindowText=object(CWindow);}

  _{str: string;}

  _{procedure Init (x,y,lenx: integer, str: string);}

  _{procedure Show;}

_end;

_{procedure CWindowText.Init (x,y,lenx: integer, str: string);}

_begin

  _{CWindow.Init (x,y,lenx,3);}

  _{Self.str:=str;}

_end;

_{procedure CWindowText.Show;}

_begin

  _{CWindow.Show;}

  _{gotoxy (x+1,y+1);}

  _{write (str);}

_end;

_{Отмечу, что наследование отражается в тексте программы указанием  в скобках родительского  объекта после  слова object. При этом методы родительского объекта можно вызывать, указывая явно имя объекта, которому принадлежит метод.}

_{Сокрытие  информации}

_{Внутри  описания полей один раз можно использовать слово private, которое  будет разделять  поля на два типа. К полям, описанным  выше слова private можно обращаться из любого места программы, а ниже - только из текущего модуля (такие поля называют скрытыми).}

_{Отмечу, что при описании объектов стараются  как можно больше полей сделать  скрытыми. Это подчёркивает самостоятельность  объекта, работа с которым происходит только с помощью невскрытых полей и методов. Замечу, что даже простое присваивание полю значения часто делают с помощью метода. Ведь, в будущем в дополнении к этому присваиванию могут использоваться другие операции.}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

_{Рекурсия}

 

  Реку́рсия — метод определения класса объектов или методов предварительным заданием одного или нескольких (обычно простых) его базовых случаев или методов, а затем заданием на их основе правила построения определяемого класса, ссылающегося прямо или косвенно на эти базовые случаи.

  Другими словами, рекурсия — способ общего определения объекта или действия через себя, с использованием ранее заданных частных определений. Рекурсия используется, когда можно выделить самоподобие задачи.

  _{В Паскале процедуры и функции могут вызывать сами себя, то есть обладать свойством рекурсивности.}

_{Пример. Выдать на печать в  обратном порядке  цифры целого положительного числа N. Составим процедуру REVERSE.}

_{PROCEDURE REVERSE (N: integer);}

_Begin

  _{Write (N mod 10);}

  _{If (N Div 10)<>0 Then REVERSE (N Div 10)}

_END;

_{Рассмотрим  работу этой процедуры  для числа N = 153.}

_{Оператор Write(N mod 10) выведет на экран  остаток от деления 153 на 10, то есть 3.}

_{Оператор IF (N DIV 10)<>0 Then REVERSE (N DIV 10) проверяет целую часть частного 153/10 = 15 на ноль. Если целая часть не ноль, то с этим значением (15) идет вновь обращение к процедуре REVERSE.}

_{Оператор Write (N MOD 10) выводит на экран  остаток от деления 15 на 10, т.е.5; затем со значением 15/10 = 1 идет обращение к REVERSE.}

_{После вывода цифры 1 оператором Write (N MOD 10) проба N DIV 10 на ноль передает управление на конец  процедуры. На экране будет записано число 351.}

_{Таким образом, однократное  обращение извне  к процедуре REVERSE вызвало ее трехкратное срабатывание. Условие полного окончания должно находиться в самой процедуре, иначе произойдет зацикливание.}

_{Рекурсивные процедуры и функции (подпрограммы) имеют одну из двух форм: прямую рекурсию и косвенную рекурсию. В первом случае подпрограмма содержит оператор вызова этой же подпрограммы (как в примере с процедурой REVERSE). Во втором случае одна подпрограмма вызывает другую подпрограмму, которая либо сама, либо посредством других процедур или функций вызывает исходную подпрограмму.}

_{Если  А,В - имена подпрограмм, то схема вызова может быть такой: А-В-А. В случае косвенной рекурсии возникает проблема: как и где, описать вызываемую подпрограмму. По правилам языка Паскаль каждая подпрограмма должна быть описана до её вызова. Но если подпрограмма А вызывает В, а В вызывает А, то получается замкнутый круг. Для подобных ситуаций принято следующее правило: одна из рекурсивных подпрограмм, вызывающих друг друга, описывается предварительно следующим образом:}

_{PROCEDURE P(<Список  формальных параметров>); FORWARD;}

_{Здесь P - имя процедуры, FORWARD - ключевое слово. Это  описание указывает  транслятору, что  текст процедуры  Р помещен ниже. Подобным же образом  описывается функция: к оператору FUNCTION добавляется слово FORWARD. Список формальных параметров и тип результата (для FUNCTION) включается только в это предварительное описание и опускается в заголовке соответствующей функции.}

   _{Замечание редактора: в современных трансляторах языка Паскаль (например, Turbo Pascal 5.0) такого строгого ограничения нету. Можно описывать функцию или процедуру полностью и в предварительном описании, и в объявлении.}

_{Пример. Пусть функция  В при работе вызывает функцию А которая, в свою очередь, вызывает функцию В. Тогда  эти модули можно  описать так:}

_{FUNCTION B(X: INTEGER): REAL; FORWARD;}

_{FUNCTOIN A(Y: INTEGER): REAL;}

_BEGIN

_:.

_A:=B(I)+3.5;

_END;

_{FUNCTION B;}

_BEGIN

_..........

_B:=A(D)-1.8;

_END;

_{Заголовок (FUNCTON B) перед текстом  функции В содержит только имя функции, а список формальных параметров и тип  функции не указываются.}

_{Локальные и глобальные переменные}

_{Вложенные процедуры. Если блок какой-либо процедуры  Р1 содержит внутри процедуру  Р2, то говорят, что  Р2 вложена в Р1.}

_{Пример.}

_{PROCEDURE P1(X: REAL; VAR Y: REAL);}

_{VAR C: INTEGER;}

   _{PROCEDURE P2(VAR Z: REAL);}

   _{......................}

  _END;

_BEGIN

_{................}

_END;

_{Любые идентификаторы, введённые  внутри какого-либо блока (процедуры, функции) для описания переменных, констант, типов, процедур, называются локальными для данного блока. Такой блок вместе с вложенными в  него подпрограммами называется областью действия этих локальных переменных, констант, типов и процедур.}

_{Пример 2}

_{PROCEDURE T1;}

_{VAR Y1,Y2:REAL;}

_{PROCEDURE SQ1;}

_{VAR A,B,C,D:REAL;}

_BEGIN

_{(*Переменные A,B,C,D являются локальными  для SQ1,}

_{область их действия - процедура SQ1*)}

_{.................}

_END;

_BEGIN

_{(*Переменные Y1,Y2 -нелокальные  переменные для  SQ1 -}

_{область их действия процедуры T1 и SQ1*)}

_{.................}

_END;

 

_{Константы, переменные, типы, описанные  в блоке PROGRAM, называют глобальными. Казалось бы, проще иметь дело вообще только с глобальными переменными, описав их всех в PROGRAM. Но использование локальных переменных позволяет системе лучше оптимизировать программы (вот в этом я сомневаюсь - ред.), делает их более наглядными и уменьшает вероятность появления ошибок.}

_{При написании программ, имеющих вложенные  подпрограммы, необходимо придерживаться следующих  правил:}

_{Описывать идентификаторы в  том блоке, где  они используются, если это возможно.}

_{Если  один и тот же объект (переменная, тип, константа) используется в двух и более блоках, то описать этот объект надо в самом внешнем из них, содержащем все остальные блоки, использующие данный объект.}

_{Если  переменная, используемая в процедуре, должна сохранить свое значение до следующего вызова этой процедуры, то такую переменную надо описать во внешнем блоке, содержащем данную процедуру.}

_{Локализация переменных дает программисту большую свободу  в выборе идентификаторов. Так, если две процедуры  А и В полностью  отделены друг от друга (то есть не вложены одна в другую), то идентификаторы в них могут быть выбраны совершенно произвольно, в частности, могут повторяться. В этом случае совпадающим идентификаторам соответствуют разные области памяти, совершенно друг с другом не связанные.}

_{Пример 3}