что такое оператор enum

Типы перечислений (справочник по C#)

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

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

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

Типы перечислений как битовые флаги

Дополнительные сведения и примеры см. на странице справочника по API System.FlagsAttribute и в разделе о неисключительных элементах и атрибутах Flags страницы справочника по API System.Enum.

Тип System.Enum и ограничение перечисления

Тип System.Enum является абстрактным базовым классом всех типов перечисления. Он предоставляет различные методы, позволяющие получить информацию о типе перечисления и его значениях. Дополнительные сведения и примеры см. на странице справочника по API System.Enum.

Преобразования

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

Используйте метод Enum.IsDefined, чтобы определить, содержит ли тип перечисления элемент перечисления с определенным связанным значением.

Для любого типа перечисления существует упаковка — преобразование и распаковка — преобразование в тип System.Enum и из него соответственно.

Спецификация языка C#

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

Источник

Гайд по использованию enum в Python

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

Создание

Итерирование

При итерировании по классу вы пройдёте по атрибутам.

Цикл будет идти по элементам в том порядке, в котором они указаны при создании класса. Названия и значения никак не влияют на порядок.

Сравнение перечислений

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

IntEnum

Уникальные значения в перечислениях

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

Так как by_design и closed являются синонимами для других элементов, то они не появляются как элементы в циклах. Истинным считается название, указанное первым при объявлении.

Если вы хотите, чтобы все элементы обязательно имели разные значения, то добавьте декоратор @unique перед объявлением класса.

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

Другой способ создания перечислений

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

Аргумент value является названием перечисления, которое используется для создания представления элементов. Второй аргумент names принимает список названий в перечислении. Если подать одну строку, то она будет разбита по пробельным символам и запятым, а значения будут числами, начиная с 1.

Также аргумент name принимает список пар название — значение, либо аналогичный словарь.

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

Другие типы значений

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

Данный пример аналогичен предыдущему, но в нём используются словари вместо tuple для удобства.

Источник

Оператор Enum (Visual Basic)

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

Синтаксис

Компоненты

Необязательный элемент. Список атрибутов, которые применяются к этому перечислению. Список атрибутов необходимо заключить в угловые скобки (» » и » > «).

FlagsAttributeАтрибут указывает, что значение экземпляра перечисления может включать несколько членов перечисления и что каждый элемент представляет битовое поле в значении перечисления.

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

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

Обязательный элемент. Имя перечисления. Сведения о допустимых именах см. в разделе Имена объявленных элементов.

Необязательный элемент. Тип данных перечисления и всех его элементов.

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

Каждый member из них имеет следующий синтаксис и фрагменты: [] member name [ = initializer ]

Комментарии

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

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

Сокращает количество ошибок, вызванных перечислением или неотрицательным вводом чисел.

упрощает изменение значений в будущем;

Упрощает чтение кода, что означает меньшее количество ошибок, которые могут возникать.

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

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

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

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

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

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

К перечислению можно применять атрибуты в целом, но не в отдельные элементы. Атрибут вносит сведения в метаданные сборки.

Тип данных

Инициализация членов

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

Перечисления не могут иметь значения с плавающей запятой. Если члену присваивается значение с плавающей запятой и Option Strict для него задано состояние ON, возникает ошибка компилятора. Если параметр Option Strict равен OFF, значение автоматически преобразуется в Enum тип.

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

Модификаторы

Перечисления членов класса, структуры, модуля и интерфейса по умолчанию имеют открытый доступ. Уровни доступа можно изменить с помощью модификаторов доступа. Перечисления членов пространств имен по умолчанию имеют дружественный доступ. Уровни доступа можно изменить на «общий», но не на «частный» или «защищенный». Дополнительные сведения см. в разделе уровни доступа в Visual Basic.

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

По умолчанию все перечисления являются типами, а их поля — константами. Поэтому Shared Static Ключевые слова, и ReadOnly не могут быть использованы при объявлении перечисления или его членов.

Присваивание нескольких значений

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

Пример 1

Пример 2

Пример 3

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

Пример 4

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

Пример 5

В следующем примере As используется предложение для указания datatype перечисления.

Пример 6

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

Пример 7

В следующем примере выполняется итерация по перечислению. Он использует GetNames метод для получения массива имен членов из перечисления и GetValues для получения массива значений элементов.

Источник

Перечисления (C++)

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

В этой статье рассматривается тип языка C++ Standard в формате ISO enum и тип класса Enum с областью действия (или строго типизированный), который появился в C++ 11. Сведения об открытых классах enum или закрытых типах классов enum в c++/CLI и c++/CX см. в разделе Класс Enum.

Синтаксис

Параметры

identifier
Имя типа, присваиваемое перечислению.

type
Базовый тип перечислителей; все перечислители имеют один базовый тип. Может быть любым целочисленным типом.

Область перечислителя

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

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

Каждый перечислитель рассматривается как константа и должен иметь уникальное имя в пределах области, где enum определено (для перечислений с неограниченным диапазоном) или внутри enum самого себя (для перечислений с областью видимости). Значения, задаваемые имена, могут быть неуникальными. Например, для следующего объявления неограниченного перечисления Suit :

Приведение правил

Неограниченные константы перечисления могут быть неявно преобразованы в, но никогда не может быть неявно преобразовано int int в значение enum. В следующем примере показано, что пройдет при попытке присвоить переменной hand значение, не относящееся к типу Suit :

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

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

Обратите внимание, что в строке hand = account_num; по-прежнему содержится ошибка, которая происходит при использовании неограниченных перечислений, как показано выше. Эта ошибка устраняется с помощью явного приведения. Однако при использовании ограниченных перечислений попытка преобразования в следующем операторе — account_num = Suit::Hearts; — больше не будет разрешена без явного приведения.

Перечисления без перечислителей

Visual Studio 2017 версии 15,3 и более поздних версий (доступно в /std: c++ 17): путем определения перечисления (regular или с ограниченной областью) с явным базовым типом и без перечислителей, вы можете использовать новый целочисленный тип, не имеющий неявного преобразования в любой другой тип. Используя этот тип вместо встроенного базового типа, можно исключить потенциальные ошибки для незначительных ошибок, вызванных случайными неявными преобразованиями.

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

Источник

Урок №58. Перечисления

Язык C++ позволяет программистам создавать свои собственные (пользовательские) типы данных.

Перечисляемые типы

Перечисление (или «перечисляемый тип») — это тип данных, где любое значение (или «перечислитель») определяется как символьная константа. Объявить перечисление можно с помощью ключевого слова enum. Например:

Объявление перечислений не требует выделения памяти. Только когда переменная перечисляемого типа определена (например, как переменная paint в примере, приведенном выше), только тогда выделяется память для этой переменной.

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

Примечание: До C++11, конечная запятая после последнего перечислителя (как после COLOR_PURPLE в примере, приведенном выше) не разрешается (хотя многие компиляторы её все равно принимают). Однако начиная с C++11 конечная запятая разрешена.

Имена перечислений

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

Значения перечислителей

Результат выполнения программы:

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

Обратите внимание, ANIMAL_HORSE и ANIMAL_ZEBRA имеют одинаковые значения. Хотя C++ это не запрещает, присваивать одно значение нескольким перечислителям в одном перечислении не рекомендуется.

Совет: Не присваивайте свои значения перечислителям.

Правило: Не присваивайте одинаковые значения двум перечислителям в одном перечислении, если на это нет веской причины.

Обработка перечислений

Поскольку значениями перечислителей являются целые числа, то их можно присваивать целочисленным переменным, а также выводить в консоль (как переменные типа int):

Результат выполнения программы:

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

Тем не менее, вы можете сделать подобное с помощью оператора static_cast:

Компилятор также не позволит вам вводить перечислители через std::cin:

Однако, вы можете ввести целое число, а затем использовать оператор static_cast, чтобы поместить целочисленное значение в перечисляемый тип:

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

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

Вывод перечислителей

Попытка вывести перечисляемое значение с помощью std::cout приведет к выводу целочисленного значения самого перечислителя (т.е. его порядкового номера). Но как вывести значение перечислителя в виде текста? Один из способов — написать функцию с использованием стейтментов if:

Выделение памяти для перечислений

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

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

Польза от перечислений

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

Например, функции часто возвращают целые числа обратно в caller в качестве кодов ошибок, если что-то пошло не так. Как правило, небольшие отрицательные числа используются для представления возможных кодов ошибок. Например:

Однако магические числа, как в вышеприведенном примере, не очень эффективное решение. Альтернатива — использовать перечисления:

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

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

Или, если вы пишете функцию для сортировки группы значений:

Многие языки программирования используют перечисления для определения логических значений. По сути, логический тип данных — это простое перечисление всего лишь с двумя перечислителями: true и false! Однако в языке C++ значения true и false определены как ключевые слова вместо перечислителей.

Задание №1

Ответ №1

Задание №2

Ответ №2

Задание №3

Правда или ложь:

присваивать целочисленные значения;

не присваивать значения;

присваивать значения предыдущих перечислителей (например, COLOR_BLUE = COLOR_GRAY ).

Перечислители могут быть:

Ответ №3

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

Перечислители могут быть:

Поделиться в социальных сетях:

Урок №57. Введение в std::string

Комментариев: 34

Тут можно как-нибудь сделать ввод буквами? К примеру перед пользователем появляется вывод и нужно ввести, например, цвет. RED, ORANGE и т.д. А в темах перечисления и классы enum рассказывается только о таком способе. Через цифру как-то некрасиво.

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

Доброго времени суток, в чем смысл указывать в return std::string, все прекрасно работает и без него, либо я чего-то не понимаю. Сама функция же имеет тип возвращаемого значения string.

Да, ты прав, функция имеет возвращаемый тип std::string, по этому если не использовать конструкторы типа std::string в возвращаемом типе, то каст const char* в std::string будет произведен неявно. Видимо это сделано для наглядности происходящего.

Возможно ли вывести через оператор std::cout на экран не значение одного из перечеслителей а сам перечеслитель? ( не значение цвета RED = 1, в виде еденицы а само RED )

С помощью Switch или If else;

…сразу окончание анекдота: «Ну вот ты например кем работаешь?»
«Автослесарем, а что?»
«А теперь представь себе: в отпуске лежишь себе на пляже, а вокруг — машины, машины, машины…»:-)

Перечисления нужны:
1) для лучшего комментирования кода;
2) для упрощения разработки.
Как минимум.

Тест №3 — подстава, с плавающей ничего не было) Хотя я внимательно читал — целочисловые.

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

Источник