лекции (1998) (Буров), страница 4

int &x=a;

x=2; // это полностью эквивалентно a=2;

}

так, конечно, программировать не нужно, но пример хорошо иллюстрирует понятие ссылки. Процедуру SWAP также можно теперь переписать чуть более элегантно:

void SWAP (int &x, int &y)

{ int t;

t=x;

x=y;

y=t;

}

int a,b;

SWAP (a,b);

- никаких разыменований. В какой момент вычисляется ссылка? В момент передачи параметра.

Что еще добавил Страуструп в C++? Еще он добавил, выше указанным образом, новый способ передачи параметров.

Когда компилятор С видит обращение f(x,y) - он знает, что ему делать - если прототип f не описан, то возвращаемое значение по умолчанию будет int, а параметры будут переданы по значению, даже если будет указано f(&x,&y) - все равно компилятор передаст значения адресов. То есть, если программист что-то умалчивает - компилятор может вместо него однозначно восстановить ситуацию.

В C++ ситуация иная, так как в нем существует два способа передачи параметров, если отсутствует прототип f, то компилятор не знает - по ссылке передавать параметры или по значению.

То есть введение второго способа передачи параметров в C++ повлекло за собой обязательное требование прототипировать функции перед использованием. С точки зрения создателей С (Кернигана и Ритчи) это было слишком жесткое требование. В языке С слишком многое делалось по умолчанию.

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

Это, пожалуй, все о чем хотелось сказать в этом разделе о передаче параметров. Далее следует обсудить еще один вопрос - как возвращаются значения из функции? В некотором смысле по результату, но чуть другая - есть локальная область памяти (стек), который доступен только компилятору. После выполнения функции f происходит копирование значений в эту область. Понимание этого факта при программировании на С, вобщем, неважно. При программированиее на C++ - важно. А именно, то что у нас есть некоторое значение функции f, которое локально, и то, что обязательно происходит копирование этого значения в какую-то другую область памяти. Когда мы будем говорить о классах в C++, то увидим, что там есть понятие конструктора и понятие операции присваивания и между ними и возвращением значения из функции есть достаточно интересная связь.

Заметим, что если на C++ или другом языке, который производит копирование возвращаемого значения, возвращаемый объект имеет большой объем, то потери неизбежны.

Закончим на этом пока с процедурными абстракциями. Мы вернемся к этому вопросу, когда будет рассматривать классы.

Глава II. Основные понятия и проблемы, связанные с типами данных

В начале следует сказать несколько слов о классификации данных. Из этой классификации будет понятно, что должен содержать в себе тип данных. Всего будет 7 пунктов:

1. Содержательная роль;

2. Структура;

3. Изменчивость;

4. Способ определения;

5. Представление;

6. Набор свойств (операций);

7. Доступ.

С содержательной ролью все вроде ясно. То есть каждый тип данных должен в какой-то степени соответствовать объекту реального мира. И чем лучше он соответствует, тем больше содержания несет в себе. Конечно, если мы рассмотрим:

x: integer;

y: integer;

где x - означает вес, а y - длину, то возникает вопрос о содержательной роли выражения x+y.

Данные, естественно различаются по структуре, потому что первое, что разделяет данные и операци - это наличие у данных структуры, которая как-то отображается на архитектуру машины.

С точки зрения изменчивости ясно, что хорошо бы было как-то ограничивать возможности изменения в пределах одного типа. Понятно, что нормальный ЯП должен давать такую возможность. Уже в ранних языках такие средства были, например, указание диапазона изменения.

Способ определения. Вообще говоря, данные могут быть определены пользователем, либо уже быть определены априори.

Представление. Естественно, что данные имеют какую-то свою структуру. Каким образом эта структура отражается на машинную память. Это представление важно прежде всего для вопросов эффективности программирования. Эффективный язык должен представлять средства управления представлением данных. Здесь можно говорить об адресах, где хранятся данные, об их упаковке (если переменная может разрешать два значения, то в один байт таких можно составить несколько).

Следующий фактор, это - набор операций. По своей значимости - он следующий после содержательной роли. То есть прежде всего тип данных с абстрактной точки зрения характеризуется

а) содержательной ролью (которую сложно формализовать);

б) набором операций (который не только можно формализовать, но и нужно);

Для каждого типа данных мы должны привести набор операций, разрешенный над ним.

Ну и, наконец, управление доступом. Этот вопрос связан прежде всего с защитой. Данные могут быть полностью защищены, открыты частично или открыты полностью для внешнего доступа. В таких языках, как С и Pascal (стандартных) нет никакого управления доступом, а в таких языках, как Turbo Pascal, Modula-2, Ada, C++, есть очень мощные и развитые средства управления доступом.

Лекция 5

Какие основные понятия в типах данных связаны с языками программирования? Прежде всего, введем понятие типизации. Здесь, правда, есть некий разнобой в терминологии: в литературе часто встречается этот термин, как «строгая типизация», «слабая типизация», «сильная типизация». Вообще говоря, не очень понятно, что подразумевают те или иные термины, потому что то, что, например, называется «строгой типизацией» разные авторы понимают по-разному.

Мы же рассмотрим некую идеализированную концепцию, и покажем, в какой степени те или иные языки программирования удовлетворяют правилам типизации. Следует подчеркнуть, что это концепция традиционных языков программирования. Отход в сторону объектно-ориентированной парадигмы и безтиповых языков мы будем также иногда совершать.

Концепция уникальности типов.

• любой объект данных имеет единственный тип;

• два типа данных совпадают, если совпадают, тогда и только тогда, когда они имеют одно и то же имя. Это называется «именной эквивалентностью типов»

• каждый тип характеризуется набором операций;

• различные типы данных несовместимы;

