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

                                           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.

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

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

               Битовые  поля не располагаются на пересечении границ, обяв­ленных для них типов. Например, битовое поле, об"явленое с  типом unsigned  int,  упаковывается  или  в пространстве, оставшимся от предидущего unsigned int или начиная с нового unsigned int.

               Примеры

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

                 struct {

                                           float x,y;

                           } complex;

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

                 struct employee {

                                              char name[20];

                                              int id;

                                              long class;

                           } temp;

                 /**************** Example 3 ******************/

struct employee student, faculty, staff;

/**************** Example 4 ******************/ struct sample {

Страницы: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17