Земля и луна, звёзды, Сириус
بسم الله الرحمن الرحيم

Стандартная библиотека языка Си

Стандартной библиотекой языка Си (также известная как libc) называется часть стандарта ANSI C, посвященная заголовочным файлам и библиотечным подпрограммам. Является описанием реализации общих операций, таких как обработка ввода/вывода и строк, в языке программирования Си. Стандартная библиотека языка Си — это описание программного интерфейса, а не настоящая библиотека, пригодная для использования в процессе компиляции.

Заголовочные файлы стандартной библиотекой языка Си

Стандартная библиотека языка Си включает следующие заголовочные файлы: assert.h, complex.h, ctype.h, errno.h, fenv.h, float.h, inttypes.h, iso646.h, limits.h, locale.h, math.h, setjmp.h, signal.h, stdarg.h, stdbool.h, stddef.h, stdint.h, stdio.h, stdlib.h, string.h, tgmath.h, time.h, wchar.h, wctype.h - всего 24 заголовочных файла.

Из них три заголовочных файла iso646.h, wchar.h и wctype.h были добавлены в Приложении 1 (сокращенно NA1) — дополнении к Стандарту языка Си, ратифицированному в 1995. А шесть заголовочных файлов complex.h, fenv.h, inttypes.h, stdbool.h, stdint.h и tgmath.h были добавлены в C99, версии Стандарта языка Си, опубликованном в 1999 году.

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

complex.h - Набор функций для работы с комплексными числами. (Появилось в C99)

ctype.h - Содержит функции, используемые для классификации символов по их типам или для конвертации между верхним и нижним регистрами независимо от используемой кодировки (обычно ASCII или одно из её расширений, хотя есть и реализации, использующие EBCDIC).

errno.h - Для проверки кодов ошибок, возвращаемых библиотечными функциями.

fenv.h - Для управления средой, использующей числа с плавающей запятой. (Появилось в C99)

float.h - Содержит заранее определенные константы, описывающие специфику реализации свойств библиотеки для работы с числами с плавающей запятой, как, например, минимальная разница между двумя различными числами с плавающей точкой (_EPSILON), максимальное число цифр точности (_DIG) и область допустимых чисел (_MIN, _MAX).

inttypes.h - Для точной конвертации целых типов. (Появилось в C99)

iso646.h - Для программирования в кодировке ISO 646. (Появилось в NA1)

limits.h - Содержит заранее заданные константы, определяющие специфику реализации свойств целых типов, как, например, область допустимых значений (_MIN, _MAX).

locale.h - Для setlocale() и связанных констант. Используется для выбора соответствующего языка.

math.h - Для вычисления основных математических функций. Это заголовочный файл стандартной библиотеки языка программирования С, разработанный для выполнения простых математических операций. Большинство функций привлекают использование чисел с плавающей точкой. C++ также реализует данные функции для обеспечения совместимости, все они содержатся в заголовочном файле cmath. Все эти функции принимают double, если не определено иначе. Для работы с типами float и long double используются функции с постфиксами f и l соответственно. Все функции, принимающие или возвращающие угол, работают с радианами.

setjmp.h - Объявляет макросы setjmp и longjmp, используемые для переходов

signal.h - Для управления различными исключительными условиями

stdarg.h - Это заголовочный файл стандартной библиотеки языка программирования СИ, предоставляющий средства для перебора аргументов функции, количество и типы которых заранее не известны. Содержимое stdarg.h часто используют в функциях с произвольным количеством переменных (к примеру, printf, scanf).

stdbool.h - Для булевых типов данных. (Появилось в C99)

stdint.h - Для определения различных типов целых чисел. (Появилось в C99)

stddef.h - Это заголовочный файл стандартной библиотеки языка программирования С, определяющий макросы NULL и offsetof, а также типы ptrdiff_t, wchar_t, и size_t.
wchar_t - это реализация широкосимвольного типа, предопределённого в С++, но требующего включение «stddef.h» или «wchar.h» в языке программирования Си.

stdio.h - Реализует основные возможности ввода и вывода в языке Си. Этот файл содержит весьма важную функцию printf.

stdlib.h - Для выполнения множества операций, включая конвертацию, генерацию псевдослучайных чисел, выделение памяти, контроль процессов, окружения, сигналов, поиска и сортировки.

string.h - Для работы с различными видами строк.

tgmath.h - Для типовых математических функций. (Появилось в C99)

