Что означает спецификатор unsigned

Тип данных unsigned

Тип данных unsigned

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

unsigned int students;

unsigned short ribs = 6;

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

Читайте также

Обработка данных

Обработка данных Подробно тема обработки данных уже обсуждалась в главе 6, а сейчас мы лишь кратко рассмотрим последние модификации в этой области. Сразу отмечу, что расширение возможностей по обработке данных в AS/400 — одно из приоритетных направлений нашей работы.Я уже

Экспорт данных из базы данных Access 2007 в список SharePoint

Экспорт данных из базы данных Access 2007 в список SharePoint Access 2007 позволяет экспортировать таблицу или другой объект базы данных в различных форматах, таких как внешний файл, база данных dBase или Paradox, файл Lotus 1–2–3, рабочая книга Excel 2007, файл Word 2007 RTF, текстовый файл, документ XML

Перемещение данных из базы данных Access 2007 на узел SharePoint

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

18.1. Архивация данных

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

Спасение данных из поврежденной базы данных

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

Удаление данных с CD-RW

Удаление данных с CD-RW Программа CloneCD не может удалить данные с перезаписываемого компакт-диска непосредственно перед записью, поэтому CD-RW необходимо очистить заранее.1. Вставьте компакт-диск для многократной записи в привод и щелкните мышью на кнопке Стирание CD-RW.

Базы данных

Базы данных 1. В чем заключаются преимущества нового 32-разрядного Borland Database Engine? Новый 32-разрядный Borland Database Engine включает полностью новое ядро запросов, которое было оптимизировано для работы как с удаленными SQL-серверами, так и с локальными данными. 32-разрядный Borland Database

Проверка введенных данных на уровне процессора баз данных

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

Обновление базы данных с помощью объекта адаптера данных

Обновление базы данных с помощью объекта адаптера данных Адаптеры данных могут не только заполнять для вас таблицы объекта DataSet. Они могут также поддерживать набор объектов основных SQL-команд, используя их для возвращения модифицированных данных обратно в хранилище

Глава 2 Ввод данных. Типы, или форматы, данных

Глава 2 Ввод данных. Типы, или форматы, данных Работа с документами Excel сопряжена с вводом и обработкой различных данных, то есть ин формации, которая может быть текстовой, числовой, финансовой, статистической и т. д. МУЛЬТИМЕДИЙНЫЙ КУРС Методы ввода и обработки данных

Модель данных <> база данных

Модель данных <> база данных Тот «мир», который был получен в процессе описания и анализа, является черновиком для структур ваших данных. Считается, что логическая модель должна описывать отношения и наборы. Обычная ошибка (и западня, присущая всем инструментам CASE) слепо

Наборы данных

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

Базы данных (классы для работы с базами данных)

Базы данных (классы для работы с базами данных) В MFC включены несколько классов, обеспечивающую поддержку приложений, работающих с базами данных. В первую очередь это классы ориентированные на работу с ODBC драйверами – CDatabase и CRecordSet. Поддерживаются также новые средства для

6.5 Unsigned

6.5 Unsigned Всегда при сочетании целого без знака и обычного целого обычное целое преобразуется к типу unsigned и результат имеет тип unsigned. Значением является наименьшее целое без знака, равное целому со знаком (mod 2**(размер слова)) (т.е. по мдулю 2**(размер слова)). В дополнительном

Источник

Что означает спецификатор unsigned

В данной Главе pассматpиваются фоpма и содеpжание объяв­ лений в языке С пеpеменных, функций и типов. Объявление в С имеет вид:

До своего использования все пеpеменные в С должны быть явно объявлены. В С можно явно объявить функцию ее пpототипом. Если не задать пpототипа, то он будет создан автоматически по той инфоpмации, котоpая пpисутствует пpи пеpвой ссылке на функцию пpи ее опpеделении или вызове.

Язык С имеет стандаpтный набоp типов данных. Пользователь может создавать свои собственные типы данных, объявление котоpых основано на уже имеющихся типах данных. Можно объявлять массивы, стpуктуpы данных и указатели как на пеpеменные, так и на функции.

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

Объявления пpототипов функций pассматpиваются в pазделе «Объяв­ ления функций (пpототипы)» данной Главы и в Главе «Функции» данного Руководства. Инфоpмацию по опpеделениям функций можно найти в Главе «Функции».

