Пратт Т. Языки программирования. Разработка и реализация

Подождите немного. Документ загружается.

577

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

таким образом, чтобы минимизировать время ее выполнения (TIME) или необходи

мую для ее выполнения память (SPACE).

Исключительные ситуации. В конце каждой программной единицы (подпро

граммы, блока, задачи или пакета) можно определить набор обработчиков исклю

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

ключений, возникающих как внутри этой программной единицы, так и переданных

из других подпрограмм, не имеющих своего обработчика ошибок. Каждое исклю

чение имеет свое имя. Существует небольшое число предопределенных исключе

ний, таких как CONSTRAINT_ERROR (возникает, когда индекс выходит за объявленный

диапазон, когда при присваивании нарушается ограничение на диапазон значений

и т. д.). Все остальные исключения объявляются следующим образом:

èìÿ_èñêëþ÷åíèÿ: exception

Обработчик исключений начинается с имен исключительных ситуаций, кото

рые он обрабатывает, далее следует последовательность операторов, которые вы

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

обработчиков исключений следующий:

exception

when èìÿ_èñêëþ÷åíèÿ | ... | èìÿ_èñêëþ÷åíèÿ

=> ïîñëåäîâàòåëüíîñòü_îïåðàòîðîâ;

...

when others => ïîñëåäîâàòåëüíîñòü_îïåðàòîðîâ;

где каждая последовательность операторов может обрабатывать одну или несколько

именованных исключений. Обработчик others других, не перечисленных ранее ис

ключений, не обязателен. Однако если он присутствует, он обрабатывает все ис

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

Исключение генерируется либо неявно элементарной операцией, либо явно по

средством выполнения оператора:

raise èìÿ_èñêëþ÷åíèÿ

Когда сгенерировано исключение, управление передается обработчику исклю

чений текущей выполняемой программной единицы, если, конечно, эта программ

ная единица имеет соответствующий этому исключению обработчик. Если обра

ботчика нет, тогда исключение передается по цепочке вызовов подпрограмм первой

из них, в которой имеется соответствующий обработчик, или, в конце концов, если

нет программноопределенного обработчика, исключение передается на обработ

ку системноопределенному обработчику. Исключения не передаются из задач.

Как только исключение обработано обработчиком, подпрограмма (или другая

программная единица) нормально завершает свое выполнение и возвращает уп

равление обратно в вызвавшую ее подпрограмму. Таким образом, обработчик ис

ключений в языке Ada завершает выполнение тела подпрограммы, которое было

прервано, когда возникло исключение. Здесь не предусмотрено возобновление

выполнения программной единицы, в которой возникло исключение. Обработчик

может частично обработать исключение, а затем передать это же исключение на

зад по динамической цепочке, выполнив оператор raise без имени исключения.

Задачи. Задача — это подпрограмма, которая может выполняться параллельно

с другими задачами. Более подробно задачи были рассмотрены в разделе 11.2.

П.1. Ada

578 Приложение. Обзоры языков

Встроенные приложения. Поскольку язык Ada разрабатывался для запуска

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

части, на которой выполняются эти приложения. Ниже описаны некоторые из та

ких возможностей.

Задание адреса. С помощью следующего оператора при выполнении програм

мы может быть определен конкретный адрес памяти, по которому следует поме

стить объект данных, подпрограмму или задачу:

for èìÿ_îáúåêòà use at àäðåñ_ïàìÿòè

где адрес памяти задается как значение некоторого выражения.

Листинг П.2. Структура задач в языке Ada

task èìÿ_çàäà÷è is

– îáúÿâëåíèÿ òî÷åê âõîäà

end;

task body èìÿ_çàäà÷è is

– ïîñëåäîâàòåëüíîñòü îáúÿâëåíèé

begin

– ïîñëåäîâàòåëüíîñòü îïåðàòîðîâ

exception

– îáðàáîò÷èêè èñêëþ÷åíèé

end;

Прерывания. В случае встроенных систем часто бывает важно, чтобы програм

ма могла обрабатывать прерывания, генерируемые аппаратной частью или внеш

ними устройствами. С помощью следующей структуры можно связать прерыва

ние с точкой входа задачи:

for òî÷êà_âõîäà use at àäðåñ_ïðåðûâàíèÿ