time.h - Для конвертации между различными форматами времени и даты.

wchar.h - Для обработки «широких» потоков и нескольких видов строк при помощи «широких» символов (поддержка набора языков). (Появилось в NA1)

wctype.h - Для классификации «широких» символов. (Появилось в NA1)

wchar.h

wchar.h — заголовочный файл стандартной библиотеки языка программирования Си, часть стандарта расширения возможностей языка 1995 года. Содержит функции для работы с многобайтовыми и широкими символами.

Функции

int wcscasecmp(const wchar_t *s1, const wchar_t *s2) — широкосимвольный эквивалент функции strcasecmp.

int strcasecmp(const char *s1, const char *s2) — сравнивает две строки s1 и s2, игнорируя регистр символов. Возвращает отрицательное, нулевое или положительное значение int, если s1 соответственно меньше, совпадает или больше s2.

int strncasecmp(const char *s1, const char *s2, size_t n) — почти аналогичная strcasecmp, за исключением того, что сравнивает только первые N символов s1.

int wcscmp(const wchar_t *s1, const wchar_t *s2) — широкосимвольный эквивалент функции strcmp.

stdio.h

stdio.h (от англ. standard input/output header — стандартный заголовочный файл ввода/вывода) заголовочный файл стандартной библиотеки языка Си, содержащий определения макросов, константы и объявления функций и типов, используемых для различных операций стандартного ввода и вывода. Функциональность унаследована от «портативного пакета ввода/вывода» («portable I/O package»), написанного Майком Леском из Bell Labs в начале 1970-х. В C++ ради совместимости, также использует stdio.h наряду со схожим по функциональности заголовочным файлом cstdio.

Функции

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

Функции, объявленные в stdio.h предназначены или для операций с файлами или для операций ввода-вывода.

Функция стандартного вывода printf()

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

Функция printf() имеет прототип в файле stdio.h

int printf(char *управляющая строка, ...);

В случае успеха функция printf() возвращает число выведенных символов.

Управляющая строка содержит два типа информации: символы, которые непосредственно выводятся на экран, и спецификаторы формата, определяющие, как выводить аргументы.

Функция printf() это функция форматированного вывода. Это означает, что в параметрах функции необходимо указать формат данных, которые будут выводиться. Формат данных указывается спецификаторами формата. Спецификатор формата начинается с символа % за которым следует код формата.

символ
%d целое десятичное число
%i целое десятичное число
%e десятичное число в виде x.xx e+xx
%E десятичное число в виде x.xx E+xx
%f десятичное число с плавающей запятой xx.xxxx
%F десятичное число с плавающей запятой xx.xxxx
%g %f или %e, что короче
%G %F или %E, что короче
%o восьмеричное число
%s строка символов
%u беззнаковое десятичное число
%x шестнадцатеричное число
%X шестнадцатеричное число
%% символ %
%p указатель
%n указатель

Кроме того, к командам формата могут быть применены модификаторы l и h.

%ld печать long int
%hu печать short unsigned
%Lf печать long double

В спецификаторе формата, после символа % может быть указана точность (число цифр после запятой). Точность задаётся следующим образом: %.n<код формата>. Где n - число цифр после запятой, а <код формата> - один из кодов приведённых выше.

Например, если у нас есть переменная x=10.3563 типа float и мы хотим вывести её значение с точностью до 3-х цифр после запятой, то мы должны написать:

printf("Переменная x = %.3f",x);

Результат:
Переменная x = 10.356

Таблица и пример после неё взаимствованы из статьи: Функции стандартного ввода/вывода (printf, scanf). Автор: Бардин П.Б. http://proger.ru

При составлении статьи были использованы материалы из Википедии — свободной энциклопедии

Наверх к содержанию страницы

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

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

Спецификатор static

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

Например:

{ static int sti=0;
...
}

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

Спецификатор extern

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

Например:

{ extern long extl;
...
}

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

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

Особенности областей видимости static и extern

Особенности static

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

Переменная объявленная глобально как static (вне блоков) видима в пределах остатка исходного файла, в котором она определена. Выше своего описания и в других исходных файлах эта переменная объявленная глобально как static невидима.

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

Особенности extern

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

Функции всегда определяются глобально

Функции могут быть объявлены с классом памяти static или extern.

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

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

Наверх к содержанию страницы

Массивы, структуры и др. на Си