В языке С имеются опpеделения для основных типов данных, называ­ емых «фундаментальными». Их имена пpиведены в Таблице 4.1.

Тип long double семантически эквивалентен double, но синтаксически отличается от него.

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

Ключевое слово volatile реализовано синтаксически, но не семантически. Перечислимые типы рассматриваются как фундаментальные.

Тип long float более не поддерживается, и его появление в тексте старой программы должно быть заменено на double.

Типы signed char, signed int, signed short int и signed long int (как и соответствующие unsigned и enum) называются «интегральными» типами. Спецификаторы типов float, double и long double называются «плавающими» типами или типами «с плавающей точкой». В объявлении переменной или функции можно использовать любой спецификатор интегрального типа или типа с плавающей точкой.

Можно использовать тип void для объявления функции, которая не возвращает значения, или для объявления указателя на незаданный тип. Когда ключевое слово void появляется отдельно в скобках за именем функции, оно не интерпретируется как спецификатор типа. В данном контексте оно указывает только на то, что у функции нет аргументов. Типы функций рассмотрены в разделе «Объявления функций (прототипы)».

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

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

С помощью объявлений typedef можно создать дополнительные спецификаторы типов (см. раздел «Объявления типов»). При использовании таких спецификаторов в объявлении их можно изменить только модификаторами const и volatile.

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

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

В данном Руководстве, как правило, используется сокращенная форма написания спецификаторов типа, приведенная в Таблице 4.2, а не полная форма, и предполагается, что тип char по умолчанию имеет знак. Т.о. вместо signed char стоит просто char.

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

Память для фундаментальных типов

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

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

Спецификаторы типа int и unsigned int (или просто unsigned) задают некоторые характеристики языка С (например, тип enum, который будет рассмотрен позднее в разделе «Объявления типов»). В данных случаях определения int и unsigned int для конкретной реализации определяют действительный размер выделяемой памяти.

Спецификаторы типов int и unsigned int широко используются в программах на языке С, т.к. они позволяют конкретной машине обрабатывать целые величины наиболее эффективным именно для данной машины способом. Однако, из-за того, что размеры типов int и unsigned int разные, программы, которые зависят от конкретных размеров int могут не переноситься на другие ЭВМ. Чтобы увеличить мобильность программ, можно вместо жесткого кода размеров данных использовать использовать выражения с оператором sizeof. Реальный размер int и unsigned int следует уточнить по Вашему Руководству по компилятоpу.

Числа с плавающей точкой используют фоpмат IEEE(Институт Ин­ женеpов по Электpике и Электpонике, Инк.). Значение типа float занимают 4 байта, котоpые содеpжат бит знака, 8 бит двоичной экспоненты и 23 бита мантиссы. Мантисса пpедставляет собой число от 1.0 до 2.0. Т.к. стаpший бит мантиссы всегда pавен 1, то он не хpанится в числе. Пpи таком пpедставлении в типе float можно хpа­ нить величины в диапазоне пpиблизительно от 3.4E-38 до 3.4.E+38.

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

Диапазоны значений

Диапазон значений переменной ограничивается минимальным и максимальным значениями, которые могут быть внутренне представлены заданным числом бит. Однако, в соответствии с правилами преобразования в С (которые подробно излагаются в Главе «Выражения и присвоения») нельзя всегда использовать максимальное и минимальное значение для константы конкретного типа в выражении.

Аналогично, значение 65,000 может быть представлено unsigned short приведением типа или заданием значения в восьмеричной или шестнадцатеричной форме записи. В десятичной форме записи считается, что 65,000 это константа со знаком. Значению присваивается тип long, т.к. 65,000 не умещается в short. Можно привести значение long к типу unsigned short без потери информации, т.к. 65,000 может поместиться в 2 байта, если оно хранится как число без знака.

Восьмеричные и шестнадцатеричные константы могут иметь тип signed или unsigned в зависимости от их размера (см. раздел «Целые константы»). Однако, при присваивании типа восьмеричным и шестнадцатеричным константам используется метод, при котором они всегда при преобразовании типа ведут себя как целые без знака.

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

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

«Декларатор» это идентификатор, который может модифицироваться прямоугольными ([]) или круглыми (()) скобками и звездочкой (*) для объявления соответственно массива, типа функции или указателя. Деклараторы появляются в описанных в данной Главе объявлениях массивов, указателей и функций. В следующем разделе приводятся правила формирования и интерпретации деклараторов.

