Xreferat.com » Рефераты по информатике и программированию » Основы алгоритмического языка С++

Основы алгоритмического языка С++

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

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

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.

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

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

Битовые поля не располагаются на пересечении границ, обявленных для них типов. Например, битовое поле, объявленое с типом 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 {

char c;

float *pf;

struct sample *next;

} x;

/***************** Example 5 ******************/

struct {

unsigned icon : 8;

unsigned color : 4; unsigned underline : 1; unsigned blink : 1;

} screen[25][80];

В первом примере объявляется переменная с именем complex типа структура. Эта структура состоит из двух элементов x и y типа float. Тип структуры не поименован.

Во втором примере объявляется переменная с именем temp типа структура. Структура состоит из трех элементов с именами name, id и class. Элемент с именем name- это массив иэ 20- ти элементов типа char. элементы с именами id и class- это простые переменные типа int и long соответственно. Идентификатор employee является тегом структуры.

В третьем примере объявлены три переменных типа структура с именами: student, faculty и staff. Каждая из структур состоит из трех элементов одной и той же конструкции. Элементы определены при объявлении типа структуры с тегом employee в предыдущем примере.

В четвертом примере объявляется переменная с именем x типа структура. Первые два элемента структуры представлены переменной c типа char и указателем pf на величину типа float. Третий элемент с именем next объявляются как указатель на описываемую структуру sample.

В пятом примере объявляется двумерный массив поименованный screen, элементы которого имеют структурный тип. Массив состоит из 2000 элементов и каждый элементэто отдельная структура, состоящая из четырех элементов типа bit-fild с именами icon, color, underline и blink.

Объявление совмещений

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

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

Если Вам нужна помощь с академической работой (курсовая, контрольная, диплом, реферат и т.д.), обратитесь к нашим специалистам. Более 90000 специалистов готовы Вам помочь.
Бесплатные корректировки и доработки. Бесплатная оценка стоимости работы.

Поможем написать работу на аналогичную тему

Получить выполненную работу или консультацию специалиста по вашему учебному проекту
Нужна помощь в написании работы?
Мы - биржа профессиональных авторов (преподавателей и доцентов вузов). Пишем статьи РИНЦ, ВАК, Scopus. Помогаем в публикации. Правки вносим бесплатно.

Похожие рефераты: