Типы данных способы объявления

C Урок 4. Переменные и типы данных. Часть 1

Продолжаем освоение языка C.

И теперь пришло время познакомиться с типами данных, а также способами их представления, одним из которых являются переменные. Также есть ещё константы, но с ними мы будем знакомиться немного позже.

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

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

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

Данные различного типа – это величины, которые располагаются в каком-то месте памяти и могут занимать в ней различное количество пространства.

Типы данных можно разделить условно на три группы:

1. целые – данные целого типа,
2. вещественные – данные, которые могут иметь дробную часть,
3. символы – данные типа char, которые представляют собой какой-то символ и занимают в памяти всего один байт.

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

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

Данная таблица, думаю, всё это расскажет:

-9 223 372 036 854 775 808 …

9 223 372 036 854 775 807

Тип	Количество бит	Допустимый диапазон
char	8	-128 … 127
unsigned char	8	0 … 255
short	16	-32 768 … 32767
unsigned short	16	0 … 65535
int	32	-2 147 483 648 … 2 147 483 647
unsigned int	32	0 … 4 294 967 295
long	32	-2 147 483 648 … 2 147 483 647
unsigned long	32	0 … 4 294 967 295
long long	64
unsigned long long	64	0 … 18 446 744 073 709 551 615

Аналогичным образом ведёт себя и вещественный тип. Только представители данного типа могут иметь ещё некоторые свойства. Кроме того, что они тоже занимают в памяти каждый определенное количество байт и имеют диапазоны, они могут быть представлены ещё в нормированной форме – в виде числа, умноженного на 10 в определённой степени. Также данный вид представления называют экспоненциальной записью числа.

Например, число 135.543 можно представить как 1,35543 . 10 2 .

А, например, число 0.00001245 – как 1.245 . 10 -5 .

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

В коде мы так написать не можем, в исходном коде первое число будет выглядеть как 1.35543E2, а второе 1.245E-5.

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

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

-9 223 372 036 854 775 808 .0 …

9 223 372 036 854 775 807.0

-9 223 372 036 854 775 808 .0 …

9 223 372 036 854 775 807.0

В некоторой документации пишут, что последний тип занимает 80 бит в памяти. Пока не знаю, где правда, возможно это зависит от операционных систем, либо от каких-то стандартов, либо от компилятора. С этим, думаю, разберёмся позже, когда будем писать исходные коды, отлаживать их и смотреть результаты в дизассемблированном виде.

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

Ещё существует тип данных bool. Это целочисленный тип данных, так как диапазон допустимых значений — целые числа от 0 до 255. Данный тип используется как логический тип данных исключительно для хранения результатов логических выражений. У логического выражения может быть один из двух результатов – true или false. true — если логическое выражение истинно, false — если логическое выражение ложно. Данный тип может отсутствовать в некоторых компиляторах вообще, тогда мы используем вместо него char либо unsigned char.

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

Теперь о переменных.

Переменные существуют для хранения значений и величин определённых типов данных в памяти.

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

Самое основное требование для объявления переменной: переменная должна быть объявлена раньше, чем она будет использоваться.

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

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

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

Имя переменной для удобства должно отражать суть и назначение нашей переменной, она должна показывать нам, для чего мы её используем, то есть имя должно быть говорящим. Конечно, это не обязательно и никакие стандарты этого не предусматривают и делать это мы должны только для своего удобства, чтобы наш код легче потом читался. Так как язык C – язык для программиста, а ассемблер – это язык для процессора.

Тем не менее существует и стандарт для имени переменной. Не всякие символы можно использовать в имени переменной. можно использовать буквы только латинского алфавита, как верхнего так и нижнего регистра, причём язык C является языком регистрозависимым и, например, переменные с именами Symbol1 и symbol1 – это будут разные переменные.

Также разрешается использовать арабские цифры в именах переменных (от 0 до 9), только с одним ограничением – имя переменной не должно начинаться с цифры, например имя переменной 4symbol использовать запрещено, а s4ymbol – разрешено.