Когда происходит прерывание, оно действует как вызов точки входа с наивыс

шим приоритетом для задачи с заданной точкой входа. Таким образом, задача, от

ветственная за обработку прерывания, может ответить немедленно, если она нахо

дится в состоянии ожидания при выполнении соответствующего оператора accept

для этой точки входа.

Стандартные функции

В язык Ada включено множество стандартных пакетов, которые определяют обыч

ные функции. Ниже перечислены некоторые из них:

Ada.Strings.Fixed Функции строк фиксированной длины

Ada.Strings.Bounded Функции строк переменной длины

Ada.Strings.Unbounded Функции строк неограниченной длины

Ada.Numerics.Generic_Elementary_Functions Тригонометрические функции

Пакеты

Пакеты языка Ada обеспечивают возможность инкапсуляции. Однако в язык Ada 95

добавлены дополнительные возможности для объектноориентированного насле

дования.

Определение пакета состоит из двух частей: спецификации (состоящей из види

мой части и закрытой части) и тела. Спецификация содержит информацию, не

обходимую для правильного использования пакета, тело содержит как инкапсу

579

лированные локальные переменные и определения подпрограмм, так и тела под

программ, вызываемых извне пакета. В некоторых случаях пакет не нуждается в те

ле. Стандартная форма определения пакета приведена в листинге П.3.

Листинг П.3. Спецификация пакета Ada

package èìÿ_ïàêåòà is

– îáúÿâëåíèÿ âèäèìûõ îáúåêòîâ äàííûõ

private

– ïîëíîå îïðåäåëåíèå çàêðûòûõ îáúåêòîâ äàííûõ

end;

package body èìÿ_ïàêåòà is

- îïðåäåëåíèÿ îáúåêòîâ äàííûõ è ïîäïðîãðàìì,

- îáúÿâëåííûõ âûøå â ÷àñòè ñïåöèôèêàöèè ïàêåòà

begin

- îïåðàòîðû èíèöèàëèçàöèè ïàêåòà

- ïðè ïåðâîì ñîçäàíèè åãî ýêçåìïëÿðà

exception

– îáðàáîò÷èêè èñêëþ÷åíèé

end;

Видимая часть спецификации пакета (все, что предшествует ключевому слову

private) определяет, какие объекты данных внешний пользователь пакета может

использовать в программе. Если определения типов даны в видимой части, пользо

ватель может объявлять переменные этого типа; если там определены переменные

или константы, на них можно ссылаться и т. д.

Если в пакете определяется абстрактный тип данных, пользователь может объяв

лять переменные, принадлежащие к этому абстрактному типу, но подробное опи

сание типа не должно быть видимым. В этом случае определение типа в видимой

части имеет вид

type èìÿ_òèïà is private;

а полное определение задается в закрытой части спецификации (например, стро

ки 6–12 в листинге П.1).

Казалось бы, логично поместить закрытые компоненты пакета в его тело, а не

в спецификацию, чтобы спрятать такие имена от других пакетов. Однако по сооб

ражениям, связанным с реализацией, это делается не так. Более подробно этот мо

мент обсуждается в разделе 7.1.

Ограниченные закрытые типы. Обычно желательно, чтобы элементарные опе

рации присваивания и проверки на равенство и неравенство были автоматически

доступны даже для объектов закрытых типов, так что операция A := B была бы

определена для объектов A и B закрытого типа. В языке Ada это единственные опе

рации, которые предусмотрены для закрытых типов без явного определения про

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

заранее определены для закрытого типа. Если программист описывает тип как

limited private (ограниченный закрытый тип), то никакие операции вообще не

будут заранее определены для этого типа.

Общие пакеты. Спецификация общего пакета имеет параметры, задающие типы

конкретных элементов пакета, размер конкретных массивов пакета и т. д. Напри

мер, общий пакет, который определяет абстрактный тип stack, может иметь пара

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

дит следующим образом:

П.1. Ada

580 Приложение. Обзоры языков

package èìÿ_ôàêòè÷åñêîãî_ïàêåòà is

new èìÿ_îáùåãî_ïàêåòà(ïàðàìåòðû);

Создание экземпляра пакета — это операция, выполняемая компилятором. Во

время компиляции в операторе, который создает экземпляр пакета, каждая ссыл

