лекции (2007), страница 5

Интернационализация - локальные приложения, глобализованные приложения. Есть класс программ, которые должны работать в любой среде. Приложения, которые написаны такими, должны работать с одной и той же БД, но должны работать на всех версиях ОС одинаково. Все аспекты интернационализации не сводятся к одному типу данных. Поэтому современные ЯП должны делать char. Все возвращается к языку Pascal, у которого был тип данных char, несовместимый с другими.

В С# нет неконтролируемых преобразований.

(char)i

(int)c

При таких преобразованиях происходит проверка. В языке Ада стояла проблема с charset, так как Пентагон думал, что все будет работать на английском языке, но локализация была важна и тогда. Проблема была в том, что тогда не было юникода, а компьютеры, на которых работала Ада, были с разными системами кодировки. Для Ады были разработаны системы, кодирующие все 48 символами. Чтобы найти выход, они пошли по другому пути. Символьный тип данных - перечислимый. Можно придумать свои литералы исчисления.

type enum is (A,B,C) могли использовать теперь символы A B C.

В Аде есть модуль STANDART. И вся программа в него вложена, в нем был описан тип character и w_character. Следствие - тип w_char и char пересекаются. Как следствие, литералы перечисления могут совпадать.

UCS transformation format - перекодировка в юникоде.

UTF-8 - пример многобайтовых кодировок.

При передаче и приеме информации, она пересылается в УТФ - 8, а потом преобразуется в юникод.

4. Порядковый тип

• перечисления

• диапазоны – аналоги в Pascal

В свое время они были очень популярны, они вводились параллельно. Впервые, они появились в языке Pascal.

Перечисления

Простой тип данных, характеризующийся набором своих значений.

Это порядковый тип. Например, булевый тип тоже перечеслимый, с ними есть SUCC И PREV.

Языки - Pascal, Modula 2, Ада.

Литералы перечисления - идентификаторы. Еще к константам перечислимого типа можно было так же применять ord(Pascal).

val(day_of_week,0) = mon

north,east,west,south

Они явно совместимы с целыми, а неявных преобразований нет - очень легко реализуемы. В современных ЯП мы сталкиваемся с тем, что одному имени соответствуют различные сущности:

void f()

void f(int)

Перекрытие (перегрузка) имен - в одной области видимости - несколько форм -статический полиморфизм. Перегрузка разрешается статически

struct time time()

Теги структур - псевдоимена, это еще одно из понятий языка С, которые перешли в С++. Все современные языки допускают понятие перегрузки имен:

function f

begin

return 0;

end f;

Имена перечислений трактуются, как нуль-местные функции. В Аде можно описать 2 функции без параметров, а в C нельзя, так как возвращаемое значение не входит в поле перекрытий. Всегда ли можно догадаться, какую нуль-местную функцию вызывать?

typе е1 is (a,b)

t2 is (b,c)

procedure P(x:t1)

procedure P(t:t2)

P(A) и p(c) - понятно, но что такое p(b)???

Нужно дать возможность программисту указать нужную функцию или нужный тип. Появляется конструкция указания (не преобразования) типа. Но от этой схемы отличается лишь язык Oberon.

Что такое enum C?

C - не имя, это тег.

enum C X;

x=-25;

(С очень похож на язык ассемблера)

В языке ассемблера нет никакого квазистатического контроля. Перечислимый тип данных становится квазистатическим. Это удобный способ именования констант.

enum WrMode

{

read=1;

write=2;

readwrite=read|write;

}

Вирт, который первый придумал перечислимые типы, в Oberon 2 отказался от них, также был выброшен беззнаковый тип. В Oberon осталось 1 понятие типа модуля.

import m.x

В 1999 году в C# появились перечислимые типы. В С# создатели языка неявно оправдывались и проводили дополнительные аргументы в пользу перечислений. Этот тип в C# имеет несколько свойств. Проблема импорта решена, так как имена локализованы. Запрещено преобразование из целочисленных в перечислимый тип, за исключением 0. Преобразование из enum в int – безопасное.