В именах переменных запрещено использовать пробелы, поэтому, например, имя переменной first var запрещено. Но чтобы нам как-то можно было больше рассказать о назначении переменных и всё же использовать там несколько слов, то вместо пробелов разрешено использовать подчёркивания – ‘_‘. Поэтому мы сможем нашу переменную назвать как first_var. Также со знака подчёркивания допустимо начинать имя переменной, но злоупотреблять этим нежелательно, так как во многих библиотеках, в т.ч. стандартных, переменные, имя которых начинается со знака подчёркивания, очень часто используется. Тем самым мы избежим повторения имён, которое недопустимо.

Запрещено также в качестве имён использовать ключевые слова – такие, к примеру, как if , else , int , float . Данные слова зарезервированы и не могут быть использованы.

Также не допускается использование в именах операторов (+, -, = и т.д.), кавычек, скобок и т.д.

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

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

char symbol1;

int cnt;

float adc_val;

char symbol1; int cnt; float adc_val;

Если переменные объявляются одного типа, то мы можем их объединить в одно объявление. В этом случае имена данных переменных между собой мы разделяем запятыми

char symbol1, symbol2, symbol3;

В случае всех вышеперечисленных операций под переменные, которые мы объявили резервируется место в памяти в таком размере, какой предусматривает тип переменной, которую мы объявляем. В этом случае содержимое резервируемых ячеек памяти как правило не изменяется и значение переменной приобретёт случайную величину. Некоторые компиляторы автоматически присваивают значение 0 объявляемым переменным.

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

Так как с различными операциями мы будем знакомиться не в данном уроке, то познакомимся пока с первым типом придания определённого значения переменной – это её инициализация.

Инициализируются переменные различными способами.

Мы можем сначала наши переменные объявить, а затем инициализировать

char symbol1, symbol2, symbol3;

int cnt;

float adc_val;

symbol1 = ‘c’ ;

symbol2 = ‘f’ ;

symbol3= ‘h’ ;

cnt = 589 ;

adc_val = 124.54 f;

Таким образом мы присвоили нашим переменным определённые значения. Теперь мы с нашими переменными в дальнейшем можем осуществлять какие-то действия – арифметические, логические, также использовать их в параметрах вызываемых функций, например, с помощью функции printf вывести их значения в консоль.

Также мы можем проделать инициализацию наших переменных сразу – на этапе объявления

char symbol1 = ‘c’ , symbol2 = ‘f’ , symbol3= ‘h’ ;

int cnt = 589 ;

float adc_val = 124.54 f;

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

Существует ещё несколько операторов, с которыми мы будем знакомиться в следующих уроках.

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

Смотреть ВИДЕОУРОК (нажмите на картинку)

Источник

Типы Данных И Их Объявление

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

Объявления переменной имеет следующий формат:

Описатель — идентификатор простой переменной либо более сложная конструкция с квадратными скобками, круглыми скобками или звездочкой (набором звездочек).

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

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

Спецификатор класса памяти — определяется одним из четырех ключевых слов языка СИ: auto, extern, register, static, и указывает,каким образом будет распределяться память под объявляемую переменную, с одной стороны, а с другой, область видимости этой переменной, т.е., из каких частей программы можно к ней обратиться.

1.2.1 Категории типов данных

Ключевые слова для определения основных типов данных

Переменная любого типа может быть объявлена как немодифицируемая. Это достигается добавлением ключевого слова const к спецификатору-типа. Объекты с типом const представляют собой данные используемые только для чтения, т.е. этой переменной не может быть присвоено новое значение. Отметим, что если после слова const отсутствует спецификатор-типа, то подразумевается спецификатор типа int. Если ключевое слово const стоит перед объявлением составных типов (массив, структура, смесь, перечисление), то это приводит к тому, что каждый элемент также должен являться немодифицируемым, т.е. значение ему может быть присвоено только один раз.