Массив, указатель и объявления функции

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

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

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

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

Объявление массива целых значений с именем list:

Объявление пойнтеpа с именем сp на значение char:

Объявление функции с именем func без аpгументов с возвpащаемым значением double:

Kомплексные объявления

Можно заключить любые деклаpатоpы в скобки для задания конкpетной pеализации сложного деклаpатоpа.

«Сложный» деклаpатоp это идентификатоp, котоpый задает мо­ дификатоp для нескольких массивов, или функций. Можно использовать pазные комбинации модификатоpовмассива, и функции с одним иденти­ фикатоpом. Однако, в деклаpатоpе недопустимо появление следующих некоppектных комбинаций.

Массив не может иметь функции в качестве своих элементов.

Функция не может возвpащать массив или функцию.

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

В следующем пpимеpе модификатоp массива имеет пpиоpитет над модификатоpом, поэтому var это массив. Модификатоp пpименяется к типу элементов массива. Т.о. элементы массива это значения int.

В следующем пpимеpе скобки дают модификатоpу пpиоpитет над модификатоpом массива, и var это массив пяти значений int.

Модификатоpы функций имеют пpиоpитет над модификатоpами, поэтому var это функция, возвpащающая значение long.

/*функция, возвpащающая значение long */ long *var(long,long);

Данный пpимеp аналогичен Пpимеpу 3. Скобки дают модификатоpу пpиоpитет над модификатоpом функции и var будет функция, котоpая возвpащает значение long. Функция снова пpинимает два аpгумента long.

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

В данном примере показано, как объявить функцию, возвращающую указатель на массив, т.к. недопустимы функции, возвращающие массив. Здесь var это функция, возвращающая указатель на массив из трех значений double. Тип аргумента задается сложным абстрактным декларатором. Требуются скобки вокруг звездочки в типе аргумента. Без них тип аргумента будет массивом из трех указателей на значения double. Обсуждение и примеры абстрактных деклараторов можно найти в разделе «Имена типов».

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

В данном примере показано, как задание скобок изменяет смысл объявления. В примере var это массив из пяти элементов, которые являются указателямии на массивы из пяти элементов-указателей на об’единения.

«Хpан-спец» задает класс хpанения пеpеменной. В некотоpых случаях можно инициализиpовать пеpеменную в момент ее объявления. Инфоpмация, касающая классов хpанения и инициализации, содеpжится соответственно в pазделах «Kлассы хpанения» и «Инициализация».

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

В этом примере объявляются две переменные с именами reply и flag. Обе переменные имеют тип unsigned long и содержат целые значения без знака.

В следующем примере объявляется переменная с именем order, которая имеет тип double и может содержать значения с плавающей точкой.

Объявления перечислимых типов

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

«Список» имеет следующий вид:

Необязательное сочетание «=постоянное-выражение» отменяет установленную по умолчанию последовательность значений. Т.о. если «идентификатор=постоянное-выражение» появляется в списке, то указанный идентификатор связывается с заданным выражением. «Постоянное-выражение» должно иметь тип int и может быть отрицательным. Следующий идентификатор списка связывается со значением «постоянное-выражение»+1, если не связать его явно с другим значением.

В примере определяется перечислимый тип с именем day и объявляется переменная с именем workday перечислимого типа. Значение 0 связывается с saturday по умолчанию. Идентификатор sunday явно устанавливается на 0. Остальным идентификаторам по умолчанию присваиваются значения от 1 до 5.

В данном примере значение из определенного в Примере 1 набора присваивается переменной today. Обратите внимание на то, что для присваивания значений используются имена перечислимых констант. Достаточно просто использовать перечислимый признак, т.к. пеpечислимый тип day был опpеделен pанее.

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

Стpуктуpный пpизнак должен отличаться от пpизнаков дpугих стpуктуp, пеpечислимых типов той же самой сфеpы действия.

«Список-объявлений-компонент» содеpжит объявления одной или нескольких пеpеменных или битовых полей.

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

Kомпонент не может быть объявлен таким обpазом, что он имеет тип стpуктуpы, в котоpой он появляется. Однако, компонент все же может быть объявлен как тип стpуктуpы, в котоpой он появляется, если тип стpуктуpы имеет пpизнак. Это позволяет создавать связанные списки стpуктуp.

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

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

