Главная страница
Навигация по странице:

  • .NET Стандартные типы PascalABC.NET

  • PascalABC.NET Тип .NET

  • алгоритмы. алгор. Компьютерная программа представляет собой список команд, которые указывают компьютеру


    Скачать 2.13 Mb.
    НазваниеКомпьютерная программа представляет собой список команд, которые указывают компьютеру
    Анкоралгоритмы
    Дата28.11.2019
    Размер2.13 Mb.
    Формат файлаpdf
    Имя файлаалгор.pdf
    ТипПрограмма
    #97446
    страница4 из 5
    1   2   3   4   5
    PascalABC.NET
    имеется два типа файлов
    - двоичные и
    текстовые
    Текстовые файлы хранят символы
    , разделенные на строки символами
    #13#10 (Windows) и символом
    #10 (Linux).
    Двоичные файлы в свою очередь делятся на типизированные и бестиповые
    Для описания текстового файла используется стандартное имя типа text
    , бестиповые файлы имеют тип file file file file
    , а для описания типизированного файла используется конструкция file file file file of of of of тип элементов
    :
    var var var var f1: file file file file of of of of real;
    f2: text;
    f3: file file file file;
    В качества типа элементов в типизированном файле не могут фигурировать указатели
    , ссылочные типы
    , а также тип записи
    , содержащий ссылочные поля или указатели
    Стандартные файловые процедуры и функции описываются в пункте
    Процедуры и функции для работы с файлами
    Кроме того
    , в
    .NET имеется ряд классов
    , связанных с работой с файлами

    Эквивалентность и совместимость типов
    Совпадение типов
    Говорят
    , что типы T1 и T2 совпадают
    , если они имеют одно имя либо же определены в секции type type type type в виде T1
    =
    T2
    Таким образом
    , в описаниях type type type type
    IntArray = array array array array [1..10] of of of of integer;
    IntArrayCopy = IntArray;
    var var var var a1: IntArray;
    a2: IntArrayCopy;
    b1,c1: array array array array [1..15] of of of of integer;
    b2: array array array array [1..15] of of of of integer; переменные a1 и a2 и переменные b1 и c1 имеют один и тот же тип
    , а переменные b1 и b2
    - разные типы
    Эквивалентность типов
    Говорят
    , что типы T1 и T2 эквивалентны
    , если выполняется одно из следующих условий
    :
    1.T1 и T2 совпадают
    2.T1 и T2
    - динамические массивы с совпадающими типами элементов
    3.T1 и T2
    - указатели с совпадающими базовыми типами
    4.T1 и T2
    - множества с совпадающими базовыми типами
    5.T1 и T2
    - процедурные типы с совпадающим списком формальных параметров
    (
    и типом возвращаемого значения
    - для функций
    )
    Если типы эквивалентны только если их имена совпадают
    , то говорят
    , что имеет место именная эквивалентность типов
    Если типы эквивалентны если они совпадают по структуре
    , то говорят
    , что имеет место структурная эквивалентность типов
    Таким образом
    , в
    PascalABC.NET
    имеет место именная эквивалентность для всех типов
    , кроме динамических массивов
    , множеств
    , типизированных указателей и процедурных типов
    , для которых имеет место структурная эквивалентность типов
    Только если типы T1 и T2 эквивалентны
    , фактический параметр типа T1 может быть подставлен вместо формального параметра
    - переменной типа T2
    Совместимость типов
    Говорят
    , что типы T1 и T2 совместимы
    , если выполняется одно из следующих условий
    :
    1.T1 и T2 эквивалентны
    2.T1 и T2 принадлежат к целым типам
    3.T1 и T2 принадлежат к вещественным типам
    4.
    Один из типов
    - поддиапазон другого или оба
    - поддиапазоны некоторого типа
    5.T1 и T2
    - множества с совместимыми базовыми типами

    Совместимость типов по присваиванию
    Говорят, что значение типа T2 можно присвоить переменной типа T1 или тип T2 совместим по присваиванию с типом T1, если выполняется одно из следующих условий:
    T1 и T2 совместимы
    T1 - вещественного типа, T2 - целого
    T1 - строкового типа, T2 - символьного
    T1 - pointer, T2 - типизированный указатель
    T1 - указатель или процедурная переменная, T2=nil
    T1 - процедурная переменная, T2 - имя процедуры или функции с соответствующим списком параметров
    T1, T2 - классовые типы, один из них - наследник другого. Поскольку в
    PascalABC.NET все типы кроме указателей являются потомками типа Object, то значение любого типа (кроме указателей) можно присвоить переменной типа Object
    T1 - тип интерфейса, T2 - тип класса, реализующего этот интерфейс
    Если тип T2 совместим по присваиванию с типом T1, то говорят также, что тип T2 неявно приводится к типу T1.
    // НеРеализовано Если при приведении типа происходит выход за диапазон значений типа-результата, то при отключенной директиве компилятора #rangecheck off (по умолчанию) значения приводимого типа усекаются до значений типа- результата, при установленной директиве компилятора #rangecheck on генерируется исключение.

    Отображение натипы .NET
    Стандартные типы PascalABC.NET реализуются типами библиотеки классов .NET. Далее приводится таблица соответствий стандартных типов PascalABC.NET и типов .NET.
    Тип
    PascalABC.NET
    Тип .NET int64
    System.Int64
    uint64
    System.UInt64
    integer
    , longint
    System.Int32
    longword
    , cardinal
    System.UInt32
    smallint
    System.Int16
    word
    System.UInt16
    shortint
    System.SByte byte
    System.Byte boolean
    System.Boolean real
    System.Double double
    System.Double char
    System.Char string
    System.String object
    System.Object
    array of T
    T[]
    record
    struct

    Арифметические операции
    К арифметическим относятся бинарные операции
    +
    ,
    -
    ,
    *
    ,
    /
    ,
    +=
    ,
    -=
    ,
    *=
    ,
    /=
    для вещественных и целых чисел, бинарные операции
    div
    и
    mod
    для целых чисел и унарные операции
    +
    и
    - для вещественных и целых чисел. Тип выражения x
    op y
    , где op - знак бинарной операции
    +
    ,
    - или
    *
    , определяется из следующей таблицы:
    shortin
    t
    byte
    smallin
    t
    word
    intege
    r
    longwor
    d
    int64
    uint6
    4
    singl
    e
    rea
    l
    shortin
    t
    integer integer integer integer intege r
    int64
    int64
    uint6 4
    singl e
    rea l
    byte
    integer integer integer integer intege r
    longwor d
    int64
    uint6 4
    singl e
    rea l
    smallin
    t
    integer integer integer integer intege r
    int64
    int64
    uint6 4
    singl e
    rea l
    word
    integer integer integer integer intege r
    longwor d
    int64
    uint6 4
    singl e
    rea l
    integer
    integer integer integer integer intege r
    int64
    int64
    uint6 4
    singl e
    rea l
    longwor
    d
    int64
    longwor d
    int64
    longwor d
    int64
    longwor d
    uint6 4
    uint6 4
    singl e
    rea l
    int64
    int64
    int64
    int64
    int64
    int64
    uint64
    int64
    uint6 4
    singl e
    rea l
    uint64
    uint64
    uint64
    uint64
    uint64
    uint64
    uint64
    uint6 4
    uint6 4
    singl e
    rea l
    single
    single single single single single single singl e
    singl e
    singl e
    rea l
    real
    real real real real real real real real real rea l
    То есть, если операнды - целые, то результатом является самый короткий целый тип, требуемый для представления всех получаемых значений.
    При выполнении бинарной операции с uint64
    и знаковым целым результирующим типом будет uint64
    , при этом может произойти переполнение, не вызывающее исключения.

    Для операции / данная таблица исправляется следующим образом: результат деления любого целого на целое имеет тип real.
    Для операций div и mod выполняются эти же правила, но операнды могут быть только целыми. Правила вычисления операций div и mod - следующие: x div y - результат целочисленного деления x на y. Точнее, x div y = x / y, округленное до ближайшего целого по направлению к 0;
    x mod y - остаток от целочисленного деления x на y. Точнее, x mod y = x - (x div y) * y.
    Унарная арифметическая операция + для любого целого типа возвращает этот тип.
    Унарная арифметическая операция - возвращает для целых типов, меньших или равных integer, значение типа integer, для longword и int64 - значение типа int64, к uint64 унарная операция - не применима, для типов single и real - соответственно типы single и real. То есть так же результатом является самый короткий тип, требуемый для представления всех получаемых значений.
    Бинарные операции +=, -=, *=, /= не возвращают результат. Они используются в операторах присваивания и имеют следующий смысл: a #= b означает a := a # b, где
    # - знак операции +, -, *, /.
    Например:
    a += 3; // увеличить a на 3
    b *= 2; // увеличить b в 2 раза
    Операция /= неприменима, если левый операнд - целый.
    Операции +=, -=, *=, /= могут также использоваться со свойствами классов соответствующих типов в левой части.

    Логические операции
    К логическим относятся бинарные операции and and and and
    , or or or or и xor xor xor xor
    , а также унарная операция not not not not
    , имеющие операнды типа boolean и возвращающие значение типа boolean эти операции подчиняются стандартным правилам логики
    : a and and and and b истинно только тогда
    , когда истинны a и b
    , a or or or or b истинно только тогда
    , когда истинно либо a
    , либо b
    , a xor xor xor xor b истинно только тогда
    , когда только одно из a и b истинно
    , not not not not a истинно только тогда
    , когда a ложно
    Выражения с and and and and и or or or or вычисляются по короткой схеме
    : в выражении x and and and and y если x ложно
    , то все выражение ложно
    , и y не вычисляется
    ;
    в выражении x or or or or y если x истинно
    , то все выражение истинно
    , и y не вычисляется

    Побитовые операции
    К побитовым относятся бинарные операции and and and and
    , or or or or
    , not not not not
    , xor xor xor xor
    , shl shl shl shl
    , shr shr shr shr
    Они производят побитовые манипуляции с операндами целого типа
    Результирующий тип для and and and and
    , or or or or
    , xor xor xor xor будет наименьшим целым
    , включающим все возможные значения обоих типов операндов
    Для shl shl shl shl
    , shr shr shr shr результирующий тип совпадает с типом левого операнда
    , для not not not not
    - с типом операнда
    Побитовые операции осуществляются следующим образом
    : с каждым битом
    (0 принимается за
    False, 1 - за
    True) производится соответствующая логическая операция
    Например
    :
    00010101 and and and and 00011001 = 00010001 00010101 or or or or 00011001 = 00011101 00010101 xor xor xor xor 00011001 = 00001100
    not not not not 00010101 = 11101010
    (
    операнды и результат представлены в двоичной форме
    ).

    Операции сравнения
    Операции сравнения <
    ,
    >
    ,
    <=
    ,
    >=
    ,
    =
    ,
    <>
    возвращают значение типа boolean и применяются к операндам простого типа
    Операции = и <> также применяются ко всем типам
    (!).
    Для размерных типов по умолчанию сравниваются значения
    , для ссылочных типов
    - адреса
    Можно переопределить это поведение
    , перегрузив операции = и <>
    Аналогично можно перегрузить все операции сравнения для типов записей и классов
    , вводимых пользователем

    Строковые операции
    К строкам применимы все операции сравнения
    <, >, <=, >=, =, <>. Кроме этого, к строкам и символам применима операция конкатенации (слияния) +, ее результат имеет строковый тип.
    Например, 'a'+'b'='ab'.
    К строкам также применима операция +=: s += s1; означает s := s + s1;

    Операции с указателями
    Ко всем указателям применимы операции сравнения = и <>
    К типизированным указателям применима операция разыменования
    ^
    : если p является указателем на тип T
    , то p^
    - элемент типа T
    , на который указывает p
    Указатели pointer разыменовывать нельзя

    Операции с множествами
    К множествам с базовыми элементами одного типа применимы операции +
    (
    объединение
    ),
    -
    (
    разность
    ) и *
    (
    пересечение
    ), а также +=
    ,
    -= и *=
    :
    var var var var s1,s2,s: set set set set of of of of byte;
    begin begin begin begin s1 := [1..4];
    s2 := [2..5];
    s := s1 + s2; // s = [1..5]
    s := s1 - s2; // s = [1]
    s := s1 * s2; // s = [2..4] s += [3..6]; // s = [2..6] s -= [3];
    // s = [2,4..6] s *= [1..5]; // s = [2,4..5] end end end end.
    К множествам с базовыми элементами одного типа применимы также операции сравнения
    =
    (
    равенство
    ),
    <>
    (
    неравенство
    ), <= (
    нестрого вложено
    ), < (
    строго вложено
    ), >= (
    нестрого содержит
    ) и
    > (
    строго содержит
    ):
    [1..3] = [1,2,3]
    ['a'..'z'] <> ['0'..'9']
    [2..4] < [1..5]
    [1..5] <= [1..5]
    [1..5] > [2..4]
    [1..5] >= [1..5]
    Но неверно
    , что [1..5] < [1..5]
    Наконец
    , операция in in in in определяет
    , принадлежит ли элемент множеству
    :
    3 in in in in [2..5]
    - верно
    ,
    1 in in in in
    [2..5] неверно

    Операция
    @
    Операция @ применяется к переменной и возвращает ее адрес
    Тип результата представляет собой типизированный указатель на тип переменной
    Например
    :
    var var var var r: real;
    pr: ^real := @r;

    Операции
    is
    и
    as
    Операция is is is is предназначена для проверки того
    , имеет ли классовая переменная указанный динамический тип
    Операция as as as as позволяет безопасно преобразовать переменную одного классового типа к другому классовому типу
    (
    в отличие от явного приведения классового типа
    ).
    Операция is is is is имеет вид
    :
    a is is is is
    ClassType
    и возвращает True если a принадлежит к классу
    ClassType
    или одному из его потомков
    Например
    , если Base и Derived
    - классы
    , причем
    ,
    Derived
    - потомок Base
    , переменные b и
    d имеют соответственно типы
    Base и Derived
    , то выражения b is is is is Base и d is is is is Base возвращают True
    , а b is is is is Derived
    -
    False
    Операция as as as as имеет вид
    :
    a as as as as
    ClassType
    и возвращает ссылку на объект типа
    ClassType
    если преобразование возможно
    , в противном случае возвращает nil nil nil nil
    Например
    , в программе type type type type
    Base = class class class class end end end end;
    Derived = class class class class(Base) procedure procedure procedure procedure p;
    begin begin begin begin end end end end;
    end end end end;
    var var var var b: Base;
    begin begin begin begin b := new Base;
    writeln(b is is is is Derived);
    b := new Derived;
    writeln(b is is is is Derived);
    end end end end. первый раз выводится False
    , второй
    -
    True
    Операции is is is is и as as as as используются для работы с переменной базового класса
    , содержащей объект производного класса
    1
    способ
    .
    if if if if b is is is is Derived then
    Derived(b).p;
    2
    способ
    .
    var var var var d: Derived := b as as as as Derived;
    d.p;

    Операция
    new
    Операция new new new new имеет вид
    :
    new new new new ИмяКласса(ПараметрыКонструктора)
    Она вызывает конструктор класса ИмяКласса и возвращает созданный объект
    Например
    :
    type type type type
    My = class class class class constructor constructor constructor constructor Create(i: integer);
    begin begin begin begin end end end end;
    end end end end;
    var var var var m: My := new new new new My(5);
    Эквивалентным способом создания объекта является вызов конструктора в стиле
    Object Pacal:
    var var var var m: My := My.Create(5);
    Создание объекта класса при инициализации переменной проще проводить
    , используя автоопределение типа
    :
    var var var var m := new new new new My(5);

    Операции
    typeof
    и
    sizeof
    Операция sizeof sizeof sizeof sizeof(имя типа)
    возвращает для этого типа его размер в байтах
    Операция typeof typeof typeof typeof(имя типа)
    возвращает для этого типа объект класса System.Type
    Приведем пример использования typeof
    :
    type type type type
    Base = class class class class ... end end end end;
    Derived = class class class class(Base) ... end end end end;
    var var var var b: Base := new Derived;
    begin begin begin begin writeln(b.GetType = typeof typeof typeof typeof(Derived));
    end end end end.

    Операция явного приведения типов
    Операция явного приведения типов имеет вид
    ИмяТипа(выражение)
    и позволяет преобразовать выражение к типу ИмяТипа. Тип выражения и тип с именем
    ИмяТипа должны оба принадлежать либо к порядковому типу, либо к типу указателя, либо один тип должен быть наследником другого, либо тип выражения должен поддерживать интерфейс с именем ИмяТипа. В случае указателей запрещено преобразовывать типизированный указатель к типу указателя на другой тип.
    Пример.
    type
    pinteger = ^integer;
    Season = (Winter,Spring,Summer,Autumn);
    var i: integer;
    b: byte;
    p: pointer := @i;
    s: Season;
    begin
    i := integer('z');
    b := byte(i);
    i := pinteger(p);
    s := Season(1);
    end.
    // НеРеализовано Как и для неявного приведения типов, если при приведении типа происходит выход за диапазон значений типа-результата, то при отключенной директиве компилятора #rangecheck off (по умолчанию) значения приводимого типа усекаются до значений типа-результата, при установленной директиве компилятора #rangecheck on генерируется исключение.

    Приоритет операций
    Приоритет определяет порядок выполнения операций в выражении. Первыми выполняются операции, имеющие высший приоритет. Операции, имеющие одинаковый приоритет, выполняются слева направо.
    Таблица приоритетовопераций
    @
    ,
    not
    ,
    ^
    ,
    +
    ,
    -
    (унарные), new
    1 (наивысший)
    *
    ,
    /
    ,
    div
    ,
    mod
    ,
    and
    ,
    shl
    ,
    shr
    ,
    as
    2
    +
    ,
    -
    (бинарные),
    or
    ,
    xor
    3
    =
    ,
    <>
    ,
    <
    ,
    >
    ,
    <=
    ,
    >=
    ,
    in
    ,
    is
    ,
    +=
    ,
    -=
    ,
    *=
    ,
    /=
    4 (низший)
    Для изменения порядка выполнения операций в выражениях используются скобки.

    Оператор присваивания
    Оператор присваивания имеет вид
    : переменная := выражение
    В качестве переменной может быть простая переменная
    , разыменованный указатель
    , переменная с индексами или компонент переменной типа запись
    Символ := называется значком присваивания
    Выражение должно быть совместимо по присваиванию с переменной
    Оператор присваивания заменяет текущее значение переменной значением выражения
    Например
    :
    i := i + 1; // увеличивает значение переменной i на 1
    В
    1   2   3   4   5


    написать администратору сайта