Реферат: Лекции по C++

-----------------------------------------------------------

                 Спецификатор типа                                               Сокращение

-----------------------------------------------------------

                 signed char      char

                 signed int           signed, int

                 signed short int  short, signed short

                 signed long int   long, signed long

                 unsigned char  -

                 unsigned int    unsigned

                 unsigned short int                                                     unsignet short

                 unsignet long int                                                       unsignet long

                 float                                                                          -

                 long float           double

------------------------------------------------------------

                      Табл. 4.2. Спецификаторы и сокращения

               Замечание:  в этом руководстве в основном используются сок­ращенные формы, перечисленные в Табл. 4.2, при этом предполагает­ся, что char по умолчанию знаковый.

               В табл. 4.3 для каждого типа приведены: размер распределяе­мой памяти и области значений переменных для данного  типа.  Пос­кольку  тип  void не представляет переменных, он не включен в эту таблицу.

-----------------------------------------------------------

     Тип                             Представление      Область значений

в памяти           величины

-----------------------------------------------------------

     char                             1 байт             -128 до 127

     int                                  зависит от

                                           реализации

     short         2 байта            -32768 до 32767

long                             4 байта -2.147.483.648 до 2.147.483.647

     unsigned char                1 байт              0 до 255

     unsigned                        зависит от

                                           реализации

     unsigned short  2 байта 0 до 65535

     unsigned long                4 байта                                    0 до 4.294.967.295

     float  4 байта                IEEE   стандартное

                                                                                           соглашение

     double                            8 байт                                     IEEE   стандартное

                                                                                       соглашение ------------------------------------------------------------

       Табл 4.3 Размер памяти и область значений типов

               Тип char используется для запоминания буквы, цифры или сим­вола из множества представимых символов. Значением  об"екта  типа char является ASCII код, соответствующий данному символу. Так как тип  char  интерпретируется как однобайтовая целая величина с об­ластью значений от -128 до 127, то только величины от  0  до  127

имеют символьные эквиваленты. Аналогично, тип unsigned char может запоминать величины с областью значений от 0 до 255.

               Заметим,  что представление в памяти и область значений для типов int и unsigned int не определены в языке Си.  По  умолчанию размер int (со знаком и без знака) соответствует реальному разме­ру  целого  на данной машине. Например, на 16-ти разрядной машине тип int всегда 16 разрядов или 2 байта. На 32-ух разрядной машине тип int всегда 32 разряда или 4 байта. Таким образом, тип int эк­вивалентен типам short int или long int в зависимости от реализа­ции.

               Аналогично, тип unsigned int  эквивалентен  типам  unsigned short  или  unsigned long. Спецификаторы типов int и unsigned int широко используются в программах на Си, поскольку  они  позволяют наиболее  эффективно  манипулировать  целыми величинами на данной машине.

               Однако, размер типов int и unsigned int переменный, поэтому программы, зависящие от специфики размера int и unsigned int  мо­гут  быть  непереносимы.  Переносимость кода можно улучшить путем включения выражений с sizeof операцией.

     Деклараторы

               Синтаксис:

               <identifier>

               <declarator>[]

               <declarator>[constant-expression>]

               *<declarator>

               <declarator>()

               <declarator>(<arg-type-list>)

               (<declarator>)

               Си позволяет об"являть: массивы величин, указатели на вели­чины, величины возвратов функций.  Чтобы  об"явить  эти  об"екты, нужно использовать декларатор, возможно модифицированный квадрат­ными  скобками  ([]),  круглыми скобками () и звездочкой (*), что соответствует типам массива, функции или  указателя.  Деклараторы появляются в об"явлениях указателей, массивов и функций.

