Примеры языков программирования (1161130), страница 3

Просмтор этого файла доступен только зарегистрированным пользователям. Но у нас супер быстрая регистрация: достаточно только электронной почты!

Текст из файла (страница 3)

begin

RES : T;

RES := 0;

for i in X'RANGE do loop

RES := RES+X(i)*Y(i);

end loop;

return RES;

end SCAL;

X:T constant:=e;

package P is

...

type T is ...;

end P;

...

P.T

...

package body P is

type T1 is ...;

end;

//================================================================================================

package Accounts is

type MONEY is digits 12 delta 0.01;

type ACCOUNT is tagged private;

procedure deposit (a: in out ACCOUNT; amount: in MONEY);

procedure withdraw (a: in out ACCOUNT; amount: in MONEY);

function balance (a: in ACCOUNT) return MONEY;

type CHECKING_ACCOUNT is new ACCOUNT with private;

function balance (a: in CHECKING_ACCOUNT) return MONEY;

type SAVINGS_ACCOUNT is new ACCOUNT with private;

procedure compound (a: in out SAVINGS_ACCOUNT; period: in Positive);

private

type ACCOUNT is tagged

record

initial_balance: MONEY := 0.0;

owner: String (1..30);

end record;

type CHECKING_ACCOUNT is new ACCOUNT with null record;

type SAVINGS_ACCOUNT is new ACCOUNT with

record

rate: Float;

end record;

end Accounts;

package body REAL_STACKS is

procedure put (x: in FLOAT; s: in out REAL_STACK) is

begin

if s.count = s.capacity then

raise Overflow

end if;

s.count := s.count + 1;

s.implementation (count) := x;

end put;

procedure remove (s: in out STACK) is

... Реализация remove ...

end remove;

function item (s: STACK) return X is

... Реализация item ...

end item;

function empty (s: STACK) return BOOLEAN is

... Реализация empty ...

end empty;

end REAL_STACKS;