Примеры объявления составных данных будут рассмотрены ниже.

1.2.2. Целый тип данных

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

Тип	Количество бит	Допустимый диапазон
float	32	-2 147 483 648.0 … 2 147 483 647.0
double	64
long double	64

Тип	Размер памяти в байтах	Диапазон значений
char	1	от -128 до 127
int	Для IBM XT,AT,SX,DX 2
short	2	от -32768 до 32767
long	4	от -2 147 483 648 до 2 147 483 647
unsigned shar	1	oт 0 до 255
unsigned int	Для IBM XT,AT,SX,DX 2
unsigned short	2	от 0 до 65535
unsigned long	4	от 0 до 4 294 967 295

Отметим, что ключевые слова signed и unsigned необязательны. Они указывают, как интерпретируется нулевой бит объявляемой переменной, т.е., если указано ключевое слово unsigned, то нулевой бит интерпретируется как часть числа, в противном случае нулевой бит интерпретируется как знаковый. В случае отсутствия ключевого слова unsigned целая переменная считается знаковой. В том случае, если спецификатор типа состоит из ключевого типа signed или unsigned и далее следует идентификатор переменной, то она будет рассматриваться как переменная типа int. Например:

Отметим, что модификатор-типа char используется для представления символа (из массива представление символов) или для объявления строковых литералов. Значением объекта типа char является код (размером 1 байт), соответствующий представляемому символу. Для представления символов русского алфавита, модификатор типа идентификатора данных имеет вид unsigned char, так как коды русских букв превышают величину 127.

Следует сделать следующее замечание: в языке СИ не определено представление в памяти и диапазон значений для идентификаторов с модификаторами-типа int и unsigned int. Размер памяти для переменной с модификатором типа signed int определяется длиной машинного слова, которое имеет различный размер на разных машинах. Так, на 16-ти разрядных машинах размер слова равен 2-м байтам, на 32-х разрядных машинах соответственно 4-м байтам, т.е. тип int эквивалентен типам short int, или long int в зависимости от архитектуры используемой ПЭВМ. Таким образом, одна и та же программа может правильно работать на одном компьютере и неправильно на другом. Для определения длины памяти занимаемой переменной можно использовать операцию sizeof языка СИ, возвращающую значение длины указанного модификатора-типа.

Отметим также, что восьмеричные и шестнадцатеричные константы также могут иметь модификатор unsigned. Это достигается указанием префикса u или U после константы, константа без этого префикса считается знаковой.

1.2.3. Данные плавающего типа

Для переменных, представляющих число с плавающей точкой используются следующие модификаторы-типа : float, double, long double (в некоторых реализациях языка long double СИ отсутствует).

Величина с модификатором-типа float занимает 4 байта. Из них 1 байт отводится для знака, 8 бит для избыточной экспоненты и 23 бита для мантиссы. Отметим, что старший бит мантиссы всегда равен 1, поэтому он не заполняется, в связи с этим диапазон значений переменной с плавающей точкой приблизительно равен от 3.14E-38 до 3.14E+38.

Величина типа double занимает 8 бит в памяти. Ее формат аналогичен формату float. Биты памяти распределяются следующим образом: 1 бит для знака, 11 бит для экспоненты и 52 бита для мантиссы. С учетом опущенного старшего бита мантиссы диапазон значений равен от 1.7E-308 до 1.7E+308.

1.2.4. Указатели

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

спецификатор-типа [ модификатор ] * описатель .

Спецификатор-типа задает тип объекта и может быть любого основного типа, типа структуры, смеси (об этом будет сказано ниже). Задавая вместо спецификатора-типа ключевое слово void, можно своеобразным образом отсрочить спецификацию типа, на который ссылается указатель. Переменная, объявляемая как указатель на тип void, может быть использована для ссылки на объект любого типа. Однако для того, чтобы можно было выполнить арифметические и логические операции над указателями или над объектами, на которые они указывают, необходимо при выполнении каждой операции явно определить тип объектов. Такие определения типов может быть выполнено с помощью операции приведения типов.