Деклараторы массивов, функций и указателей

               Когда декларатор состоит из немодифицируемого идентификато­ра, то об'ект, который об"является, имеет немодифицированный тип. Звездочка, которая может появиться слева от идентификатора, моди­фицирует  его  в  тип  указателя. Если за идентификатором следуют квадратные скобки ([]), то тип модифицируется на тип массива. Ес­ли за идентификатором следуют круглые скобки, то тип  модифициру­ется  на  тип функции. Сам по себе декларатор не образует полного об"явления. Для этого в об"явление должен быть включен специфика­тор типа. Спецификатор типа задает тип элементов массива или  тип адресуемых об"ектов и возвратов функции.

               Следующие  примеры иллюстрируют простейшие формы декларато­ров:

               1. int list[20]

               2. char *cp

               3. double func(void),

               где:

               1. Массив list целых величин

               2. Указатель cp на величину типа char

               3.  Функция  func  без  аргументов,  возвращающая  величину double

     Составные деклараторы

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

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

               При интерпретации составных деклараторов может быть предло­жено простое правило, которое читается следующим образом: "изнут­ри-  наружу".  Нужно начать с идентификатора и посмотреть вправо, есть ли квадратные или круглые скобки. Если они есть,  то  проин­терпретировать  эту  часть  декларатора, затем посмотреть налево, если ли звездочка. Если на любой стадии справа встретится  закры­вающая  круглая  скобка,  то вначале необходимо применить все эти правила внутри круглых скобок, а затем продолжить  интерпретацию. на последнем шаге интерпретируется спецификатор типа. В следующем примере  проиллюстрированы  эти правила. Последовательность шагов при интерпретации перенумерована.

               char *(*(*var) ()) [10];

               ^   ^ ^ ^ ^   ^   ^

               7   6 4 2 1   3   5

               1. Идентификатор var об'явлен как

               2. Указатель на

               3. Функцию, возвращающую

               4. Указатель на

5. Массив из 10 элементов, который состоит 6. Из указателей на

               7. Величины типа char.

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

               1. int *var[5]; - массив указателей на величины типа int.

               2. int (*var)[5]; - указатель на массив величин типа int.

               3.  long *var(long,long); - функция, возвращающая указатель на величину типа long.

               4. long (*var) (long,long); - указатель на функцию, возвра­щающую величину типа long.

               5. struct both {

                                           int a;

                                           char b;

                           } ( *var[5] ) ( struct both, struct both); массив указателей на функции, возвращающих структуры.

               6. double ( *var( double (*) [3] ) ) [3];

               функция, возвращающая указатель на массив из  трех  величин типа double.

               7. union sign {

                                           int x;

                                           unsigned y;

                                           } **var[5] [5];

массив массивов указателей на указатели совмещений.

               8. union sign *(*var[5]) [5];

массив указателей на массив указателей на совмещения.

               Описание примеров:

               В  первом примере, модификатор массива имеет высший приори­тет, чем модификатор указателя, так что var об"является массивом. Модификатор указателя определяет тип элементов массива; элемента­ми являются указатели на величины типа int.

               Во втором примере скобки меняют значение об"явления первого примера. Теперь модификатор указателя имеет более высокий приори­тет, чем модификатор массива, и переменная  var  об"является  как указатель на массив из пяти величин типа int.

               В  третьем  примере модификатор функции имеет более высокий приоритет, чем модификатор  указателя,  так  что  переменная  var об"является  функцией,  возвращающей  указатель  на величину типа long. Функция об"явлена с двумя аргументами типа long.

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

               Элементы  массива  не  могут быть функциями. Взамен этому в пятом примере показано, как об"явить массив указателей  на  функ­ции.  В  этом примере переменная var об"явлена как массив из пяти указателей на функции, возвращающие структуры с двумя элементами. Оба аргумента функции об"явлены как структуры типа both. Заметим, что круглые скобки, в которые заключено выражение *var[5], обяза­тельны. Без них об"явление будет неверным, поскольку будет об"яв­лен массив функций:

                                                            /* ILLEGAL */

struct both *var[5] ( struct both, struct both );

               В шестом примере показано, как об"являть функцию, возвраща­ющую указатель на массив. Здесь var об"явлена функцией, возвраща­ющей указатель на массив из трех величин типа double.  Тип  аргу­мента  функции  задан составным абстрактным декларатором. Круглые скобки, заключающие звездочку, требуются,  так  как  в  противном случае  типом аргумента был бы массив из трех указателей на вели­чины типа double.

               В седьмом примере показано, что указатель  может  указывать на  другой  указатель  и массив может состоять из массивов. Здесь var- это массив из пяти элементов. Каждый элемент,  в  свою  оче­редь, так же массив из пяти элементов, каждый из которых является указателем на указатель совмещения, состоящего из двух элементов.

В  восьмом  примере  показано,  как круглые скобки изменили