Это те темы языка программирования Си к которым мне очень редко, но по необходимости приходилось возвращаться. Поэтому я позволил себе скопировать к себе на сайт эту главу из книги "ВВЕДЕНИЕ В ЯЗЫК СИ", чтобы не искать каждый раз. А скопировал я с этой страницы.

Структурированные типы данных

Массивы

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

 int a[100];
 char b[20];
 float d[50];

В первой строке объявлен массив а из 100 элементов целого типа: а[0], а[1], ..., а[99] (индексация всегда начинается с нуля). Во второй строке элементы массива b имеют тип char, а в третьей - float.

Двумерный массив представляется как одномерный, элементами которого так же являются массивы. Например, определение char а[10][20]; задает такой массив. По аналогии можно установить и большее число измерений. Элементы двумерного массива хранятся по строкам, т.е. если проходить по ним в порядке их расположения в памяти, то быстрее всего изменяется самый правый индекс. Например, обращение к девятому элементу пятой строки запишется так: а[5][9].

Пусть задан массив:

 int a[2][3]; 

Тогда элементы массива а будут размещаться в памяти следующим образом: a[0][0], a[0][1], a[0][2], a[1][0], a[1][1], a[1][2].

Имя массива - это константа, которая содержит адрес его первого элемента (в данном примере а содержит адрес элемента а[0][0]). Предположим, что a = 1000. Тогда адрес элемента а[0][1] будет равен 1002 (элемент типа int занимает в памяти 2 байта), адрес следующего элемента а[0][2] - 1004 и т.д. Что же произойдет, если выбрать элемент, для которого не выделена память? К сожалению, компилятор не отслеживает данной ситуации. В результате возникнет ошибка и программа будет работать неправильно.

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

Определение

 int a[5]; 

задает массив из пяти элементов а[0], a[1], a[2], a[3], a[4]. Если объект *у определен как

 int *у; 