В качестве модификаторов при объявлении указателя могут выступать ключевые слова const, near, far, huge. Ключевое слово const указывает, что указатель не может быть изменен в программе. Размер переменной объявленной как указатель, зависит от архитектуры компьютера и от используемой модели памяти, для которой будет компилироваться программа. Указатели на различные типы данных не обязательно должны иметь одинаковую длину.

Для модификации размера указателя можно использовать ключевые слова near, far, huge.

1.2.5. Переменные перечислимого типа

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

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

Формат 1. enum [имя-тега-перечисления] <список-перечисления>описатель[,описатель. ];

Формат 2. enum имя-тега-перечисления описатель [,описатель..];

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

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

Переменная типа enum могут использоваться в индексных выражениях и как операнды в арифметических операциях и в операциях отношения.

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

Список-перечисления содержит одну или несколько конструкций вида:

идентификатор [= константное выражение]

Каждый идентификатор именует элемент перечисления. Все идентификаторы в списке enum должны быть уникальными. В случае отсутствия константного выражения первому идентификатору соответствует значение 0, следующему идентификатору — значение 1 и т.д. Имя константы перечисления эквивалентно ее значению.

Идентификатор, связанный с константным выражением, принимает значение, задаваемое этим константным выражением. Константное выражение должно иметь тип int и может быть как положительным, так и отрицательным. Следующему идентификатору в списке присваивается значение, равное константному выражению плюс 1, если этот идентификатор не имеет своего константного выражения. Использование элементов перечисления должно подчиняться следующим правилам:

1. Переменная может содержать повторяющиеся значения.

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

3. Имена типов перечислений должны быть отличны от других имен типов перечислений, структур и смесей в этой же области видимости.

4. Значение может следовать за последним элементом списка перечисления.

В данном примере объявлен перечислимый тег week, с соответствующим множеством значений, и объявлена переменная rab_ned имеющая тип week.

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

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

1.2.6. Массивы

Массивы — это группа элементов одинакового типа (double, float, int и т.п.). Из объявления массива компилятор должен получить информацию о типе элементов массива и их количестве. Объявление массива имеет два формата:

спецификатор-типа описатель [константное — выражение];

Описатель — это идентификатор массива .

Спецификатор-типа задает тип элементов объявляемого массива. Элементами массива не могут быть функции и элементы типа void.

Константное-выражение в квадратных скобках задает количество элементов массива. Константное-выражение при объявлении массива может быть опущено в следующих случаях:

— при объявлении массив инициализируется,

— массив объявлен как формальный параметр функции,

— массив объявлен как ссылка на массив, явно определенный в другом файле.

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

Каждое константное-выражение в квадратных скобках определяет число элементов по данному измерению массива, так что объявление двухмерного массива содержит два константных-выражения, трехмерного — три и т.д. Отметим, что в языке СИ первый элемент массива имеет индекс равный 0.

В последнем примере объявлен массив w[3][3]. Списки, выделенные в фигурные скобки, соответствуют строкам массива, в случае отсутствия скобок инициализация будет выполнена неправильно.

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

Если при обращении к некоторой функции написать s[0], то будет передаваться нулевая строка массива s.

При обращении к массиву b можно написать, например, b[1][2] и будет передаваться вектор из четырех элементов, а обращение b[1] даст двухмерный массив размером 3 на 4. Нельзя написать b[2][4], подразумевая, что передаваться будет вектор, потому что это не соответствует ограничению наложенному на использование сечений массива.

Пример объявления символьного массива.

char str[] = «объявление символьного массива»;

Следует учитывать, что в символьном литерале находится на один элемент больше, так как последний из элементов является управляющей последовательностью ‘\0’.

1.2.7. Структуры

Cтруктуры — это составной объект, в который входят элементы любых типов, за исключением функций. В отличие от массива, который является однородным объектом, структура может быть неоднородной. Тип структуры определяется записью вида:

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