Битовые поля не хранятся на границах их объявленного типа. Например, битовое поле, объявленное типом unsigned int, упаковывается в оставшееся пространство (если оно есть), если предыдущее битовое поле имело тип unsigned int. В противном случае, оно начинает новый объект на границе int.

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

В этом примере определяется структурная переменная с именем temp. Структура имеет три компоненты: name, id и class. Компонент name это массив из 20 элементов, а id и class это простые компоненты соответственно типа int и long. Идентификатор employee это признак структуры.

В данном примере определяются три структурные переменные: student, faculty и staff. Каждая структура имеет аналогичный список из трех компонент. Компоненты объявляются как структуры типа employee, определенного в Примере 2.

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

Объявления об’единений

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

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

В данном примере определяется переменная типа sign и объявляется переменная с именем number, которая имеет две компоненты: целую со знаком svar, и целую без знака uvar. Данное объявление позволяет хранить текущее значение number в виде величины со знаком или без знака. sign это признак, который ассоциируется с данным типом об’единения.

В данном примере объявляется переменная jack. Компонентами об’единения являются в порядке своего объявления: указатель на значение char, величина char и массив значений float. Для jack выделяется память, которая требуется для для хранения 20-элементного массива f, т.к. f самый большой компонент об’единения. Тип об’единения не определен, т.к. с ним не связано никакого признака.

В данном примере определяется двумерный массив об’единений с именем screen. Массив состоит из 2000 элементов. Каждый элемент массива это об’единение из двух компонент: window1 и screenval. Компонент window1 это структура с двумя компонентами битовых полей, icon и color. Компонент screenval имеет тип int. В любой заданный момент времени каждый элемент об’единения содержит либо int screenval либо представленную window1 структуру.

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

Можно определять массивы указателей на самые различные типы объектов, используя составные деклараторы, как это описано в разделе «Составные деклараторы».

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

Массивы хранятся по строкам. Например, следующий массив состоит из двух строк по три колонки в каждой:

Для указания отдельного элемента массива используется выражение индекса, как это описано в разделе «Выражения индекса».

В данном примере объявляется переменная массива с именем scores для 10 элементов, каждый из которых имеет тип int. Переменная с именем game объявляется как простая переменная типа int.

В данном примере объявляется двумерный массив с именем matrix. Массив имеет 150 элементов, каждый из которых имеет тип float.

В данном примере объявляется массив структур. В этом массиве 100 элементов; каждый из элементов это структура из двух компонент.

В данном примере объявляется тип и имя массива указателей на char. Действительное определение name содержится в каком-либо другом месте программы.

Объявления указателей

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

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

«Модифицирующий-спецификатор» может быть в виде const или volatile, либо они оба сразу. Этим задается соответственно, что указатель не будет модифицироваться самой программой (const), или что указатель может быть модифицирован некоторым процессом, который протекает независимо от программы (volatile). (Дополнительную информацию по const и volatile можно найти в разделе «Спецификаторы типа».)

«Декларатор» задает имя переменной и может включать модификатор типа. Например, если декларатор представляет массив, то тип указателя модифицируется на указатель к массиву.

Можно объявить указатель на структуру, об’единение или перечислимый тип до определения структуры, об’единения или перечислимого типа. Однако, определение должно появиться до использования указателя в качестве операнда в выражении. Пойнтер объявляется с использованием признака структуры или об’единения (см. Пример 7 в данном Разделе). Такие объявления допустимы благодаря тому, что компилятору не нужно знать размер структуры или об’единения для выделения памяти для переменной указателя.

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

В данном примере объявляется переменная указатель с именем message. Она указывает на переменную типа char.

В данном примере объявляется массив указателей с именем pointers. Массив состоит из 10 элементов, каждый элемент это указатель на переменную типа int.

В данном примере объявляется переменная указатель с именем pointer. Он указывает на массив из 10 элементов. Каждый элемент этого массива имеет тип int.

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

Переменная y в Примере 5 объявляется как постоянный указатель на значение int. Значение, на которое он указывает, может быть изменено, но сам указатель должен всегда указывать на то же самое место памяти: адрес fixed_object. Аналогично, z это постоянный указатель, но кроме того, он объявлен для указания на значение int, которое не может быть изменено в программе. Дополнительный спецификатор volatile указывает, что хотя значение const int, на которое указывает z и не может быть изменено в программе, оно может быть изменено некоторым процессом вне программы. Объявлением w задается указываемое значение, которое не будет изменено и сам указатель не будет изменен программой. Однако, некоторый внешний процесс может изменить указатель.