Убрав неявные преобразования в enum, мы повысили безопасность. явные преобразования всегда контролируются. Мы потеряли возможность выполнять арифметические операции над константами.

Есть ООП, а есть компонентное программирование, при которым мы не используем наследование, а используем компоненты. Этот стиль пошел с VB. И он оказался очень и очень полезным. COM выросла из VBX. Нам дают черный ящик, потом мы его донастраиваем. Перечислимые типы полезны тогда, когда существуют классы терминальной иерархии. Есть специальный язык, на котором описывается интерфейс компонент. Этот язык был придуман международной организацией, IDL, у микрософта - MIDL.

В Java тоже появились enum, но в С# это целочисленные константы, там можно указать базовый тип, если не int, хотя по умолчанию, все так и есть.

static final X a;

Там нет слова const. Описывать члены такого же класса внутри класса - плохая рекурсивность. Имена локализованы внутри класса.

switch(a)

{

case A:

case B:

}

Здесь не нужно указывать тип. Вообще, вот это - чистый "звоночек и свисточек". enum неявно наследуется от типа данных object. В нем есть

valuesof() - для перебора

ordinal()

В C# перечисление - наследник целого типа. Но теперь из одного перечислимого типа мы можем наследовать другой. Из перечислимого типа можем наследовать только перечислимый тип. Когда перечисления стали классами, мы потеряли эффективность. Заметим, что в Java вопросам эффективности не очень много и выделено. Таким образом, перечислимые типы занимают большое место в ЯП. Диапазоны ушли из ЯП и больше не вернулись.

L..R - в Pascal, как правило, целочисленный

У диапазона всегда есть такое понятие как базовый тип. И он связан с перечислением. В современных языках нет диапазонов. Ранее он был только для массивов. В современных массивах все начинается с 0, все индексы целые. Поэтому смысла городить понятие диапазона нет. Но с помощью С++ шаблонов и inline можем определить диапазон.

Краткое представление диапазонов в языках

L..R

[L..R], CARDINAL[0..50]

Range L..R

5. Ссылки и указатели

Зачем нужны указатели:

1. для указывания на объекты

2. для передачи адресов объектов в модули и ф-ии

указатель  адрес

T *p; T a;

p = &a

На нижнем уровне это суть адреса объектов. Основные операции, которые для них применяются — разыменование, new, присваивание.

В Ada и Oberon p.x применимо и в случае, если p — структура, и если p — указатель на структуру. В других языках (C, Turbo Pascal) применима произвольная адресная арифметика: ++, +, -. В принципе это полбеды. Но есть ещё одна: адресная операция, которая применима к любому объекту, и тут возникают страшного рода вещи. Тут языки делятся на две группы:

Безопасные языки

Указатель тождественен объекту из динамической памяти

Standart Pascal, Modula-2, Ada, Oberon

Гибкие языки

Указатель может указывать на любой объект памяти

C, C++, Turbo Pascal, Delphi

Языки без указателей

Нет указателей - нет проблемы

Java и С#

Но в C# есть managed код и unsafe код. Управляемый код безопасный, ибо идёт через вызовы .NET, в unsafe коде допускаются любые вызовы WinAPI, допускается получение указателей.

Примеры использования указателей:

Модула2: TYPE T = POINTER TO T1

Ада-83: type PT is access T;

В 1983 году казалось, зачем придумывать средства сопряжения Ады с другими языками? Вскоре в новом стандарте (Ада-95) возникла необходимость передавать адреса нединамических объектов в функции, т.к. библиотеки в основном написаны на C. Был введен новый указатель:

type PTT is access all T;

X1 : PT;

X2 : PTT;

PTT объекты могут ссылаться и на объекты не в динамической памяти, но для этого надо пометить:

Y1: t;

Y2: aliased t;

На Y2 можно ссылаться при помощи указателя, т.е. можно писать нечто типа

X2=Y2 access;

