Лекции по C++

об'является простая переменная (такая как символ, целое или плавающее), структура или совмещение простых переменных, то декларатор- это идентификатор.

В Си определено четыре спецификатора класса памяти, а имен­но: auto, extern, register и static.

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

Об"явления функций описаны в разделе 4.4.

Спецификаторы типов

Язык Си поддерживает определения для множества базовых ти­пов данных, называемых "основными" типами. Названия этих типов перечислены в Табл. 4.1.

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

Типы целых Типы плавающих Другие типы

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

signed char float void

signed int double

signed short intsigned long int

unsigned char

unsigned int

unsignet short int unsigned long int

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

Табл. 4.1. Основные типы.

Перечислимые типы также рассматриваются как основные типы. Спецификаторы перечислимых типов рассмотрены в разделе 4.7.1. Ти­пы signed char, signed int, signed short int и signed long int

вместе с соответствующими двойниками unsigned называются типами целых.

Спецификаторы типов float и double относятся к типу "плава­ющих". В об"явлениях переменых и функций можно использовать любые спецификаторы "целый" и "плавающий".

Тип void может быть использован только для об"явления функ­ций, которые не возвращают значения. Типы функций рассмотрены в разделе 4.4.

Можно задать дополнительные спецификаторы типа путем об"яв­ления typedef, описанного в разделе 4.7.2.

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

В некоторых реализациях могут быть использованы опции ком­пилятора, позволяющие изменить умолчание для типа char со знако­вого на беззнаковый. Когда задана такая опция, сокращение char имеет то же самое значение, что и unsigned char, и следовательно ключевое слово sidned должно быть записано при об"явлении сим­вольной величины со знаком.

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

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

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

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 операцией.

Деклараторы

Синтаксис:

[]

[constant-expression>]

*

()

()

()

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

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

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

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

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- это массив из пяти указате­лей на массив из пяти указателей на совмещения.


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

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

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

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

щего типа.

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

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

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

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

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

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

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


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

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

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

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

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

[] [,...],

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

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

Синтаксис:

[,...];

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

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

Примеры

int x; /* Example 1 */

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

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

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

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

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

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

Синтаксис: enum[]{}[,...]; enum[,...];

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

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

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

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

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

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

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

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

имеет следующий синтаксис:

[=][,

[=

.

.

.

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

Запись = переопределяет последователь­ность значений, заданных по умолчанию. Идентификатор, следующий перед записью = принимает значение, задавае­мое этим константным выражением. Константное выражение имеет тип int и может быть отрицательным. Следующий идентификатор в списке ассоциируется с величиной, равной +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[]{}[,...]; struct[,...];

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

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

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

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

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

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

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

Битовые поля

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

[]:; Битовое поле состоит из некоторого числа бит, специфициро-

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

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

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

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

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

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

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