Нумерованный тип

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

Например, четыре масти в колоде игральных карт могут быть четырьмя счетчиками с именами Клуб , Бриллиант , Сердце и Пика , принадлежащими к пронумерованному типу с именем масть . Если объявлена ​​переменная V с типом данных suit , ей можно присвоить любое из этих четырех значений.

Хотя перечислители обычно различны, в некоторых языках один и тот же перечислитель может быть указан дважды в объявлении типа. Имена счетчиков не обязательно должны быть семантически полными или совместимыми в каком-либо смысле. Например, нумерованный тип, называемый цветом, может быть определен как состоящий из перечислителей Red , Green , Zebra , Missing и Bacon . В некоторых языках объявление перечислимого типа также намеренно определяет порядок его членов; в других счетчики неупорядочены; в других случаях неявное упорядочивание возникает из-за того, что компилятор конкретно представляет счетчики как целые числа.

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

Значения и переменные перечислимого типа обычно реализуются как битовые строки фиксированной длины , часто в формате и размере, совместимых с некоторым целочисленным типом. Некоторые языки, особенно языки системного программирования , позволяют пользователю указывать битовую комбинацию, которая будет использоваться для каждого перечислителя. В теории типа , перечисляемые типы часто рассматриваются как меченые союзы из типов единиц . Поскольку такие типы имеют форму , их также можно записать как натуральные числа.${\ displaystyle 1 + 1 + \ cdots +1}$

Обоснование [ править ]

Некоторые ранние языки программирования изначально не имели перечислимых типов. Если бы программист хотел, чтобы переменная, например myColor , имела значение red, переменная red должна быть объявлена ​​и ей присвоено какое-то произвольное значение, обычно целочисленная константа. Затем переменная red будет присвоена myColor . Другие методы присваивают произвольные значения строкам, содержащим имена счетчиков.

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

С другой стороны, нумерованные типы делают код более самодокументируемым. В зависимости от языка компилятор может автоматически назначать счетчикам значения по умолчанию, тем самым скрывая ненужные детали от программиста. Эти значения могут быть даже не видны программисту (см. Скрытие информации ). Перечислимые типы также могут помешать программисту писать нелогичный код, такой как выполнение математических операций над значениями перечислителей. Если значение переменной, которой был назначен перечислитель, должно было быть напечатано, некоторые языки программирования могли также печатать имя перечислителя, а не его базовое числовое значение. Еще одно преимущество состоит в том, что перечисляемые типы позволяют компиляторам обеспечивать семантическую корректность. Например: myColor = TRIANGLE можно запретить, пока myColor = REDпринимается, даже если ТРЕУГОЛЬНИК и КРАСНЫЙ внутренне представлены как 1 .

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

Соглашения [ править ]

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

Синтаксис на нескольких языках программирования [ править ]

Паскаль и синтаксически похожие языки [ править ]

Паскаль [ править ]

В Паскале перечислимый тип может быть неявно объявлен путем перечисления значений в списке в скобках:

 вар  масть :  ( трефы ,  бубны ,  червы ,  пики ) ;

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

 введите  carduit  =  ( трефы ,  бубны ,  червы ,  пики ) ;  card  =  рекордная  масть :  кардный костюм ;  значение :  1  ..  13 ;  конец ;  вар  рука :  массив  [  1  ..  13  ]  из  карты ;  козырная :  карточный костюм ;

Порядок, в котором указаны значения перечисления, имеет значение. Перечислены тип является порядковым типом, а predи succфункции будут давать предварительное или следующее значение перечисления, и ordможет преобразовывать значения перечисления их целочисленного представления. Однако стандартный Паскаль не предлагает преобразования арифметических типов в перечисления. Extended Pascal предлагает эту функциональность через расширенную succфункцию. Некоторые другие диалекты Паскаля позволяют это через приведение типов. Некоторые современные потомки Паскаля, такие как Modula-3 , предоставляют специальный синтаксис преобразования с использованием метода, называемого VAL; Modula-3 также рассматривает BOOLEANи CHARкак специальные предопределенные перечисляемые типы и виды использования ORDи VALдля стандартного ASCII. декодирование и кодирование.

Языки стиля Pascal также позволяют использовать перечисление в качестве индекса массива:

 вар  suitcount :  массив  [ cardsuit ]  из  целого числа ;

Ада [ править ]

В Ada использование "=" было заменено на "is", оставив определение очень похожим:

тип  Cardsuit  есть  ( трефы ,  бубны ,  червы ,  пики );

В дополнение к Pred, Succ, Valи PosАда также поддерживает простые преобразования строки через Imageи Value.

Подобно языкам C-стиля, Ada позволяет указывать внутреннее представление перечисления:

 для  использования карточного костюма  ( трефы => 1 , бубны => 2 , червы => 4 , пики => 8 );            

В отличие от языков C-стиля, Ada также позволяет указывать количество бит перечисления:

для  Cardsuit ' Размер  использования  4 ;  - 4 бита

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

 Перемешать  :  постоянный  массив ( Cardsuit )  из  Cardsuit  : =  ( клубы  =>  Cardsuit ' SUCC ( клубы ),  - см атрибуты перечислений' Во- первых, 'Последние' SUCC, «ПРЕД  Diamonds  =>  Сердца ,  --an явное значение  сердца  =>  Cardsuit ' Last , -  первое значение перечисления типа Cardsuit, например, трефы  Spades  =>  Cardsuit ' First -  последнее значение перечисления типа Cardsuit, например, spades  );

Как и Modula-3, Ада рассматривает Booleanи Characterкак специальные предопределенные (в пакете " Standard") перечисляемые типы. В отличие от Modula-3 можно также определять собственные типы символов:

Тип  карты  :  (' 7 ',  ' 8 ',  ' 9 ',  ' J ',  ' Q ',  ' K ',  ' A ');

C и синтаксически похожие языки [ править ]

C [ править ]

Исходный диалект K&R языка программирования C не имел перечисляемых типов. ^[1] В C перечисления создаются явными определениями ( enumключевое слово само по себе не вызывает выделения памяти), которые используют enumключевое слово и напоминают определения структур и объединений :

перечисление  cardsuit  {  Клубы ,  Алмазы ,  сердце ,  Spades };struct  card  {  enum  carduit  масть ;  короткое  целое  значение ; }  рука [ 13 ];enum  carduit  trump ;

C предоставляет целочисленное представление значений перечисления непосредственно программисту. Целые числа и значения перечисления можно свободно смешивать, и все арифметические операции над значениями перечисления разрешены. Переменная enum даже может содержать целое число, которое не представляет ни одно из значений перечисления. В самом деле, в соответствии с определением языка, приведенный выше код будет определять Clubs, Diamonds, Heartsи Spadesкак константы типа int, которые будут преобразованы только (бесшумно) , чтобы , enum cardsuitесли они сохранены в переменной этого типа.

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

enum  carduit  {  Clubs  =  1 ,  Diamonds  =  2 ,  Hearts  =  4 ,  Spades  =  8 };

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

C # [ править ]

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

перечисление  Cardsuit  {  Клубы ,  Бриллианты ,  Spades ,  сердца  };

выражения CardSuit.Diamonds + 1и CardSuit.Hearts - CardSuit.Clubsразрешены напрямую (потому что может иметь смысл пройти через последовательность значений или спросить, сколько шагов между двумя значениями), но CardSuit.Hearts*CardSuit.Spadesсчитается менее понятным и разрешается только в том случае, если значения сначала преобразуются в целые числа .

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

Определение перечисления определяет имена для выбранных целочисленных значений и является синтаксическим сахаром , поскольку можно присвоить переменной перечисления другие целочисленные значения, которые не входят в область определения перечисления. ^{[2] [3] [4]}

C ++ [ править ]

В C ++ есть типы перечисления, которые напрямую наследуются от языков C и работают в основном так же, за исключением того, что перечисление является реальным типом в C ++, что дает дополнительную проверку во время компиляции. Также (как и в случае со структурами) enumключевое слово C ++ автоматически комбинируется с typedef , так что вместо наименования типа enum nameпросто назовите его name. Это можно смоделировать на C с помощью typedef:typedef enum {Value1, Value2} name;