ка на имя формального параметра в пакете заменяется фактическим параметром.

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

Общий пакет и созданный его экземпляр не влияют на структуру времени выпол

нения, только результирующий пакет (после создания экземпляра) действитель

но компилируется в объекты данных времени выполнения и в выполняемый код.

Однако, поскольку создание экземпляров общих пакетов в языке Ada — достаточ

но часто встречающаяся операция, особенно в тех программах, в которых исполь

зуются библиотечные пакеты, большинство компиляторов Ada различными спо

собами оптимизируют эту операцию. Часто это осуществляется путем частичной

предварительной компиляции общего пакета, когда не компилированными оста

ются лишь те части, которые напрямую зависят от параметров общего пакета и ко

торые только и будут компилироваться при каждом создании экземпляра пакета.

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

Язык Ada 95 расширил концепцию пакета, включив возможность наследования.

Ранее нужно было с помощью конструкции with включать явные пакеты или ис

пользовать производные типы. В язык Ada 95 добавлено понятие расширение типа,

которое осуществляется с помощью нового, названного ïîìå÷åííûì (tagged), типа.

Например, если бы тип Mydata из листинга П.1 был бы описан как

type Mydata is tagged record

val: myarray;

sz: integer := 0;

end record;

то можно было бы определить новый объект Doublestack:

type Doublestack is new Mydata with

record

Newdata: myarray;

end record;

Этот объект Doublestack имел бы унаследованные от типа Mydata компоненты

val и sz. Использование помеченных типов в языке Ada 95 позволяет создавать

новые пакеты без необходимости повторной компиляции определений существу

ющих пакетов.

Каждый помеченный тип содержит атрибут class (например, class в Mydata'class

или Doublestack'class, который может быть использован для динамического свя

зывания). Объект Doublestack является членом того же класса, что и Mydata, посколь

ку произведен из него.

Помеченные объекты также можно объявлять как абстрактные (abstract). На

пример,

type Mydata is abstract tagged with null record

задает имя объекта, обозначение его класса, но не определяет способ представле

ния этого объекта в памяти. Определение объекта Mydata может быть заполнено

с помощью расширения типа. Таким образом, создается шаблон для типа, а для

использования объекта должны быть определены помеченные типы.

581

Вызов элементарной операции с фактическим параметром помеченного типа

приводит к связыванию во время выполнения с фактической подпрограммой, ко

торая должна быть вызвана. Это обеспечивает наличие в Ada 95 существенных

свойств динамической объектноориентированной модели выполнения, что и от

личает Ada 95 от Ada 83.

П.2. C

Пример с пояснениями

В листинге П.4 приведен пример программы на языке C, производящей суммиро

вание элементов массива. В данном примере для входных данных

41234

программа напечатает:

1 2 3 4 ; SUM= 10

Листинг П.4. Пример программы суммирования элементов массива на языке C

1 #include <stdio.h>

2 const int maxsize=9;

3 main()

4 {int a[maxsize];

5 int j,k;

6 while( (k=convert(getchar())) != 0) {

7 for (j=0; j<k; j++) a[j] = convert(getchar());

8 for (j=0; j<k; j++) printf("%d ", a[j]);

9 printf ("; SUM= %d\n", addition(a,k));

10 while(getchar() != '\n');

11 } }

12 /* Ôóíêöèÿ ïðåîáðàçîâàíèÿ */

13 int convert (char ch)

14 {return ch–'0';}

15 /* Ôóíêöèÿ ñëîæåíèÿ */

16 int addition (v, n)

17 int v[ ], n;

18 { int sum,j;

19 sum=0;

20 for (j=0; j<n; j++) sum=sum+v[j];

21 return sum;

22 }

Строка 1. В данной программе должна быть использована стандартная биб

лиотека вводавывода, подключаемая через заголовочный файл stdio.h. В этой стро

ке записана препроцессорная команда, которая обрабатывается до начала транс

ляции. В этом месте происходит включение в программу содержимого файла stdio.h

как части программы.

Строка 2. Определяется целая константа maxsize, и ей присваивается значение 9.

Можно было использовать также препроцессорную команду с похожим результа

том:

#define maxsize 9

Строка 3. В этом месте начинается вычисление. Некоторая функция должна

иметь имя main.

П.2. C