За такими объектами и указателями на них компилятор особо не присматривает, но это безопасно, т.к.:

X1=Y2 access; - ошибка

и X1:=X2; - ошибка

Если надо передать адрес, используем access all.

Для такого рода указателей существует 2 проблемы:

1) мусор (необходим удалять объекты, с которыми мы больше работать не будем)

2) висячие ссылки (обращение к памяти, которая уже освобождена)

Мусор

(C++)

X *p;

X *p1;

p=new X;

p1=new X;

p=p1;

Висячие ссылки

(C++)

X *p;

X *p1;

p=new X;

p1=p;

delete p;

Динамическая сборка мусора:

Как только позволяем программисту удалять объект, язык становится небезопасным. Если забыть удалить объект, то образуется мусор. Если удалить объект и забыть очистить ссылку, то она становится висячей. Поэтому в современных языках появилась автоматическая сборка мусора.

В стандарте Ada не описан delete. Но автосборку не реализовали, т.к. писали для real-time систем и это противоречит соображениям надёжности. Тем не менее, в Аде появилось UNCHECKED_DEALLOCATION — неконтролируемое освобождение памяти.

Оберон, Оберон2 – есть

Модула2 – нет, но есть ADDRESS, ф-ии ALLOCATE(n), DEALLOCATE(p,n), но ADDRESS стала использоваться как void *, для неконтролируемого преобразования типов.

Ада83 – нет, но STANDART: UNCHECKED DEALLOCATION – PROCEDURE DEALLOCATE(P)

В «неправильных» языках (C#, Delphi, Java) понятие «указатель» заменено понятием «ссылка». Операция new вырабатывает ссылку на объект. Разыменование ссылки автоматическое. Как следствие (семантика - копирование ссылок) должна

присутствовать операция clone. Два вида копирования ссылок: глубинное и поверхностное.

В классических языках над ссылками существует лишь одна операция – операция инициализации. По Страуструпу понятие ссылки необходимо воспринимать, как понятие другого имени.

вопрос в том, в какой момент надо инициализировать ссылку.

В 1985 году ссылки расширили C++. ВBool, char_t - уточнение системы типов. Также в C++ кроме ООП появилось понятие перегрузки и перекрывания имен. Понятие перегрузки распространяется только на имена подпрограмм. Понятие перекрывания - не только на пользовательские ф-ии , но и на стандартные операции, в частности, можно перекрыть индексирование.

Если у нас нет явного понятия «ссылка», нельзя описать перекрытие. Первый из таких языков - Алгол 68.

В С++ появляются 2 способа передачи параметров - по значению и по ссылке. В C++ обязательно использование прототипов. В C оно было не обязательным, лишь для совместимости с C Кернигана-Ритчи.

Прототип ф-ий в К-Р С: тип имя (); пустой список параметра. Класть и забирать параметры - дело программиста.

В С++, чтобы отличать одну ф-ию от другой, необходимо знать профиль вызываемых параметров.

Здесь нужно также понятие конструктора. Инициализатор штука удобная, но он ничего не улучшает. Единственный хороший вариант X(Ti) : a(i) в конструкторе, но здесь у нас будет ссылка на стек, поэтому правильнее написать: X(T &i).

Гибкость языка с внедрением явного типа «ссылка» улучшается.

Проблема:

const T c;

void f(T &x)

f(c) ; - как правильно передать константу, ведь мы же передаем не значение, а адрес.

Отсутствует понятие константной ссылки (если передается большой объект, его не передашь по значению). Константность - RO file. В С++ решили сделать лишь константную ссылку.

Спец конструкция параметров - декларация, что мы не собираемся менять сам объект.

Последний тип данных - подпрограммный тип. Это разновидность простого типа данных, похожего на указатели и ссылку для передачи имен функций. В Аде сделали передачу по родовому модулю (generic). Параметры - не только объекты данных, но и типы и функции.

Глава 2. Составные ТД

- массив

- запись

- множества

- таблицы (частный случай множества)