Следующий пример на Pascal, иллюстрирует приведенные характеристики:

var A: T1;

B: T2;

begin

{...}

A:=B; {Такое присваивание вызовет ОШИБКУ, т.к. имена типов переменных A и B разные}

{...}

end.

Следует заметить, что все традиционные языки программирования: Pascal, C, Ada -удовлетворяют первому пункту данной концепции. Не удовлетворяют ему такие языки, как C++ (т.к. объектноориентированная парадигма позволяет иметь объекту как свой собсвтвенный тип, так и тип своих предков).

Второй же пункт уже несколько идеализирован. Возьмем, например Pascal, он следует именной эквивалентности типов (вообще, есть два типа эквивалентности - именная и структурная). Именная концепция говорит, что два типа данных совпадают, если совпадают их имена. Структурная - что два типа данных совпадают, если совпадают их структуры. Разговоры о том, какую из них считать более корректной начались с появлением языка PL/I, который полностью поддерживал структурную эквивалентность типов данных, т.е. два типа совпадали, если совпадали их структуры.

Несмотря на то, что в Pascal именная концепция, в этом языке есть несколько послаблений

type A1=array[1..10] of char;

A2=array[1..10] of char;

var

A: A1;

B: A2;

{...}

A:=B;

{...}

Вообще говоря, A1 и A2 - различные типы, хотя структурно они одинаковые. Какое же есть послабление второго правила? Пусть есть два типа:

type length=integer;

width=integer;

Совместимы ли эти типы? Да. Так как оба они - синонимы integer. То есть в Pascal есть правило объявления эквивалентных типов. Хорошо ли это? Не очень. Ибо все-таки это есть правило объявления синонимов. С содержательной точки зрения мы бы, наверное, хотели иметь различные типы length и width. В данном же контексте Pascal разрешит операцию суммирования переменных этих типов:

length+width

Хотя, она ошибочна с точки зрения содержания - складывать длину и ширину немного бессмысленно.

Аналогичная ситуация в языке С, хотя вроде бы в нем также соблюдается именная концепция эквивалентности типов. Но в нем есть конструкция typedef, которая позволяет создавать синонимичные типы.

Также в языке С есть одна очень неприятная особенность, в нем «пролезает» структурная эквивалентность типов. Например, если у нас есть:

struct A{

int i;

double f; };

struct B{

int j;

double x;};

struct B b;

struct A a;

С точки зрения языка С - это различные типы данных. Мы не можем присваивать

a=b

или, если функция имеет прототип:

f (struct A);

вызывать ее f(b), так как имена типов различны.

Но всегда ли? Увы, не всегда. Механизм раздельной независимой компиляции модулей, который подерживает язык С сводит это свойство на «нет».

Например, пусть у нас есть два модуля: F1.C и F2.C:

Тогда при раздельной компиляции этих двух модулей ошибки не возникнет. Так как информация о типах из модуля F1.C будет известна только по объявлениям для структур, которые эквивалентны.

extern int f(struct B);

Итого мы имеем чистую структурную (а не именную) эквивалентность типов, которая «пролезает» благодаря механизму раздельной компиляции. Конечно, можно было бы объявить такую программу некорректной, но у компилятора нет механизмов для обнаружения данной некорректности.

Кстати, в языке C++ с этой точки зрения именная или структурная эквивалентность? Вообще, C++ также имеет механизм раздельной компиляции, но структурной эквивалентности в нем нет. Будет ли приведенный выше пример корректен на С++? На какой стадии трансляции или выполнения программы возникнет ошибка? При сборке. Страуструп применил достаточно хакерский метод для обхода этой проблемы - дело в том, что для совместимости с языком C, C++ должен был поддерживать те же механизмы раздельной компиляции, а с другой стороны C++ не мог позволить себе роскошь, чтобы в язык пролезали такого рода неконтролируемые вещи (те же проблемы возникали бы при несоответствии списка параметров функций). Как можно отлавливать все эти несоответствия?

Был применен метод кодирования имен. Это не является частью языка C++, это некий реализационный прием, который на самом деле настолько хитроумен и прост, что применяется практически во всех реализациях языка С++. А именно, что все имена внутри структур кодируются так, чтобы они содержались в имени структуры, имя функции кодируется так, чтобы в нем содержались все имена формальных параметров. Для этого существует специальная система кодировки, она достаточно хитроумна - для разных функций генерируются отдельные имена, то же касается и структур данных. В нашем примере мы получим, что прототип функции f() из F1.C будет отличаться от прототипа f() из F2.C, ибо эти две функции после кодирования будут иметь различные имена. И, следовательно, при попытке собрать эти модули вместе возникнет ошибка. Конечно, ошибка будет выдана немного невразумительно (будет выписано закодированное имя функции и то, что она в нужном файле не обнаружена - не очень понятно, но зато надежно).

Перейдем к третьему пункту, что «каждый тип характеризуется набором операций» и четвертому о «несовместимости различных типов данных»

Такой язык, как Pascal достаточно строго поддерживает данные концепции, то есть действительно различные типы данных несовместимы по присваиванию и по передаче параметров.

На самом деле здесь традиционные языки программирования дальше всего отходят от указанных концепций. В чем это проявляется?

Например, у нас есть два типа данных: integer и real. С точки зрения именной эквивалентности - это два различных типа. Но в то же время, мы естественным образом можем выполнять следующие операции:

integer:=real;

integer+real;

и др.

То есть в большинстве языков программирования есть правила неявного преобразования типов. И люди, вобщем-то до сих пор спорят - стоит ли допускать неявное преобразование. Понятно, что кое-какие преобразования допускать хотелось бы - в некоторых случаях это достаточно осмысленная операция.