C ++ 11 предоставляет второй тип-безопасный тип перечисления, который неявно преобразуется в целочисленный тип. Это позволяет определить потоковую передачу io для этого типа. Кроме того, перечисления не протекают, поэтому их нужно использовать с Enumeration Type::enumeration. Это определяется фразой «enum class». Например:

enum  class  Color  { Красный ,  Зеленый ,  Синий };

Основной тип является реализация определенных интегрального типа , который является достаточно большим , чтобы вместить все перечисленные значения (он не должен быть наименьший возможный тип!). В C ++ вы можете напрямую указать базовый тип. Это позволяет "вперед объявления" перечислений:

enum  class  Color  :  long  { красный ,  зеленый ,  синий };  // должен соответствовать по размеру и разметке памяти типу long enum  class  Shapes  :  char ;  // предварительное объявление. Если позже будут определены значения, которые не вписываются в 'char', это будет ошибкой.

Перейти [ править ]

Go использует iotaключевое слово для создания нумерованных констант. ^[5]

Тип  ByteSize  float64const  (  _  =  iota  // игнорировать первое значение путем присвоения  пустому идентификатору KB  ByteSize  =  1  <<  ( 10  *  iota )  МБ  ГБ )

Java [ править ]

В J2SE версии 5.0 языка программирования Java добавлены перечисляемые типы, синтаксис объявления которых аналогичен синтаксису C :

 перечисление  Cardsuit  {  КЛУБЫ ,  DIAMONDS ,  лопаты ,  СЕРДЦА  };  ...  Cardsuit  козырь ;

Однако система типов Java рассматривает перечисления как тип, отдельный от целых чисел, и смешивание значений перечисления и целых чисел не допускается. Фактически, тип перечисления в Java на самом деле является специальным классом, созданным компилятором, а не арифметическим типом, а значения перечисления ведут себя как глобальные предварительно сгенерированные экземпляры этого класса. Типы перечисления могут иметь методы экземпляра и конструктор (аргументы которого могут быть указаны отдельно для каждого значения перечисления). Все типы перечислений неявно расширяют Enumабстрактный класс. Тип перечисления не может быть создан напрямую. ^[6]

Внутри каждое значение перечисления содержит целое число, соответствующее порядку, в котором они объявлены в исходном коде, начиная с 0. Программист не может напрямую установить настраиваемое целое число для значения перечисления, но можно определить перегруженные конструкторы, которые затем могут назначать произвольные значения для самоопределяемых членов класса перечисления. Определение геттеров позволяет затем получить доступ к этим самоопределенным членам. Внутреннее целое число может быть получено из значения перечисления с помощью ordinal()метода, а список значений перечисления типа перечисления может быть получен по порядку с помощью values()метода. Обычно программистам не рекомендуется преобразовывать перечисления в целые числа и наоборот. ^[7] Перечислимые типы Comparable, использующие внутреннее целое число; в результате их можно отсортировать.

Стандартная библиотека Java предоставляет служебные классы для использования с перечислениями. В EnumSetклассе реализует Setзначения перечислений; он реализован в виде битового массива , что делает его очень компактным и таким же эффективным, как явное манипулирование битами, но более безопасным. В EnumMapреализует класс Mapзначений перечислений объекта. Он реализован как массив с целочисленным значением значения перечисления, служащим индексом.

Perl [ править ]

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

мой  @enum  =  qw (Clubs Diamonds Hearts Spades) ; мой (  % set1 ,  % set2  ); @ set1 { @enum }  =  ();  # все очищено @ set2 { @enum }  =  ( 1 )  x  @enum ;  # все установлено в 1 $ set1 { Clubs }  ...  # false $ set2 { Diamonds }  ...  # true

Раку [ править ]

Raku (ранее известный как Perl 6) поддерживает перечисления. Существует несколько способов объявления перечислений в Raku, каждый из которых создает внутреннюю карту.

enum  Cat  <сфинкс сиамские бенгальские короткошерстные другие> ; # Использование "цитат-слов"

enum  Cat ( 'сфинкс' , 'сиамский' , 'бенгальский' , 'короткошерстный' , 'другой' ); # Использование списка

enum  Cat ( сфинкс => 0 , сиамский => 1 , бенгальский => 2 , короткошерстный => 3 , другой => 4 ); # Использование конструкторов Pair

enum  Cat (: сфинкс ( 0 ) ,: сиамский ( 1 ) ,: бенгальский ( 2 ), короткошерстный ( 3 ) ,: другой ( 4 )); # Другой способ использования пар, вы также можете использовать `: 0sphynx`

Ржавчина [ править ]

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

enum  Message {  Выйти , Move { x : i32 , y : i32 }, // struct Write ( String ), // одноэлементный кортеж ChangeColor ( i32 , i32 , i32 ), // трехэлементный кортеж }           

Swift [ править ]

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

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

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

enum  CardSuit  {  футляр для  клубов,  футляр для  бриллиантов,  футляр для  червей,  футляр для  пики }

В отличие от C и Objective-C , случаям перечисления Swift не присваивается целочисленное значение по умолчанию при их создании. В приведенном выше примере CardSuit трефы, бубны, червы и пики неявно равны 0, 1, 2 и 3. Вместо этого различные варианты перечисления являются полноценными значениями сами по себе с явно определенным типом CardSuit. .

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

перечисление  CardSuit  {  случай  клубы ,  алмазы ,  сердца ,  лопаты }

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

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

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

enum  Planet :  Int  {  case  mercury  =  1 ,  Венера ,  Земля ,  Марс ,  Юпитер ,  Сатурн ,  Уран ,  Нептун }

В приведенном выше примере Planet.mercury имеет явное исходное значение 1, Planet.venus имеет неявное исходное значение 2 и так далее.

«Подробности можно найти в онлайн-документации Swift здесь».

TypeScript [ править ]

Typescript добавляет в JavaScript тип данных enum.

перечисление  Cardsuit  { Клубы ,  Алмазы ,  сердце ,  Spades }; var  c :  Cardsuit  =  Карточный костюм . Бриллианты ;

По умолчанию перечисляет элементы, начиная с 0; это можно изменить, установив значение первого:

enum  Cardsuit  { Clubs  =  1 ,  Diamonds ,  Hearts ,  Spades }; var  c :  Cardsuit  =  Карточный костюм . Бриллианты ;

Все значения могут быть установлены:

enum  Cardsuit  { Clubs  =  1 ,  Diamonds  =  2 ,  Hearts  =  4 ,  Spades  =  8 }; var  c :  Cardsuit  =  Карточный костюм . Бриллианты ;

TypeScript поддерживает сопоставление числового значения с его именем. Например, это находит имя значения 2:

enum  Cardsuit  { Clubs  =  1 ,  Diamonds ,  Hearts ,  Spades }; var  suitName :  string  =  Карточный костюм [ 2 ];оповещение (имя костюма );

Python [ править ]

enumМодуль был добавлен в стандартной библиотеке Python в версии 3.4.

from  enum  import  Enum class  Cards ( Enum ):  трефы  =  1  бубны  =  2  червы  =  3  пики  =  4

Также есть функциональный API для создания перечислений с автоматически сгенерированными индексами (начиная с единицы):

Cards  =  Enum ( «Карты» ,  [ «трефы» ,  «бубны» ,  «червы» ,  «пики» ])

Перечисления Python не обеспечивают семантическую корректность (бессмысленное сравнение с несовместимым перечислением всегда возвращает False, а не вызывает TypeError ):

>>> Color  =  Enum ( "Цвет" ,  [ "красный" ,  "зеленый" ,  "синий" ]) >>> Shape  =  Enum ( "Форма" ,  [ "круг" ,  "треугольник" ,  "квадрат" ,  " шестиугольник " ]) >>> def  has_vertices ( shape ): ... return  shape  ! =  Shape . круг ... >>>has_vertices ( Цвет . зеленый) Верно

Фортран [ править ]

Fortran имеет только перечисленные типы для взаимодействия с C; следовательно, семантика аналогична C и, как и в C, значения перечисления являются просто целыми числами, и никакая дополнительная проверка типа не выполняется. Пример C, приведенный выше, можно записать на Фортране как

 enum ,  bind (  C  )  перечислитель  ::  CLUBS  =  1 ,  DIAMONDS  =  2 ,  HEARTS  =  4 ,  SPADES  =  8  end enum

Visual Basic / VBA [ править ]

Перечисленным типам данных в Visual Basic (до версии 6) и VBA автоматически "" присваивается Longтип данных, а также они сами становятся типом данных:

' Начинающийся с нуля Enum  CardSuit  Clubs  Diamonds  Hearts  Spades End  EnumSub  EnumExample ()  Тусклый  костюм  As  CardSuit  suit  =  Diamonds  MsgBox  suit End  Sub

Пример кода в VB.NET

Enum  CardSuit  Клубы  Бриллианты  Сердца  Пики Конец  EnumSub  EnumExample ()  Тусклый  костюм  As  CardSuit  suit  =  CardSuit . Бриллианты  MessageBox . шоу ( масть ) End  Sub

Лисп [ править ]

Common Lisp использует спецификатор типа члена, например,

( Deftype  cardsuit  ()  ' ( член  клуба  алмазов  сердце  лопата ))

в котором говорится, что объект относится к типу костюма, если это клюшка #'eql, бриллиант, сердце или лопата. Однако спецификатор типа члена недопустим в качестве специалиста параметров Common Lisp Object System (CLOS). Вместо этого может использоваться, что (eql atom)эквивалентно (member atom)может использоваться (то есть только один член набора может быть указан с помощью спецификатора типа eql, однако он может использоваться как специализатор параметра CLOS.) Другими словами, для определения методов. чтобы охватить перечислимый тип, метод должен быть определен для каждого конкретного элемента этого типа.

Кроме того,

( deftype тип набора  конечных элементов  ( & остальные  элементы )  ` ( член  , @ элементы ))

может использоваться для определения произвольных перечислимых типов во время выполнения. Например

( Конечно-элементный посаженного типа  клуб  алмаз  сердце  лопата )

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

( Член  клуба  алмазов  сердце  лопата )

но может быть менее запутанной функцией #'memberпо стилистическим причинам.

Алгебраический тип данных в функциональном программировании [ править ]

В языках функционального программирования из линии ML (например, Standard ML (SML), OCaml и Haskell ) для реализации перечислимого типа можно использовать алгебраический тип данных только с конструкторами с нулевым значением . Например (в синтаксисе сигнатур SML):

 тип данных  carduit  =  Клубы  |  Бриллианты  |  Сердечки  |  Тип карты пик  = { масть : кардный костюм ; значение : int } val hand : список карт val trump : carduit                 

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

Базы данных [ править ]

Некоторые базы данных напрямую поддерживают перечисляемые типы. MySQL предоставляет перечислимый тип ENUMс допустимыми значениями, указанными в виде строк при создании таблицы. Значения сохраняются как числовые индексы, при этом пустая строка хранится как 0, первое строковое значение хранится как 1, второе строковое значение сохраняется как 2 и т. Д. Значения могут быть сохранены и извлечены как числовые индексы или строковые значения.

Схема XML [ править ]

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

<xs: element  name = "cardsuit" >  <xs: simpleType>  <xs: Restriction  base = "xs: string" >  <xs: enumeration  value = "Clubs" />  <xs: enumeration  value = "Diamonds" />  < xs: enumeration  value = "Hearts" />  <xs: enumeration  value = "Spades" />  </ xs: ограничение>  </ xs: simpleType> </ xs: element>

См. Также [ править ]

• Контрастный набор

Ссылки [ править ]

Внешние ссылки [ править ]

В Wikibook Ada Programming есть страница по теме: Перечисление

• Перечислимые типы в C / C ++
• Перечислимые типы в C #
• Перечислимые типы в Java
• Перечислимые типы в MySQL
• Перечислимые типы в Obix
• Перечислимые типы в XML
• Перечислимые типы в Visual Basic