Как вывести название enum c
BestProg
Содержание
Поиск на других ресурсах:
1. Общие сведения о перечислениях. Преимущества использования перечислений в программах
Тип данных «перечисление» используется для создания именованных идентификаторов, представляющих некоторое целочисленное константное значение.
Перечисления позволяют объединять группы константных значений в единое целое. Формируется тип перечисления на основании которого может быть объявлена переменная, которая принимает значение из набора, который описывается в перечислении.
При использовании перечислений в программах можно выделить следующие взаимосвязанные преимущества:
Общая форма объявления перечисления следующая:
Если значение константы в перечислении не задано, то оно принимает значение, которое есть на 1 больше чем предыдущее константное значение. Например, если предыдущая константа имела значение 5, то следующая будет иметь значение 6. В случае типа char следующая константа есть следующим символом в таблице символов.
После объявления типа (шаблона) перечисления, можно объявлять переменные этого типа, например
Если объявлена переменная, то эта переменная в программе может принимать значение имени из перечисления, например
3. Каким образом в перечислении можно задать значение перечислительным константам? Пример
Значение перечислительным константам можно задать одним из двух способов:
Пример.
4. Константные значения каких типов данных разрешается использовать в перечислениях?
В перечислениях допускается использовать константные значения следующих типов:
компилятор выдаст сообщение об ошибке
5. Могут ли в перечислениях использоваться отрицательные значения перечислительных констант?
В перечислении VALUES используется отрицательная константа
6. Примеры объявления разных видов перечислений с различными способами начальной инициализации
Пример 1. Объявляется перечисление, реализующее месяцы года.
7. Примеры объявления и использования перечислений в программах
будет выводиться число 10. Идентификатор ‘Oct’ выводиться не будет.
8. Какая область видимости константы, объявленной в перечислении?
Константа, объявленная в перечислении, имеет область видимости в пределах скобок, в которых объявляется шаблон (тип) перечисления.
Например.
то компилятор выдаст ошибку
здесь TypeName – имя нового типа перечисления, которое создается.
Урок №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 — подстава, с плавающей ничего не было) Хотя я внимательно читал — целочисловые.
Вот присвоение значений других определителей — тоже самое, нету об этом, хотя что стоит дать число от другого, когда можно дать любое число перечислителю.
C#. Урок 7. Типы перечислений enum
Для представления набора связанных констант с символьными именами язык C# предоставляет инструмент: типы перечислений – enum‘ы. О том как создавать и работать с объектами такого типа будет рассказано в данном уроке.
Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.
Типы перечислений enum
Тип перечисление ( enum ) представляет собой набор символьных имен, связанных с уникальными целочисленными значениями. Для объявления этого типа используется оператор enum. После оператора enum указывается имя создаваемого типа. Через двоеточие можно указать тип констант перечисления (должен быть целочисленным). Если не указывать тип явно, то будет использован int. После этого приводится список символьных констант через запятую. Пример типа перечисления:
Каждому элементу перечисления присваивается целочисленное значение, в примере выше, эти значения начинаются с нуля и, далее, увеличиваются на единицу. Можно явно задать значения элементам перечисления. Для этого C# предоставляет два варианта: первый – это задание численного значения первому элементу, при этом все остальные, по очереди, принимают значения на единицу больше:
Второй вариант предполагает явное задание численных значений каждому элементу перечисления индивидуально:
Работа с переменными типа перечисления
Создадим следующий тип перечисление для экспериментов:
) и операции постфиксного и префиксного инкремента (++) и декремента (–), более подробно про эти операции написано в “Уроке 4. Простые типы. Арифметические и логические операции“.
Выполним несколько операций с типом WeekDay :
Продемонстрируем работу этого метода:
Тип System.Enum
Определение типа элемента перечисления
Для получения значения типа элемента перечисления используйте метод GetType непосредственно у самого элементы. Метод GetUnderlyingType у типа System.Enum возвращает базовый тип перечисления:
Конвертация числа в константу перечисления
Метод ToObject конвертирует целочисленное значение в экземпляр перечисления указанного типа:
Необходимо учитывать, что если ToObject применить к числу, которое не совпадает со значениями у элементов перечисления, то метод будет выполнен, но ничего не преобразует:
Проверка наличия целочисленного (или строкового) значения в заданном перечислении
Форматированное строковое представление значения перечисления
Метод Format предоставляет возможность форматированного конвертирования перечисления в строку:
Преобразование строки или числа в значение перечисления
Метод Parse преобразует строку (или число) в значение перечисления указанного типа. Значение и тип передаются в качестве аргументов методу, также можно дополнительно использоваться параметр ignoreCase для игнорирования регистра:
Получение имен элементов перечисления и их численных значений в виде массивов
Для получения имен элементов перечисления в виде массива строк, используется метод GetNames :
Массив численных значений можно получить с помощью метода GetValues :
Битовые флаги
Для использования перечислений как наборов битовых флагов необходимо:
Ниже представлен пример, демонстрирующий работу с битовыми флагами:
Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.
C#. Урок 7. Типы перечислений enum : 1 комментарий
В последнем примере наименование перечисления с именем Mounts не очевидно. Наверное должно быть Months
Вывод имени значения enum class. enum class => std::string
Можно ли как-то написать это умнее/короче? Правильный ли такой подход в целом?
Нет. C++ такое не умеет. Или глобальные методы или городить свой класс, ака:
Других способов нет. Для чего тебе это?
Жалко. Слишком много писанины получается.
Берите другой язык и не мучайтесь.
Чтобы логи писать/читать нормально, часто бывает важно узнать какое значение имеет enum.
Лучше словарик, а не свитч.
Так будет сложнее забыть обновить функцию при изменения перечисления.
Ага, спасибо. Хорошее замечание.
В общем как я понял такой способ самый удобный. Cпасибо LOR.
Ваш компилятор не умеет проверять switch?
Ваш компилятор не умеет проверять switch?
Умеет, конечно. Поэтому и выношу default, чтобы не мешать ему это делать.
Нечитаемая портянка, типичный сишных код
P.S. рекаптча должна умереть
В общем как я понял такой способ самый удобный. Cпасибо LOR.
Но далеко не самый быстрый.
Если есть возможность используй для этой цели string_view:
Даже в вашем простом примере 311 строчек против 471 с string:
Лул, ну сделай читаемой. Мое дело показать, как вы достали.
Эти разработчики, зачастую, не осилили IDE, которая это всё парсит и подсвечивает. А они продолжают грызть кактус типа вима.
Пардон. Не увидел минусы.
Слабо не постить быдлокод?
Спасибо за ссылку, посмотрел с удовольствием.
Эти разработчики, зачастую, не осилили IDE, которая это всё парсит и подсвечивает. А они продолжают грызть кактус типа вима.
Зачастую такие разработчики используют мышку и microsoft visual studio.
А вот и свидетели вима подтянулись.
QMetaEnum::valueToKeys() и Q_ENUM.
Конечно же, никак. Это же кресты. Просто выкинь кресты, и всё. Они говно.
C# тот же, позволяет сделать все легко через рефлекшн.
А вот и свидетели вима подтянулись.
Куда мне до мыше-программистов в ide, которая все умеет.
Ты так говоришь как будто это что-то плохое
Вот решение от германского студента:
Там даже примеры есть.
Ты так говоришь как будто это что-то плохое
Добавляем рефлексию для перечислений (enum) в C++
Недавно в нашем проекте возникла необходимость программно получать информацию о перечислениях (enum), например, имена констант в виде строк, а также общий список всех имеющихся в enum-е констант.
Обычно решение данной задачи базируется на дублировании значений, например, внутри switch-а:
И возможно, для небольших перечислений такое решение действительно является приемлемым, однако если значений много, и особенно, если они время от времени меняются, то рано или поздно разработчик может забыть дописать или изменить соответствующие строки в switch. Сюда прибавляются и другие очевидные минусы, например сам факт необходимости дублирования значений уже вызывает у меня некоторое недовольство.
Поэтому я постарался найти путь, который вообще не требовал бы дублирования, но при этом полностью справлялся бы с поставленной задачей. Думаю, у меня получилось.
Далее в статье я опишу способ, позволяющий организовать рефлексию для enum-ов. Кому интересно — добро пожаловать под кат.
Зачем это вообще нужно
Полезных применений может быть много. Одно из них — сериализация значений, например в JSON.
Также это может пригодиться для взаимодействия кода на C++ со скриптовыми языками (например, Lua).
Требования
Раз мы хотим избежать дублирования констант в коде, то нам нужно как-то сохранить информацию о всех значениях прямо в месте определения перечисления. Как вы уже, возможно, догадались, для этой цели придется использовать макрос. Учитывая это, можно выделить некоторые дополнительные требования:
Обязательным условием также является полная портируемость.
Результат
Сначала, привожу краткое описание того, что получилось. Ниже в статье будет описание деталей реализации.
Для добавления рефлексии, перечисление вместо ключевого слова enum следует объявлять с помощью макроса Z_ENUM. Например, для enum CardSuit из начала статьи, это выглядит следующим образом:
После этого в любом месте можно по типу перечисления получить ссылку на объект EnumReflector, который хранит о нем информацию:
Следующий пример показывает более сложное перечисление:
На этот раз получим всю имеющуюся информацию:
Особенности
Детали реализации
Итак, самое интересное.
Примечание: код, приводимый здесь упрощен в целях повышения читаемости. Полную версию вы можете найти на гитхабе, ссылка в конце статьи.
Рассмотрим его по частям:
В начале Z_ENUM раскрывается в обычный enum. Можно заметить, что явно указывается нижележащий тип данных — int. Так сделано только потому, что в EnumReflector сейчас значения хранятся с типом int. При необходимости int можно заменить на более большой тип.
После объявляется friend-функция _detail_reflector_. Она принимает значение типа нашего перечисления и возвращает ссылку на объект EnumReflector, который на самом деле является статическим объектом, объявленным внутри нее.
Немного забегая вперед, приведу функцию EnumReflector::For, которая служит внешним интерфейсом для получения объекта EnumReflector:
Но вернемся в функцию _detail_reflector_.
Для обеспечения атомарности, вся инициализация статического объекта EnumReflector происходит внутри безымянной лямбда-функции. Рассмотрим её поподробнее.
Сначала в ней объявляется статическая переменная-счетчик sval. Статическая она потому, что нам потребуется обращаться к ней из локального класса val_t, определенного далее. Не имея дополнительного состояния, локальный класс, очевидно, может обращаться только к статическим переменным внешнего блока. В переменной sval будет храниться следующее значение для константы. Следующей строчкой мы инициализируем её в 0.
Далее определяется тип val_t. После описания типа еще раз раскрывается __VA_ARGS__ (значения нашего перечисления). То есть мы определяем локальные переменные типа val_t — и их количество соответствует количеству значений в перечислении, а имена соответствуют самим константам (они перекрывают собой настоящие константы определенного до этого enum-а). Для того, чтобы инициализация этих переменных правильно работала, у типа val_t есть три конструктора. Каждый из них дополнительно устанавливает sval в следующее после себя значение, на случай если у следующей константы нет специально заданного значения.
Именно в этом месте, если после последнего значения имеется запятая — возникнет синтаксическая ошибка.
После, нам необходимо «перегнать» значения из переменных в массива типа int. Благодаря оператору преобразования в int у val_t это сделать довольно просто — мы можем в качестве инициализаторов массива сразу использовать наши переменные типа val_t, просто еще раз раскрыв __VA_ARGS__. Поскольку при таком раскрытии могут присутствовать присваивания, то мы добавляем в val_t два оператора присваивания, которые ничего не делают — таким образом мы полностью игнорируем присваивания.
Теперь, когда у нас есть массив всех значений и известно их количество, нужно получить названия констант в виде строк. Для этого все значения оборачиваются в строку вида «(__VA_ARGS__)». Эта строка, наряду с указателем на массив и количеством элементов, передается в конструктор EnumReflector. Ему осталось только распарсить строку, выделив из нее имена констант, и сохранить все значения.
Сам парсер для быстродействия организован в виде простого конечного автомата.
Мы просто идем по строке, сохраняя идентификаторы (названия констант). После очередного идентификатора, мы ищем начало следующего идентификатора, и так далее. В конце имеем готовую структуру данных, содержащую всю информацию о перечислении.
Остальная часть реализации класса EnumReflector служит для получения этой информации и на мой взгляд, не представляет особого интереса для данной статьи. Напоминаю, в конце есть ссылка на полную версию.
При объявлении перечисления вне класса функция _detail_reflector_ должна быть объявлена не как friend, а как inline. Отсюда необходимость в отдельном макросе Z_ENUM_NS. Чтобы случайно не использовать Z_ENUM_NS в теле класса, в нем также присутствует пустой блок extern «C» <> (напоминаю, его использование в теле класса не допускается стандартом, так что получим ошибку компиляции).
Также, во избежание возникновения коллизий имён с константами, в полной версии все идентификаторы внутри функции _detail_reflector_ имеют префикс _detail_.
Что можно улучшить
Можно попробовать выполнять парсинг для получения названий прямо на этапе компиляции, используя user-defined литералы для строк и constexpr функции из C++14.
Также было бы неплохо избавиться от необходимости в двух разных макросах для определения перечисления в классе и вне класса, но пока что я не нашел способа это сделать, не сломав при этом поиск ADL.