то оператор у = &a[0]; присваивает переменной у адрес элемента а[0]. Если переменная у указывает на очередной элемент массива а, то y+1 указывает на следующий элемент, причем здесь выполняется соответствующее масштабирование для приращения адреса с учетом длины объекта (для типа int - 2 байта, long - 4 байта, (double - 8 байт и т.д.).

Так как само имя массива есть адрес его нулевого элемента, то оператор у = &a[0]; можно записать и в другом виде: у = а. Тогда элемент а[1] можно представить как *(а+1). С другой стороны, если у - указатель на массив a, то следующие две записи: a[i] и *(у+i) - эквивалентны.

Между именем массива и соответствующим указателем есть одно важное различие. Указатель - это переменная и у = а; или y++; - допустимые операции. Имя же массива - константа, поэтому конструкции вида a = y; a++; использовать нельзя, так как значение константы постоянно и не может быть изменено.

Переменные с адресами могут образовывать некоторую иерархическую структуру (могут быть многоуровневыми) типа указатель на указатель (т.е. значение указателя является адресом другого указателя), указатель на указатель на указатель и т.д. Если указатели адресуют элементы одного массива, то их можно сравнивать (отношения вида <, >, = =, != и другие работают правильно). В то же время нельзя сравнивать ли6о использовать в арифметических операциях указатели на разные массивы (соответствующие выражения не приводят к ошибкам при компиляции, но в большинстве случаев не имеют смысла). Любой адрес можно проверить на равенство или неравенство с константой NULL. Указатели на элементы одного массива можно также вычитать. Тогда результатом будет число элементов массива, расположенных между уменьшаемым и вычитаемым объектами.

Язык Си позволяет инициализировать массив при его определении. Для этого используется следующая форма:

 тип имя_массива[...] ... [...] = {список значений};

Примеры:

 int a[5] = {0, 1, 2, 3, 4};
 char ch[3] = {'d', 'e', '9'};
 int b[2][3] = {1, 2, 3, 4, 5, 6};

В последнем случае: b[0][0] = 1, b[0][1] = 2, b[0][2] = 3, b[1][0] = 4, b[1][1] = 5, b[1][2] = 6.

В языке допускаются массивы указателей, которые определяются, например, следующим образом: char *m[5];. Здесь m[5] - массив, содержащий адреса элементов типа char.

Строки символов

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

Определение char а[10]; указывает компилятору на необходимость резервирования места для максимум 10 символов. Константа а содержит адрес ячейки памяти, в которой помещено значение первого из десяти объектов типа char. Процедуры, связанные с занесением конкретной строки в массив а, копируют ее по одному символу в область памяти, на которую указывает константа а, до тех пор, пока не будет скопирован нулевой символ, оканчивающий строку. Когда выполняется функция типа printf("%s", а), ей передается значение а, т.е. адрес первого символа, на который указывает а. Если первый символ - нулевой, то работа функции printf() заканчивается, а если нет, то она выводит его на экран, прибавляет к адресу единицу и снова начинает проверку на нулевой символ. Такая обработка позволяет снять ограничения на длину строки (конечно, в пределах объявленной размерности): строка может иметь любую длину, но в пределах доступной памяти.

Инициализировать строку при таком способе определения можно следующим образом:

 char array[7] = "Строка";
 char s[ ] = {'С', 'т', 'р', 'о', 'к', 'а', '\0'};

(при определении массива с одновременной инициализацией пределы изменения индекса можно не указывать).

Второй способ определения строки - это использование указателя на символ. Определение char *b; задает переменную b, которая может содержать адрес некоторого объекта. Однако в данном случае компилятор не резервирует место для хранения символов и не инициализирует переменную b конкретным значением. Когда компилятор встречает оператор вида b ="IBM PC";, он производит следующие действия. Во-первых, как и в предыдущем случае, он создает в каком-либо месте объектного модуля строку "IBM PC", за которой следует нулевой символ ('\0'). Во-вторых, он присваивает значение начального адреса этой строки (адрес символа 'I') переменной b. Функция printf("%s", b) работает так же, как и в предыдущем случае, осуществляя вывод символов до тех пор, пока не встретится заключительный нуль.

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

Для ввода и вывода строк символов помимо scanf( ) и printf() могут использоваться функции gets( ) и puts( ) (их прототипы находятся в файле stdio.h).

Если string - массив символов, то ввести строку с клавиатуры можно так:

 gets(string);

(ввод оканчивается нажатием клавиши <Enter>). Вывести строку на экран можно следующим образом:

 puts(string);

Отметим также, что для работы со строками существует специальная библиотека функций, прототипы которых находятся в файле string.h.

Наиболее часто используются функции strcpy( ), strcat( ), strlen( ) и strcmp( ).

Если string1 и string2 - массивы символов, то вызов функции strcpy( ) имеет вид:

 strcpy(string1, string2);

Эта функция служит для копирования содержимого строки string2 в строку string1. Массив string1 должен быть достаточно большим, чтобы в него поместилась строка string2. Так как компилятор не отслеживает этой ситуации, то недостаток места приведет к потере данных.

Вызов функции strcat( ) имеет вид:

 strcat(string1, string2);

Эта функция присоединяет строку string2 к строке string1 и помещает ее в массив, где находилась строка string1, при этом строка string2 не изменяется. Нулевой байт, который завершал первую строку, заменяется первым байтом второй строки.

Функция strlen( ) возвращает длину строки, при этом завершающий нулевой байт не учитывается. Если a - целое, то вызов функции имеет вид:

 a = strlen(string);

Функция strcmp( ) сравнивает две строки и возвращает 0, если они равны.

Структуры

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

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

struct тип { тип элемента_1 имя элемента_1; 
.........
тип элемента_n имя элемента_n;
};

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

Рассмотрим пример:

sruct date { int day; 
int month;
int year;
}; 

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

 struct date {...} a, b, c; 

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

 struct date days;

Теперь переменная days имеет тип date.

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

Разрешается вкладывать структуры друг в друга, например:

struct man { char name[20], fam[20];
struct date bd;
int age;
}; 

Определенный выше тип data включает три элемента: day, month, year, содержащий целые значения (int). Структура man включает элементы name, fam, bd и voz. Первые два - name[20] и fam[20] - это символьные массивы из 20 элементов каждый. Переменная bd представлена составным элементом (вложенной структурой) типа data. Элемент age содержит значения целого типа int). Теперь можно определить переменные, значения которых принадлежат введенному типу:

 struct man man_[100]; 

Здесь определен массив man_, состоящий из 100 структур типа man.

Чтобы обратиться к отдельному элементу структуры, необходимо указать его имя, поставить точку и сразу же за ней записать имя нужного элемента, например:

 man_[j].age = 19; 
 man_[j].bd.day = 24;
 man_[j].bd.month = 2
 man_[j].bd.year = 1987; 