582 Приложение. Обзоры языков

Строка 4. Объявляется массив a целых чисел с индексом из диапазона значе

ний от 0 до 8.

Строка 6. Функция getchar() определена в файле stdio.h. Она считывает оче

редной символ со стандартного ввода. Поскольку переменные символьного типа

char являются подтипами целых чисел, читается целочисленное значение (код)

символа. Например, в системах, использующих ASCIIкоды, цифра 2 является

символом с двоичным значением 0110010, которое в восьмеричной системе равня

ется 62, а в десятичной — 50. Однако в данной программе требуется численное зна

чение 2, которое и получается в результате действия функции convert() (строки

13–14).

Считанное значение присваивается переменной k. Обратите внимание на то, что

присваивание здесь является просто операцией, а выражение k=convert(getchar())

присваивает следующее введенное число переменной k и возвращает его же в ка

честве значения этого выражения. Если это значение не 0, то выполняются следу

ющие операторы (строки 7–11). Следовательно, если значение k равно 0, то цикл

завершится, а вместе с ним завершится и программа, так как закончится выполне

ние процедуры main.

Строка 7. В операторе for последовательно считываются значения массива

(с помощью функции convert и функции getchar из стандартной библиотеки вво

давывода). Первым параметром оператора for является операция присваивания

значения переменной (счетчику цикла), выполняемая при входе в этот оператор

цикла; обычно присвоенное значение является начальным значением для цикла

(j=0). Второй параметр является условием продолжения выполнения цикла (вы

полнять цикл, пока j<k), а третий параметр описывает операцию, выполняющую

ся в конце каждого шага цикла (j++, то есть добавление единицы к значению пере

менной j).

Строка 8. Этот оператор for аналогичен предыдущему оператору цикла, но толь

ко на каждом шаге цикла печатает соответствующий элемент массива. Функция

printf выводит на печать свой первый аргумент, представленный символьной стро

кой. Последовательность символов %d в строке вывода указывает, что нужно взять

следующий аргумент функции printf и напечатать его в целочисленном формате в

том месте строки вывода, где находится эта последовательность.

Строка 10. Программа читает символы до тех пор, пока не встретится символ

конца строки. Данный оператор while имеет пустое тело.

Строка 11. Фигурные скобки завершают блок, начинающийся в строке 6, и тело

основной программы, которое начинается в строке 4.

Строка 12. Комментарий. Его можно использовать везде, где можно поместить

символ пробела.

Строка 14. Не обязательно знать ASCIIкоды для цифр. Все, что необходимо

знать, это то, что символ '0' — это число 0, символ '1' — на единицу больше симво

ла '0' и имеет значение 1, а '2' — больше '0' на 2 и имеет значение 2 и т. д. Выраже

ние ch–'0' вернет требуемое числовое значение для одной цифры.

Строки 16–17. Здесь приведен старый стиль описания параметров языка C. Име

на параметров находятся в списке параметров, а затем в теле функции следует опи

сание их типов. Обратите внимание на то, что границы массивов не заданы.

583

П.2.1. Объекты данных

Язык C является строго типизированным языком, но в нем существует всего не

сколько типов, поэтому строгая типизация полезна лишь в минимальной степени.

Данные могут быть целочисленными (integer), перечисляемого типа или веществен

ными с плавающей точкой (

float). Структурированные данные представлены мас

сивами, строками (форма массивов) или записями, такими как struct или union.

Элементарные типы данных

Переменные и константы. Идентификаторами в C могут быть любые последова

тельности букв, цифр и символа подчеркивания (_), причем они не должны начи

наться с цифры. В заголовочных файлах .h обычно используются внутренние

переменные, имена которых начинаются с символа подчеркивания, так что в пользо

вательских программах лучше избегать задания идентификаторов, начинающих

ся с символа подчеркивания. Регистр играет важную роль в языке C, поэтому пе

ременные с именами abc и ABC — это разные переменные.

Целые числа можно задавать в обычном формате целых чисел (например, 12, –17)

или как восьмеричные литералы с предшествующим 0 (например, 03 — десятичное

3, 011 — десятичное 9, 0100 — десятичное 64). Символьные литеральные константы

задаются в одинарных кавычках (например, 'A', 'B', '1'). Символ \n обозначает