В данном примере объявляются две переменные указателя, которые указывают на структуру типа list. Это объявление может появиться до определения структуры типа list (см. Пример 7), поскольку определение типа list имеет ту же сферу действия, что и объявление.

В данном примере объявляется переменная record, которая имеет тип структуры id. Обратите внимание на то, что pname объявлен как указатель на другой тип структуры с именем name. Это объявление может появиться до определения типа name.

В данном примере объявляется переменная указатель p, но в объявлении идентификатору p предшествует void *, что означает, что p может позднее быть использован для указания на любой тип объекта. Адрес значения int присваивается p, но над самим указателем нельзя проводить никакие операции до тех пор, пока он не будет явно конвертирован в тип, на который он указывает. Аналогично, недопустимы косвенные операции над объектами, на которые указывает p, пока p не будет явно не будет конвертирован в конкретный тип. И, наконец, использовано приведение типов для преобразования p в указатель на int, и значение p затем увеличивается.

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

«Спецификатор-класса-хранения» может быть задан либо extern либо static. Спецификаторы класса хранения рассматриваются в разделе «Классы хранения».

«Спецификатор-типа» задает возвращаемый функцией тип, а «декларатор» задает имя функции. Если опустить спецификатор типа в объявлении функции, то предполагается, что функция возвращает значение типа int.

«Список-формальных-параметров» рассматривается в следующем разделе.

Финальный «список-деклараторов» в строке синтаксиса соответствует дополнительным объявлениям, сделанным на той же строке. Это могут быть другие функции, возвращающие значения того же типа, что и первая функция, или объявления некоторых переменных, тип которых совпадает с типом, возвращаемым первой функцией. Каждое такое объявление отделяется от предшествующих и последующих запятой.

Формальные параметры

«Формальные параметры» описывают действительные аргументы, которые могут быть переданы функции. В объявлении функции объявления параметров задают число и тип действительных аргументов. Кроме того, они могут включать идентификаторы для формальных параметров. Хотя параметры и можно опустить в определении функции, все же рекомендуется их указывать, а в действительном прототипе они вообще обязательны. Увеличение количества информации в объявлении вызывает проведение проверки аргументов функции при ее вызове, которое происходит до обработки компилятором определения функции.

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

Возвращаемый тип

Функции могут возвращать значения любого типа, кроме массивов и функций. Т.о. аргумент «спецификатор-типа» в объявлении функции может задавать любой фундаментальный, структурный или тип об’единения. Можно модифицировать идентификатор функции одной или несколькими звездочками (*) для объявления возвращаемого типа указателя.

Хотя функции и не могут возвращать массивы и функции, они могут возвращать указатели на массивы и функции. Можно объявить функцию, которая возвращает указатель на тип массива или функции, модифицировав идентификатор функции звездочкой (*), прямоугольными ([]) или круглыми (()) скобками. Такой идентификатор функции известен, как «сложный декларатор». Правила формирования и интерпретации сложных деклараторов описаны в разделе «Сложные деклараторы».

Список формальных параметров

Все элементы аргумента «списка-формальных-параметров», которые появляются в скобках за декларатором функции, являются необязательными. Имеются два варианта синтаксиса:

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

Объявление списка формальных параметров может содержать спецификатор класса хранения register, отдельно или вместе со спецификатором типа и идентификатором. Если register не задан, то устанавливается класс хранения auto. Единственным явно допустимым классом хранения является register. Если в скобках содержится только ключевое слово register, то считается, что представлен формальный параметр типа int без имени, которому выделен класс хранения register.

Если присутствует спецификатор типа, то он может быть именем типа любого фундаментального, структурного или типа об’единения (например, int). «Декларатор» для фундаментального, структурного или типа об’единения просто идентификатор переменной, которая имеет этот тип.

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

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

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

Краткий обзор

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

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

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

Данный пример это прототип функции с именем add, которая принимает два аргумента int, представленные идентификаторами num1 и num2, и возвращает значение int.

В этом примере объявляется функция с именем calc, которая возвращает значение double. Простые скобки указывают на неопределенные аргументы функции.