При работе со структурами необходимо помнить, что тип элемента определяется соответствующей строкой описания в фигурных скобках. Например, массив man_ имеет тип man, year является целым числом и т.п. Поскольку каждый элемент структуры относится к определенному типу, его имя может появиться везде, где разрешено использование значений этого типа. Допускаются конструкции вида man_[i]=man_[j]; где man_[i] и man_[j] - объекты, соответствующие единому описанию структуры. Другими словами, разрешается присваивать одну структуру другой по их именам.

Унарная операция & позволяет взять адрес структуры. Предположим, что определена переменная day:

 struct date {int d, m, у;} day; 

Здесь day - это структура типа date, включающая три элемента: d, m, у. Другое определение

 struct date *db; 

устанавливает тот факт, что db - это указатель на структуру типа date.

Запишем выражение:

 db = &day; 

В этом случае для выбора элементов d, m, у структуры необходимо использовать конструкции:

 (*db).d; (*db).m; (*db).y; 

Действительно, db - это адрес структуры, *db - сама структура. Круглые скобки здесь необходимы, так как точка имеет более высокий, чем звездочка, приоритет. Для аналогичных целей в языке Си предусмотрена специальная операция ->. Эта операция выбирает элемент структуры и позволяет представить рассмотренные выше конструкции в более простом виде:

 db -> d; db -> m; db -> у; 

Оператор typedef

Рассмотрим описание структуры:

 struct data {int d, m, у;}; 

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

 struct data а, b, с; 

В язык Си введено специальное средство, позволяющее назначать имена типам данных (переименовывать). Таким средством является оператор typedef. Он записывается в следующем виде:

 typedef тип имя; 

Здесь "тип" - любой разрешенный тип данных и "имя" - любой разрешенный идентификатор.

Рассмотрим пример:

 typedef int INTEGER; 

После этого можно сделать объявление:

 INTEGER а, b; 

Оно будет выполнять то же самое, что и привычное объявление int a,b;. Другими словами, INTEGER можно использовать как синоним ключевого слова int.

Битовые поля

Особую разновидность структур представляют собой битовые поля. Битовое поле - это последовательность соседних битов внутри одного, целого значения. Оно может иметь тип signed int или unsigned int и занимать от 1 до 16 битов. Поля размещаются в машинном слове в направлении от младших к старшим разрядам. Например, структура:

struct prim { int a:2; 
unsigned b:3; 
int c:5; 
int d:1; 
unsigned d:5; } i, j; 

обеспечивает размещение данных в двух байтах (в одном слове). Если бы последнее поле было задано так: unsigned d:6, то оно размещалось бы не в первом слове, а в разрядах 0 - 5 второго слова.

В полях типа signed крайний левый бит является знаковым.

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

Объединение (union)

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

Пусть задано определение:

 union r {int ir; float fr; char cr;} z; 

Здесь ir имеет размер 2 байта, fr - 4 байта, cr - 1 байт. Размер переменной z будет равен размеру самого большого из трех приведенных типов (т.е. 4 байтам). В один и тот же момент времени z может иметь значение только одной из переменных ir, fr или cr.

Перечислимый тип данных

Перечислимый тип данных предназначен для описания объектов из некоторого заданного множества. Он задается ключевым словом enum. Рассмотрим пример:

 enum seasons (spring, summer, autumn, winter); 

Здесь введен новый тип данных seasons. Теперь можно определить переменные этого типа:

 enum seasons а, b, с; 

Каждая из них (а, b, c) может принимать одно из четырех значений: spring, summer, autumn и winter. Эти переменные можно было определить сразу при описании типа:

 enum seasons (spring, summer, autumn, winter) a, b, с; 

Рассмотрим еще один пример:

 enum days {mon, tues, wed, thur, fri, sat, sun} my_week; 

Имена, занесенные в days (также как и в seasons в предыдущем примере), представляют собой константы целого типа. Первая из них (mon) автоматически устанавливается в нуль, и каждая следующая имеет значение на единицу больше, чем предыдущая (tues=1, wed=2 и т.д.).

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

 enum days (man=5, tues=8, wed=10, thur, fri, sat, sun} my_week;

После этого mon=5, tues=8,wed=10, thur=11, fri=12, sat=13, sun=14.

Тип enum можно использовать для задания констант true=1 и false=0, например:

 enum t_f (false, true) а, b; 

Были использованы материалы из интернета: Курсков С.Ю., составление, 2006

Наверх к содержанию страницы

Внешние ссылки: Аллах Тагаләнең исемнәре.

hsta.ru
Копирование материалов сайта запрещено.
Copyright © 2011-2017