где тип-данных указывает тип структуры для объектов, определяемых в описателях. В простейшей форме описатели представляют собой идентификаторы или массивы.

Переменные s1, s2 определяются как структуры, каждая из которых состоит из двух компонент х и у. Переменная sm определяется как массив из девяти структур. Каждая из двух переменных date1, date2 состоит из трех компонентов year, moth, day. >p>Существует и другой способ ассоциирования имени с типом структуры, он основан на использовании тега структуры. Тег структуры аналогичен тегу перечислимого типа. Тег структуры определяется следующим образом:

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

В приведенном ниже примере идентификатор student описывается как тег структуры:

Тег структуры используется для последующего объявления структур данного вида в форме:

struct тег список-идентификаторов;

struct studeut st1,st2;

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

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

Доступ к компонентам структуры осуществляется с помощью указания имени структуры и следующего через точку имени выделенного компонента, например:

1.2.8. Объединения (смеси)

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

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

Доступ к элементам объединения осуществляется тем же способом, что и к структурам. Тег объединения может быть формализован точно так же, как и тег структуры.

Объединение применяется для следующих целей:

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

— интерпретации основного представления объекта одного типа, как если бы этому объекту был присвоен другой тип.

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

При использовании объекта infor типа union можно обрабатывать только тот элемент который получил значение, т.е. после присвоения значения элементу inform.fio, не имеет смысла обращаться к другим элементам. Объединение ua позволяет получить отдельный доступ к младшему ua.al[0] и к старшему ua.al[1] байтам двухбайтного числа ua.ax .

1.2.9. Поля битов

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

длинна — поля задается целым выражением или константой. Эта константа определяет число битов, отведенное соответствующему полю. Поле нулевой длинны обозначает выравнивание на границу следующего слова.

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

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

1.2.10. Переменные с изменяемой структурой

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

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

В общем случае каждый объект типа figure будет состоять из трех компонентов: area, perimetr, type. Компонент type называется меткой активного компонента, так как он используется для указания, какой из компонентов объединения geom_fig является активным в данный момент. Такая структура называется переменной структурой, потому что ее компоненты меняются в зависимости от значения метки активного компонента (значение type).

Отметим, что вместо компоненты type типа int, целесообразно было бы использовать перечисляемый тип. Например, такой

Константы CIRCLE, BOX, TRIANGLE получат значения соответственно равные 0, 1, 2. Переменная type может быть объявлена как имеющая перечислимый тип :

enum figure_chess type;

В этом случае компилятор СИ предупредит программиста о потенциально ошибочных присвоениях, таких, например, как

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

Пример определения переменной структуры с именем helth_record

Обращаться к компонентам структуры можно при помощи ссылок:

1.2.11. Определение объектов и типов

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

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

Отметим важную особенность языка СИ, при объявлении можно использовать одновременно более одного модификатора, что дает возможность создавать множество различных сложных описателей типов.

Однако надо помнить, что некоторые комбинации модификаторов недопустимы:

— элементами массивов не могут быть функции,

— функции не могут возвращать массивы или функции.

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

Для интерпретации сложных описаний предлагается простое правило, которое звучит как «изнутри наружу», и состоит из четырех шагов.

1. Начать с идентификатора и посмотреть вправо, есть ли квадратные или круглые скобки.

2. Если они есть, то проинтерпретировать эту часть описателя и затем посмотреть налево в поиске звездочки.

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

4. Интерпретировать спецификатор типа.

В данном примере объявляется переменная comp (1), как массив из десяти (2) указателей (3) на функции (4), возвращающие указатели (5) на целые значения (6).

Переменная var (1) объявлена как указатель (2) на функцию (3) возвращающую указатель (4) на массив (5) из 10 элементов, которые являются указателями (6) на значения типа char.