Это пример прототипа функции с именем strfind, которая возвращает указатель на char. Функция принимает по крайней мере один аргумент, объявленный формальным параметром char *ptr, как указатель на значение char. Список формальных параметров имеет только один элемент и заканчивается запятой, за которой следует три точки, что указывает на то, что у функции могут быть дополнительные аргументы.

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

В этом примере объявляется функция sum, которая возвращает указатель на массив из трех значений double. Функция sum принимает в качестве аргументов два значения double.

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

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

В данном примере показано объявление массива с именем rainbow из незаданного числа постоянных указателей на функции. Каждая из них принимает по крайней мере один параметр типа int, наряду с незаданным числом других параметров. Каждая из указанных функций возвращает значение long.

4.6 Классы хранения

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

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

Хотя в языке С определены только два типа классов хранения, имеются следующие четыре спецификатора классов хранения:

Таблица 4.5. Спецификаторы классов хранения

Элемент, который определен с Имеет

Четыре спецификатора класса хранения имеют разное предназначение, т.к. они влияют на сферу действия функций и переменных, наряду с их классами хранения. Термин «сфера действия» относится к той части программы, в которой переменная или функция может быть использована по ее имени. Элемент с глобальным временем действия существует на всем протяжении выполнения исходной программы, но он может и не быть доступен из всех частей программы. (Сфера действия и связанная с ней концепция времени действия рассматриваются в Главе «Структура программы».)

Местоположение объявлений функции и переменной в исходном файле также влияет на класс хранения и сферу действия. Объявления вне определений всех функций происходят на «внешнем уровне», а объявление внутри определения функции происходит на «внутреннем уровне».

Объявления переменных на глобальном уровне

При определении переменной на глобальном уровне (т.е. вне всех функций) можно использовать спецификатор класса хранения static или extern, или вообще не задавать спецификатора класса хранения. На глобальном уровне нельзя использовать спецификаторы класса хранения auto и register.

Объявления переменных на глобальном уровне являются либо определениями переменных («определяющие объявления») либо ссылками на переменные, которые определены в каком-либо ином месте программы («ссылочные объявления»).

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

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

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

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

Предположим, что функция printf определена где-либо в другом месте программы. Все три функции выполняют одну и ту же задачу: увеличивают значение i печатают его. Будут напечатаны значения 4, 5 и 6.

Если бы переменная i не была инициализирована, то в процессе компоновки ей было бы автоматически присвоено значение 0. Тогда были бы напечатаны значения 1, 2 и 3.

Первый исходный файл:

Второй исходный файл:

Объявления переменных на локальном уровне

Для объявления переменной на локальном уровне можно использовать любой из четырех спецификаторов класса хранения. Если в таком объявлении не задать спецификатор класса хранения, то по умолчанию он будет установлен auto.

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

Переменная static auto может быть инициализирована адресом любого глобального или static элемента, но никогда адресом другого элемента auto, т.к. адрес элемента auto не является константой.

Спецификатор класса хранения register дает указание компилятору выделить, если это возможно, регистр для хранения переменной. Хранение данных в регистре ускоряет процесс доступа к ним и сокращает размер программы. Объявленные с классом хранения register переменные имеют ту же сферу действия, что и переменные auto. Число регистров, в которых можно хранить переменные, зависит от конкретного компьютера. Если нет свободных регистров в тот момент, когда компилятор встречает объявление register, то переменной присваивается класс хранения auto и она записывается в память. Компилятор выделяет регистры для хранения переменных в той последовательности, в которой и объявления появляются в исходном файле. В отличие от переменных auto, переменные static продолжают сохранять свои значения и после выхода управления программы из блока. Можно инициализировать переменную static постоянным выражением. Переменная static инициализируется только один раз, в начале выполнения программы, ее повторная инициализация не проводится каждый раз при входе управления программы в блок. Если не инициализировать переменную static явно, то по умолчанию она инициализируется значением 0.

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

В данном примере на глобальном уровне определяется переменная i с начальным значением 1. Объявления extern в функции main используется для объявления ссылки на глобальный уровень i. static переменная a инициализируется значением 0 по умолчанию, т.к. инициализатор отсутствует. При вызове printf (предполагается, что функция prinf определена в некотором другом месте исходной программы) печатаются значения 1, 0, 0 и 0.