конец строки, а \0 — это nullсимвол, который используется при обработке строк.

Действительные ASCIIкоды символов можно задавать, используя числовые коды.

Так, \062 соответствует ASCIIкоду 62 (восьмеричному) или символу '2'.

Дискретные значения можно создавать с помощью перечисляемых типов — дру

гой формы целочисленных данных:

enum èìÿ_òèïà { ñïèñîê_çíà÷åíèé } èìÿ

Пример:

enum colors { red, yellow, blue } x, y, z;

x = red;

y = blue;

Значения перечисляемого типа нужно указывать только один раз. Следующее

объявление переменных перечисляемого типа colors можно записать как

enum colors a, b, c;

Литеральные константы с плавающей точкой могут быть записаны в форме чи

сла с десятичной точкой (например, 1.0, 3.456) или в экспоненциальной форме (на

пример, 1.2e3 = 1200, 12e–1 = .012).

Строковые литералы, или просто строки, задаются как последовательности сим

волов, заключенные в двойные кавычки ("), например, "abc", "1234". Однако стро

ки на самом деле являются строковыми массивами со специальными завершаю

щими nullсимволами (\0). Таким образом, строка "123456" на самом деле является

последовательностью 123456\0 и обрабатывается так же, как если бы она была объяв

лена одним из следующих способов:

char arrayvar[] = "123456"; /* arrayvar äëèíîé 7 ñèìâîëîâ */

char *arrayptr = "123456"; /* arrayptr óêàçûâàåò íà ýòè ñèìâîëû */

Числовые типы данных. Целый тип в языке C имеет несколько разновидно

стей. Целый тип short содержит наименьшее количество бит, эффективное для

П.2. C

584 Приложение. Обзоры языков

данной реализации. Для многих реализаций C, используемых на персональных

компьютерах, этот тип соответствует 16битному целому числу со знаком, макси

мальное значение которого может быть 32 767. Он может быть и больше, например

32битное целое. Тип long является, наоборот, наиболее длинной (в отношении

количества бит) реализацией целых чисел, приемлемой для данной конкретной

аппаратной части компьютера. Как правило, переменные этого типа занимают

32 бита, а иногда и больше. Тип int представляет собой наиболее эффективную

реализацию для данной аппаратной части. Этот тип (int) может совпадать с short

или long или его длина может иметь некоторое промежуточное значение в интер

вале между значениями длин описанных типов.

Как показано в приведенном примере, тип char также является подтипом цело

го, в данном случае — однобайтным значением. То есть любыми введенными сим

волами можно манипулировать так же, как другими целыми значениями.

В языке C нет булевого или логического типа данных; вместо них также ис

пользуются целые переменные. Èñòèíà определена как любое ненулевое целое зна

чение, а Ëîæü представляется нулевым значением. Для установки и сброса различ

ных битов в целых числах можно использовать поразрядные операции. Хотя для

хранения различных булевых значений можно использовать несколько битов в от

дельном слове (например, двоичное число 101 = десятичное 5 может обозначать

«A — истинно, B — ложно, C — истинно»), для этой цели обычно лучше использо

вать отдельные переменные типа int.

Константы можно определять либо при помощи препроцессорной команды

#define, как было показано выше, либо при помощи объявления const:

const èìÿ_òèïà = çíà÷åíèå

Указатели. Указатели могут указывать на любые данные. Конструкция *p по

казывает, что p является указателем на объект. Например, операторы

int *p;

p = (int *) malloc(sizeof(int));

p = 1;

делают следующее:

1. Размещают в памяти указатель p, который будет указывать на целую пере

менную.

2. Отводят достаточно памяти, чтобы разместить там целую переменную, и

сохраняют lзначение этой области памяти как rзначение переменной p.

3. Используя rзначение переменной p, помещают целое значение 1 в отведен

ное пространство памяти, на которое указывает p.

Структурированные типы данных

Массивы. Индексы одномерных массивов начинаются с 0 (например, int a[3]).

Многомерные массивы любой размерности можно определить как

int a[10][5]

Такие массивы сохраняются путем развертывания по строкам, то есть как если

бы массив был описан следующим образом:

thing a[10]

где тип thing — это целый массив длины 5.

585

Как говорилось ранее, строки являются массивами символов. Строковые функ

ции обычно используют строки с завершающим nullсимволом (то есть в виде мас

сивов символов, завершающихся nullсимволом: "abcdef" = abcdef\0).

Определяемые пользователем типы

Язык C может создавать записи структурированных данных, называемые струк

турами, с помощью типа struct. Синтаксис структур похож на синтаксис перечи

сляемых констант, описанных выше. Например,

struct MarylandClass {int size; char instructor[20];} CMSC330, CMSC630;

определяет структуру MarylandClass, содержащую целый компонент size и компо

нент instructor в виде массива из 20 символов, и объявляет две переменные CMSC330

и CMSC630 типа MarylandClass. А следующий оператор:

struct MarylandClass CMSC430;

определяет новую переменную CMSC430 типа MarylandClass, ссылаясь на то же самое

описание структуры. К членам структуры доступ осуществляется с использовани

ем точечной нотации. Так, CMSC330.size будет целочисленным компонентом size

этой структуры, а соответствующее имя CMSC330.instructor будет компонентом

instructor этой же структуры.

Объявление записи с помощью конструкции struct создает новый тип. Пара

доксально, но объявление typedef на самом деле является просто подстановкой име

ни, но новый тип оно не создает. Соответственно

typedef int newint;

определяет, что тип newint является таким же, как и тип int. Обычно такое описа

ние используется при определении структур struct. Так, во фрагменте

typedef struct NewClass { ... } MarylandClass;

MarylandClass A;

MarylandClass B;

определяется новое имя MarylandClass для структурного типа NewClass, и с помо

щью нового имени типа переменные A и B объявляются как принадлежащие также

к структурному типу NewClass.

Рис. П.1. Память, выделяемая для объединения S и структуры T

Объединение. Объединение (union)— это определение типа, синтаксически по

хожее на определение типа struct, но семантически эквивалентное вариантным

записям языка Pascal (раздел 6.1.6). Различие между типами union и srtuct показа

но на рис. П.1. В объединении S каждый его компонент имеет lзначение такое же,

П.2. C

586 Приложение. Обзоры языков

как и lзначение самого объединения S. Каждый компонент располагается в одной

и той же области памяти. В структуре T lзначение компонента A то же самое, что

и у нее самой, но все lзначения остальных компонентов отличны от lзначения струк

туры T. Каждый компонент располагается в своей собственной области памяти.

Представление объектов в памяти. Целые, вещественные с плавающей точкой

и символьные данные хранятся в своем естественном формате, а массивы не тре

буют дескрипторов. Указатели являются просто lзначениями объектов, на кото

рые они указывают. Накладные расходы при доступе к этим объектам незначи

тельны.

Указатели и массивы тесно связаны. К массиву

int A[10]

также можно получить доступ как к указателю:

int *arrayptr;

arrayptr = &A[0]; /* arrayptr óêàçûâàåò íà A[0] */

Выражение *((arrayptr) + (i)) имеет то же значение, что и a[i].

Если q — это структура struct:

struct q { int a; int b; }

тогда последовательность

struct q *p;

p = (struct q *) malloc(sizeof(struct q));

как и в предыдущем примере, выделяет память для структуры q и сохраняет ее

адрес в переменнойуказателе p. Для доступа к компонентам этой структуры ис

пользуется операция → (которая записывается как –>). На компонент a ссылаются

следующим образом: p → a; а на компонент b — p → b. Обратите внимание на то,

что p → a есть в точности то же самое, что и (*p).a.

Инициализация. Любую статически размещаемую переменную можно инициа

лизировать следующим образом:

int i=12;

Если нужно инициализировать массив, то задается список элементов:

int a[4] = (1, 2, 3, 4); char string[4] = "abc";

В последнем примере массив string инициализируется как abc\0. В массиве

должно быть зарезервировано место под завершающий nullсимвол.

П.2.2. Управление последовательностью

действий

Выражения

Одна из сильных сторон языка C — это наличие множества операций, которые могут

обрабатывать числовые данные. (Одновременно это является и его слабым местом,

потому что теперь существует много способов выполнить аналогичные операции.)

Множество операций языка C и уровни их приоритетов были приведены ранее,

в табл. 8.2.

Важно помнить о различии между поразрядными и логическими операциями.

Операция поразрядного логического È в выражении 5&4 приведет к результату, рав