смысл об"явления. В этом примере var- это массив из пяти указате­лей на массив из пяти указателей на совмещения.

     Об"явления переменной

               В  этом разделе дано описание синтаксиса и семантики об"яв­лений переменной. В частности, здесь  об"ясняется  каким  образом об"явить следующие переменные:

               Тип переменной                           Описание

               Простая переменная                    Переменная целого или плаваю-

                                                                      щего типа.

               Переменная перечис-                  Простая переменная целого типа

               ления.                                            которая принимает значения из

                                                                      предопределенного набора зна-

                                                       чений поименованных констант. Структура  Переменная, которой соответс-

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

               Совмещение                                 Переменная, которой соответс-

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

                 Массив                                          Переменная, представляющая на-

                                                                        бор элементов одного типа.

                 Указатель                                      Переменная, которая указывает

на другую переменную (содержит местоположение другой перемен­ной в форме адреса).

Общий синтаксис об"явлений переменных следующий:

[<sc-spesifier>] <type-spesifier> <declarator> [,<declarator>...],

     где  <type-  spesifier> - задает тип данных, представляемых переменной, а <declarator> - это имя переменной, возможно модифи­цированное для об"явления массива или указателя. В об"явлении мо жет быть задана более чем одна переменная путем задания  множест­венного  об"явления,  в  котором  деклараторы разделены запятыми. <sc- spesifier> задает класс памяти переменной. В некоторых  слу­чаях  переменные  могут быть инициализированы при их определении. Классы памяти и инициализация описаны в разделах 4.6 и 4.7  соот­ветственно.

          Объявление простой переменной

               Синтаксис:

               <type-specifier><identifier>[,<identifier>...];

               Об"явление  простой  переменной определяет имя переменной и ее тип; оно может также определять класс памяти  переменной,  как это описано в разделе 4.6. Имя переменной- это идентификатор, за­данный  в  об"явлении.  Спецификатор типа <type-specifier> задает имя определяемого типа данных.

               Можно определить имена различных переменных в том же  самом об"явлении,  задавая список идентификаторов, разделенных запятой. Каждый идентификатор списка именует переменную.  Все  переменные, заданные в об"явлении, имеют один и тот же тип.

               Примеры

               int x;                            /* Example 1 */

unsigned long reply, flag         /* Example 2 */ double order;                     /* Example 3 */

В  первом примере об"является простая переменная x. Эта пе-

ременная может принимать любое значение  из  множества  значений, определяемых для типа int.

               Во  втором  примере об"явлены две переменные: reply и flag. Обе переменные имеют тип unsigned long.

               В третьем примере об"явлена переменная order, которая имеет тип double. Этой переменной могут быть присвоены величины с  пла­вающей запятой.

          Объявление перечисления

          Синтаксис: enum[<tag>]{<enum-list>}<identifier>[,<identifier>...]; enum<tag><identifier>[,<identifier>...];

               Об"явление  перечисления задает имя переменной перечисления и определяет список именованных констант, называемый списком  пе­речисления.  Значением каждого имени списка является целое число. Переменная перечисления принимает значение одной  из  именованных констант  списка. Именованные константы списка имеют тип int. Та-

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

Объявление перечисления начинается с ключевого слова enum и

имеет две формы представления. В первой форме представления имена перечисления задаются в списке перечисления <enum-list>.

               Опция  <tag>-  это идентификатор, который именует тип пере­числения, определенного в <enum-list>.

               Переменную перечисления именует <identifier>. В  об"явлении может быть описана более чем одна переменная перечисления.

               Во второй форме используется тег перечисления, который ссы-

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

               <enum-list> имеет следующий синтаксис:

<identifier>[=<constant-expression>][,<identifier>

                                                                        [=<constant-expression]]...

              .

              .

              .

               Каждый  идентификатор  именует  элементы  перечисления.  По умолчанию первому идентификатору соответствует значение 0, следу­ющий идентификатор ассоциируется со значением 1 и т. д. Имя конс­танты перечисления эквивалентно ее значению.

               Запись =<constant-expression> переопределяет последователь­ность значений, заданных по умолчанию.  Идентификатор,  следующий перед записью =<constant-expression> принимает значение, задавае­мое  этим константным выражением. Константное выражение имеет тип int и может быть отрицательным. Следующий идентификатор в  списке ассоциируется  с  величиной, равной <constant-expression>+1, если он явно не задается другой величиной.

               Перечисление может содержать повторяющиеся значения иденти­фикаторов, но каждый идентификатор должен быть уникальным.  Кроме того,  он должен быть отличным от всех других идентификаторов пе­речислений с той же видимостью. Например, двум различным  иденти­фикаторам  null и zero может быть задано значение 0 в одном и том же перечислении. Идентификаторы должны  быть  отличны  от  других идентификаторов  с той же самой видимостью, включая имена обычных переменных и идентификаторы других перечислений. Теги  перечисле­ний  должны  быть отличны от тегов перечислений, тегов структур и совмещений с той же самой видимостью.

               Примеры:

               /**************** Example 1 ***************/

               enum day {

                                    saturday,

                                    sunday = 0,

                                    monday,

                                    tuesday,

                                    wednesday,

                                    thursday,

                                    friday

                                    } workday;

                 /***************** Example 2 ***************/

                 enum day today = wednesday;

               В первом примере определяется тип перечисления, поименован­ный day и об"является переменная workday этого типа перечисления. С saturday по умолчанию ассоциируется значение  0.  Идентификатор sunday  явно  устанавливается  в  0. Оставшиеся идентификаторы по умолчанию принимают значение от 1 до 5.

               Во втором примере переменной today типа enum day присваива­ется значение из перечисления. Заметим, что для присваивания  ис­пользуется  имя константы из перечисления. Так как тип перечисле­ния day был  предварительно  об"явлен,  то  достаточно  сослаться только на тег перечисления.

          Объявления структур

                        Синтаксис: struct[<tag>]{<member-declaration-list>}<declarator>[,<declarator>...]; struct<tag><declarator>[,<declarator>...];

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

               Об"явление  структуры начинается с ключевого слова struct и имеет две формы представления, как показано выше. В первой  форме представления  типы и имена элементов структуры специфицируются в списке об"явлений элементов <member-declaration-list>. <tag>- это идентификатор, который  именует  тип  структуры,  определенный  в списке об"явлений элементов.

               Каждый  <declarator>  задает имя переменной типа структуры. Тип переменной в деклараторе может быть модифицирован  на  указа­тель к структуре, на массив структур или на функцию, возвращающую структуру.

               Вторая синтаксическая форма использует тег- <tag> структуры для  ссылки на тип структуры. В этой форме об"явления отсутствует список об"явлений элементов, поскольку тип структуры определен  в другом  месте. Определение типа структуры должно быть видимым для тега, который используется  в  об"явлении  и  определение  должно предшествовать об"явлению через тег, если тег не используется для об"явления  указателя  или структурного типа typedef. В последних случаях об"явления могут использовать тег структуры без предвари­тельного определения типа структуры, но все же определение должно находиться в пределах видимости об"явления.

               Список об"явлений элементов <member-declaration-list>-  это одно  или  более  об"явлений переменных или битовых полей. Каждая

переменная,  об"явленная  в  этом  списке,  называется  элементом структурного  типа. Об"явления переменных списка имеют тот же са­мый синтаксис, что и об"явления  переменных  обсуждаемых  в  этой главе,  за  исключением  того,  что об"явления не могут содержать спецификаторов класса памяти или инициализаторов. Элементы струк­туры могут быть любого  типа:  основного,  массивом,  указателем, совмещением или структурой.

               Элемент  не может иметь тип структуры, в которой он появля­ется. Однако, элемент может быть об"явлен, как указатель  на  тип структуры,  в  которую  он  входит,  позволяя создавать списочные структуры.

          Битовые поля

Об"явления битовых полей имеют следующий синтаксис:

   <type-specifier>[<identifier>]:<constant-expression>; Битовое  поле состоит из некоторого числа бит, специфициро-

ванных константным выражением- <constant- expression>. Для  бито-

вого поля спецификатор типа <type- specifier> должен специфициро-

вать  беззнаковый  целый тип, а константное выражение должно быть неотрицательной целой величиной. Массивы битовых полей, указатели на битовые поля и функции, возвращающие битовые поля не  допуска­ются.  Идентификатор- <identifier> именует битовое поле. Неимено­ванное битовое поле, чей размер специфицируется как нулевой, име­ет специальное назначение: оно гарантирует, что память для следу­ющей переменной об"явления будет начинаться на границе int.

Страницы: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11