Кроме объявлений переменных различных типов, имеется возможность объявить типы. Это можно сделать двумя способами. Первый способ — указать имя тега при объявлении структуры, объединения или перечисления, а затем использовать это имя в объявлении переменных и функций в качестве ссылки на этот тег. Второй — использовать для объявления типа ключевое слово typedef.

При объявлении с ключевым словом typedef, идентификатор стоящий на месте описываемого объекта, является именем вводимого в рассмотрение типа данных, и далее этот тип может быть использован для объявления переменных.

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

При объявлении переменных и типов здесь были использованы имена типов (MATH FIO). Помимо этого, имена типов могут еще использоваться в трех случаях: в списке формальных параметров, в объявлении функций, в операциях приведения типов и в операции sizeof (операция приведения типа).

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

Абстрактный-описатель — это описатель без идентификатора, состоящий из одного или более модификаторов указателя, массива или функции. Модификатор указателя (*) всегда задается перед идентификатором в описателе, а модификаторы массива [] и функции () — после него. Таким образом, чтобы правильно интерпретировать абстрактный описатель, нужно начать интерпретацию с подразумеваемого идентификатора.

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

1.2.12. Инициализация данных

При объявлении переменной ей можно присвоить начальное значение, присоединяя инициатор к описателю. Инициатор начинается со знака «=» и имеет следующие формы.

Формат 1: = инициатор;

Формат 1 используется при инициализации переменных основных типов и указателей, а формат 2 — при инициализации составных объектов.

Переменная tol инициализируется символом ‘N’.

const long megabute = (1024 * 1024);

Немодифицируемая переменная megabute инициализируется константным выражением после чего она не может быть изменена.

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

При инициализации массива можно опустить одну или несколько размерностей

Если при инициализации указано меньше значений для строк, то оставшиеся элементы инициализируются 0, т.е. при описании

элементы первой строки получат значения 1 и 2, а второй 3 и 0.

При инициализации составных объектов, нужно внимательно следить за использованием скобок и списков инициализаторов.

В данном примере инициализируется массив структур comp из двух строк и трех столбцов, где каждая структура состоит из двух элементов real и imag.

В этом примере компилятор интерпретирует рассматриваемые фигурные скобки следующим образом:

— первая левая фигурная скобка — начало составного инициатора для массива comp2;

— вторая левая фигурная скобка — начало инициализации первой строки массива comp2[0]. Значения 1,1 присваиваются двум элементам первой структуры;

— первая правая скобка (после 1) указывает компилятору, что список инициаторов для строки массива окончен, и элементы оставшихся структур в строке comp[0] автоматически инициализируются нулем;

— аналогично список <2,3>инициализирует первую структуру в строке comp[1], а оставшиеся структуры массива обращаются в нули;

— на следующий список инициализаторов <4,5>компилятор будет сообщать о возможной ошибке так как строка 3 в массиве comp2 отсутствует.

При инициализации объединения задается значение первого элемента объединения в соответствии с его типом.

Инициализируется переменная pers.name, и так как это массив, для его инициализации требуется список значений в фигурных скобках. Первые пять элементов массива инициализируются значениями из списка, остальные нулями.

Инициализацию массива символов можно выполнить путем использования строкового литерала.

char stroka[ ] = «привет»;

Инициализируется массив символов из 7 элементов, последним элементом (седьмым) будет символ ‘\0’, которым завершаются все строковые литералы.

В том случае, если задается размер массива, а строковый литерал длиннее, чем размер массива, то лишние символы отбрасываются.

Следующее объявление инициализирует переменную stroka как массив, состоящий из семи элементов.

char stroka[5] = «привет»;

В переменную stroka попадают первые пять элементов литерала, а символы ‘Т’ и ‘\0’ отбрасываются.

Если строка короче, чем размер массива, то оставшиеся элементы массива заполняются нулями.

Отметим, что инициализация переменной типа tab может иметь следующий вид:

union tab pers1 = «Антон»;

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

а остальные элементы будут инициализированы нулем.

Источник