procedure print_balance (a: in ACCOUNT'Class) is

begin

Put (balance (a));

New_Line;

end print_balance;

package Accounts is

type Account is private;

procedure Withdraw(An_Account : in out Account; Amount : in Money);

procedure Deposit( An_Account : in out Account; Amount : in Money);

function Create( Initial_Balance : Money) return Account;

function Balance( An_Account : in Account) return Integer;

private

type Account is

record

Account_No : Positive;

Balance : Integer;

end record;

end Accounts;

with Accounts; use Accounts;

procedure Demo_Accounts is

Home_Account : Account;

Mortgage : Account;

This_Account : Account;

begin

Mortgage := Accounts.Create(Initial_Balance => 500.00);

Withdraw(Home_Account, 50);

. . .

This_Account := Mortgage;

if This_Account = Home_Account then

. . .

end Demo_Accounts;

package Stacks is

type Stack is private;

procedure Push(Onto : in out Stack; Item : Integer);

procedure Pop(From : in out Stack; Item : out Integer);

function Full(Item : Stack) return Boolean;

function Empty(Item : Stack) return Boolean;

private

...

end Stacks;

package Stacks.More_Stuff is

function Peek(Item : Stack) return Integer;

end Stacks.More_Stuff;

//================================================================================================

Delphi

//================================================================================================

Конструкция языка Delphi «uses список_имен_модулей» служит для импорта всех имен, объявленных в интерфейсе модулей из списка. При этом импортированные имена становятся непосредственно видимыми (если нет конфликтов с именами из других модулей).

VAR - передача по ссылке, иначе передача по значению

overload в delphi используется после функции для указания, что она будет перегружена (несколько функций с одним именем, но разными параметрами)

//================================================================================================

a: X;
a := X.create; {в этот момент отводится память и вызывается конструктор}
a. – разыменовывание ссылки.

//================================================================================================

// Наследование

TAncestor = class
private
protected
public
// Виртуальная процедура
procedure VirtualProcedure; virtual; abstract;
procedure StaticProcedure;
end;

TDescendant = class(TAncestor)
private
protected
public
// Перекрытие виртуальной процедуры
procedure VirtualProcedure; override;
procedure StaticProcedure;
end;

//================================================================================================

// Пример использования искючений

procedure TForm1.FormCreate(Sender: TObject);
begin
try
// Some code which may raise an exception
except
on E: EConvertError do
begin
// Handle only EConvertError, or any derived classes
end;
on E: Exception do
begin
// Handle only Exception, or any derived classes
end;
end;
end;

//================================================================================================

if ptr = nil then
raise Exception.Create('Invalid pointer');

//================================================================================================

Двух ступенчатый массив

(На си)

char** mat = new char*[6];
for (int i = 0; i < 6; i++) mat[i] = new char[i+1];
(На delphi)
var mat: array [0..5] of array of integer;
i : integer;
// <...>
for i := 0 to high(mat) do setlength(mat[i], i + 1);

//================================================================================================

program Overloads; // Название программы
{$APPTYPE CONSOLE} // Фиг знает что
type TRec = record // Описание класса
private
function GetOrd: Integer; // Просто функция (она отвечает за свойство, но тем не менее в приватной зоне)
public
class operator Implicit(const Value: TRec): Integer; // Это функция для преобразования типов (неявного в частности)
property ord: Integer read GetOrd; // Описание свойства
end;
// Ниже пойдёт тела функций класса
class operator TRec.Implicit(const Value: TRec): Integer;
begin
Result := 0;
end;

function TRec.GetOrd: Integer;
begin
Result := 0;
end;

procedure Foo(i: Integer);
begin
end;
// Далее обычные объявления
var
R: TRec;
a: array[0..0] of Integer;

begin
Writeln(R); //E2054 Illegal type in Write/Writeln statement
Writeln(Integer(R)); //explicit cast, provided by class operator Implicit
Writeln(R.ord); //my preferred option, a property
a[R] := 0; //E2010 Incompatible types: 'Integer' and 'TRec'
a[Integer(R)] := 0; //again, explicit cast is fine
a[R.ord] := 0; //or using a property
Foo(R); //implicit cast used for actual parameters
end.

//================================================================================================

Oberon-?

В Обероне звёздочка означает public, если нету звёздочки - то private ("Скрытый тип данных" - пример ниже).

//================================================================================================

Тут OpaqueT - тип, который экспортируется

TYPE OpaqueT* = RECORD I:TT; J: TTT END;

//================================================================================================

TYPE T* = RECORD

Y:T1; // приватно

Z*:T2; // публично

END;

TYPE T* = RECORD

I* : INTEGER;

J : INTEGER;

END

TYPE T1* = RECORD(T1)

K : INTEGER;

END

PROCEDURE (VAR X:T) P(L:INTEGER);

PROCEDURE (VAR X:T1) P(L:INTEGER);

//================================================================================================

Oberon-2

В Обероне звёздочка означает public, если нету звёздочки - то private ("Скрытый тип данных" - пример ниже).

//================================================================================================

TYPE T* = RECORD I*, J : INTEGER; END;
TYPE T1* = RECORD (T) K : INTEGER; END; // Тип T - тут базовый класс
PROCEDURE (VAR X: T) P* (L : INTEGER); // Тут перед названием указывается приёмник

PROCEDURE (VAR X: T1) P* (L : INTEGER); // Тут перед названием указывается приёмник

//================================================================================================

Modula-2

если перед переменой в функции стоит слово VAR - то передача идёт по ссылке, а если без, то по значению

//================================================================================================

DEFINITION MODULE M

TYPE T = ...;

TYPE Stack;

PROCEDURE Init(VAR S: Stack);

PROCEDURE Destroy(VAR S: Stack);

...

END M.

IMPLEMENTATION MODULE M;

...

END M.

//================================================================================================

DEFINITION MODULE HashTables;
FROM Types IMPORT KeyType, ElementType;
TYPE HashTable; // Тут объявен скрыты тип данных
PROCEDURE Init(VAR T:HashTable);
PROCEDURE Destroy(VAR T:HashTable);
PROCEDURE Lookup(VAR T:HashTable; Key: KeyType; VAR X:ElementType):BOOLEAN;
PROCEDURE Add(VAR T:HashTable; Key: KeyType; X:ElementType);
PROCEDURE Remove(VAR T:HashTable; Key: KeyType):BOOLEAN;
VAR Done: BOOLEAN;
END HashTables.

//================================================================================================

CLASS Viewers =
RECORD
x, y, w, h: INTEGER;
METHOD restore (T: Text)
BEGIN ...
END restore
END;

TYPE Viewers =
RECORD x, y, w, h: INTEGER;
restore: PROCEDURE (T: Text)
END;

v := Viewers.New (X,Y,W,H); NEW (v);
v.x := X; v.y := Y; v.w := W; v.h := H; v.restore := Restore;

//================================================================================================

Lisp

//================================================================================================

[1]> (car '(1 2 3))

1

[2]>

(car не создает список c заголовным элементом.)

//================================================================================================

Паскаль

//================================================================================================

type PIneger = ^Integer; // Создание типа

var X: ^Integer: Y: PInteger;

AnotherAddress^ := 99; // Разыменовали оператор

SomeAddress := @SomeNumber; // Взять адрес

New(IntPointer); // Выделить память указателю

Всякие разные языки

//================================================================================================

Algol, Ada, Delphi, Modula-2, Pascal - в них понятие

conversion - преобразование типов с какими-либо потерями точности при акрглении, расширении с 32-бит до 64-х, …

casting - любое преобразование типа, в не зависимости от того, это лишь смена интерпретации ("Взглянем на эти же байтики, но немного по другому" (например reinterpret_cast)), или же это настоящее преобразование типа, с вызовом функции.

Характеристики

Список файлов учебной работы