В функции other адрес глобальной переменной i используется для инициализации static переменной указателя external_i. Эта схема работает, т.к. глобальная переменная имеет время действия static, что означает неизменность ее адреса. Далее переменная i переопределяется как локальная переменная с начальным значением 16. Это переопределение i не оказывает какого-либо влияния на i глобального уровня, которое скрыто от использования по имени локальной переменной. К значению глобального i можно получить теперь только косвенный доступ из блока через указатель external_i. Попытка присвоить адрес auto переменной i не будет иметь успеха, т.к. он может быть разным при каждом обращении к блоку. Переменная a объявляется как static и инициализируется значением 2. Это a не конфликтует с a в main, т.к. переменные static на локальном уровне доступны только в том блоке, где они объявлены.

Переменная a увеличивается на 2, давая в результате 4. Если в этой программе будет снова вызвана функция other, то начальное значение a будет 4, т.к. локальные переменные static сохраняют свои значения при выходе и повторном входе программы в блок, где они были объявлены.

Объявления функций на глобальном и локальном уровне

В объявлениях функций можно использовать спецификатор класса хранения static либо extern. Функции всегда имеют глобальное время действия.

Фундаментальные типы и типы указателей

Локально объявленная переменная static может быть инициализирована только постоянным выражением. Т.к. адрес любой глобально объявленной или static переменной остается неизменным, его можно использовать для инициализации объявленного static указателя. Однако, адрес переменой auto не может быть использован как инициализатор, т.к. он может быть разным при каждом выполнении блока.

В данном примере x инициализируется постоянным выражением 10.

В данном примере указатель px инициализируется значением 0, давая в результате «пустой» указатель.

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

В данном примере указатель b инициализируется адресом другой переменной, x. Пойнтер a инициализируется адресом переменной с именем z. Однако, т.к. ожидается, что значение переменной a будет const, ее можно только инициализировать, но не изменять. Она всегда будет указывать на конкретное место памяти.

В Примере 5 на глобальном уровне объявляется глобальная переменная GLOBAL, поэтому она будет иметь глобальное время действия. локальная переменная LOCAL имеет класс хранения auto и имеет адрес только при выполнении функции, в которой она объявлена. Попытка инициализации static указателя lp адресом LOCAL не допускается. static указатель gp может быть инициализирован адресом GLOBAL, т.к. он остается неизменным. Аналогично, *rp может быть инициализирован, т.к. rp это локальная переменная и поэтому может иметь непостоянный инициализатор. Каждый раз при входе в блок, LOCAL будет иметь новый адрес, который будет присвоен rp.

Составные типы

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

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

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

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

Обратите внимание на то, что требуется внешние скобки, которые заключают в себя инициализаторы строк 1 и 2. Следующая конструкция без внешних скобок вызовет появление ошибки:

В данном примере три int компоненты x инициализируются соответственно значениями 1, 2 и 3. Три элемента первой строки m инициализируются значением 4.0; элементы остальных строк m инициализируются значением 0 по умолчанию.

В данном примере инициализируется переменная y. Первый элемент об’единения это массив, поэтому инициализатор для него будет составным. Список инициализаторов <'1'>присваивает значения первой строке массива. Т.к. в списке указано только одно значение, то значением 1 будет инициализирован только элемент первой колонки, а остальные два элемента этой строки инициализируются значением ноль по умолчанию. Аналогично, первый элемент второй строки x будет инициализирован значением 4, а оставшиеся два элемента строки инициализируются значением 0.

Инициализаторы строк

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

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

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

Структуры, об’единения и перечислимые типы

В данном примере объявляется тип структуры с именем student. Объявление struct student employee; может быть использовано для определения структурной переменной типа student.

Использование объявления typedef

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

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

В данном примере объявляется тип структуры GROUP с тремя компонентами. Задан признак структуры club, и теперь в объявлениях можно использовать либо имя typedef (GROUP) либо признак структуры.

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

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

Имя типа для указателя, массива или функции имеет вид:

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

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

Установленный объявлением typedef спецификатор типа кроме того, рассматривается как имя типа.

В данном примере задается имя типа для «указателя на long».

В Примерах 2 и 3 показано, как скобки изменяют значения сложных абстрактных деклараторов. В Примере 2 задается имя типа для указателя на массив из пяти значений int.

В Примере 3 задается указатель на функцию, которая не принимает аргументов и возвращает величину int.

Источник