9 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Максимальное количество значений в enum Часть I

Содержание

Количество элементов в множестве (enum)

16 ответов

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

const int GraphFilesNum = 4;

void CheckRes()
<
for (int i=LEEFILE;i

Originally posted by XilefNori

enum GraphFileNumbers
<
LEEFILE = 0,
LEEFILE2,
ZFACE,
ZFACER
>;

const int GraphFilesNum = 4;

Если ты используешь перечисления без присвоений внутри (меняющих их порядок по умолчанию: от 0 и далее +1), то последний элемент и есть количество.
Например:
enum GraphFileNumbers
<
LEEFILE ,//= 0 — оно и так =0 — по умолчанию
LEEFILE2,
ZFACE,
ZFACER,
GraphFilesNum
>;
Т.е. теперь ты всегда уверен, что GraphFilesNum и есть кол-во

Нет, нельзя. Перечисление, вообще, не имеет «физического» представления, т.е. не занимает места, не имеет размера и т.д.

Что касаемо GraphFilesNum, то оно связано на мой взгляд с GraphFiles[], а не enum:

const int GraphFilesNum = sizeof(GraphFiles)/sizeof(GraphFiles[0]);

Разумно.
Других вариантов нет?

Проверил. Работает. Хотя с моей точки зрения не должно: длины названий файлов разные.

Разумно.
Других вариантов нет?

Этот не устраивает ? Или сомневаешься — вот кусок моего кода:
enum < cl_Screen=0, // фон экрана
.
.
cl_ErrorMsg, // сообщения об ошибках
cl_HotKeys, // @горячие@ клавиши
cl_ //
>;
.
.
unsigned char Clrs[cl_];

Enumы хотя и могут именоваться, но не подвержены sizeof-у — их действительно нет во время исполнения — о них «знал» лишь компилятор.

Длины названий здесь не имеют значения.

GraphFiles[] — массив const AnsiString
sizeof(GraphFiles) — размер этого массива
sizeof(GraphFiles[0]) — размер элемента массива, т.е. sizeof(AnsiString).

Да нет. Просто интересно есть ли другие решения.

Это ясно. Однако не ясно почему AnsiString имеет такой странный размер: всего 4 байта?

Да еще вопрос:
Можно ли пробежаться по всем значениям перечисления enum в цикле, если они не составляют арифметическую последоватьность, вроде:

enum E
<
E1 = 0,
E2,
E3 = -3,
E4 = 102,
E5 = 8
>;
?

Размер класса определяется суммарным размером входящих в него членов данных с учетом выравнивания.
Т.о. получается, что AnsiString, видимо, имеет один такой член — указатель на строку.

Нет. Хотя, вопрос не совсем понятен.

Т.е. допустим:
если данные занимают int x — байт, а память квантуется по int i байт, то в случае если x%i!=0, то под эти данные выделится память размером (x/i)*(i+1)?

Я такого не замечал. Можно ссылочку кинуть на тему этого таинственного выравнивания?

Ну например написать что-нибудь вроде:

for(int i=E.begin(); i!=E.end(); i++)
<
Check(i);
>

Originally posted by XilefNori

Т.е. допустим:
если данные занимают int x — байт, а память квантуется по int i байт, то в случае если x%i!=0, то под эти данные выделится память размером (x/i)*(i+1)?

Я такого не замечал. Можно ссылочку кинуть на тему этого таинственного выравнивания?

Посмотри опции компилятора. Для VC++ это /Zp.
А также #pragma pack

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

Кстати, sizeof() в данном случае тоже вычисляется еще при компиляции программы.

Кстати, sizeof() в данном случае тоже вычисляется еще при компиляции программы.

он м.б. и вычисляется — но как ?
проверь сам на практике (в отладчике):
enum E
<
E1,
E2,
E3,
E4,
E5
>;
.
int e=sizeof(E);
.
— посмотри чему равно е.

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

int e = sizeof E;

sizeof для enum это размерность наименьшего (по размерности) типа, который может содержать наибольшее значение из enum. Но этот тип по размерности не больше int.
Может, коряво сказал, но в кратце sizeof для enum будет 1, 2 или 4, в зависимости от разрядности максимального значения.
Правда, это было действительно для 32-битных архитектур. Возможно, что для 64-битных sizeof может быть и 8.

Максимальное количество элементов перечисления в Java

21 Rnet [2010-12-17 09:56:00]

Каково максимальное количество элементов, разрешенных в перечислении в Java?

Я хотел узнать максимальное количество случаев в инструкции switch. Поскольку наибольший примитивный тип, разрешенный в коммутаторе, является int, мы имеем случаи от -2147,483,648 до 2,147,483,647 и один случай по умолчанию. Однако перечисления также разрешены. так что вопрос..

java enums switch-statement

7 ответов

23 Решение Thilo [2010-12-17 10:07:00]

Пул констант для каждого класса или каждого интерфейса ограничен 65535 элементами 16-разрядного поля constant_pool_count структуры ClassFile (§ 4.1). Это действует как внутренний предел общей сложности одного класса или интерфейса.

Я считаю, что это означает, что у вас не может быть больше 65535 с именем «вещи» в одном классе, что также ограничивало бы число констант перечисления.

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

К счастью, этого не может быть:

Количество кода на не-родной, не абстрактный метод ограничено 65536 байтами по размерам индексов в таблице exception_table атрибута Code (§4.7.3) в атрибуте LineNumberTable (§4.7.8).), и в атрибуте LocalVariableTable (§4.7.9).

Хорошо, на jdk1.6 я ударил этот предел. У кого-то есть 10 000 enum в xsd, и когда мы сгенерируем, мы получаем файл перечисления в 60 000 строк, и у меня получается хорошая ошибка компилятора java

[ERROR] Не удалось выполнить цель org.apache.maven.plugins: maven-compiler-plugin: 2.0.2: скомпилировать (по умолчанию компиляция) в рамках проекта: сбой компиляции [ERROR]/Users/dhiller/Space/ifp-core/framework/target/generated-sources/com/framework/util/LanguageCodeSimpleType.java:[7627,4] слишком большой

так что, возможно, предел намного ниже, чем другие ответы здесь, или, возможно, комментарии и такие, которые генерируются, занимают слишком много места. Обратите внимание, что номер строки 7627 в ошибке компилятора java, хотя, если лимит линии равен 7627, мне интересно, что такое ограничение длины строки;), которое может быть аналогичным. то есть. лимиты могут быть не основаны на количестве перечислений, а только на ограничениях длины строки или количестве строк в пределе файла, поэтому вы должны переименовать перечисления в A, B и т.д., чтобы быть очень маленькими, чтобы вписать больше перечислений в перечисление.

Читать еще:  NTLDR is missing. Как восстановить загрузочный сектор и загрузочную запись?

Я не могу поверить, что кто-то написал xsd с перечислением в 10 000. Они должны были сгенерировать эту часть xsd.

6 Thomas W [2014-12-17 01:31:00]

У перечислений определенно есть лимиты, с максимальным (жестким) ограничением около 32 тыс. значений. Они подвержены максимальным значениям класса Java, как «постоянного пула» (записи в 64 КБ), так и — в некоторых версиях компилятора — до ограничения размера метода (байтовый код 64 КБ) в статическом инициализаторе.

Инициализация «Enum» внутри, использует две константы на значение — поле FieldRef и строку Utf8. Это дает «жесткий предел» при значениях

Старые компиляторы (как минимум, Eclipse Indigo) также сталкиваются с проблемой статического размера метода инициализатора. С 24 байтами байт-кода требуется для создания каждого значения и добавления его в массив значений. может встречаться предел около 2730.

Более новые компиляторы (по крайней мере, JDK 7) автоматически разбивают большие статические инициализаторы на методы с именем » enum constant initialization$2″ , » enum constant initialization$3″ и т.д., поэтому не подлежат второму лимиту.

Вы можете разобрать байт-код через javap -v -c YourEnum.class , чтобы узнать, как это работает.

[Теоретически возможно написать «класс старого класса» в качестве ручного кодирования Java, чтобы разбить предел 32K и приблизиться к значениям до 64K. Подходом было бы инициализировать значения перечисления путем отражения, чтобы избежать необходимости строковых констант в пуле. Я протестировал этот подход и работает на Java 7, но желательность такого подхода (проблемы безопасности) сомнительна.]

4 Derek [2017-03-02 19:45:00]

Максимальное количество элементов перечисления — 2746. Чтение спецификации было очень ошибочным и заставило меня создать ошибочный дизайн с предположением, что я бы никогда не попал под отметку 64K или даже 32K. К сожалению, число намного ниже, чем указывает спецификация. В качестве теста я попробовал следующее как с Java 7, так и с Java 8: Ran следующий код перенаправил его в файл, а затем скомпилировал полученный .java файл.

Результат, 2746 работ и 2747 нет.

После 2746 записей компилятор выдает слишком большую ошибку кода, например

EnumSizeTest.java:2: ошибка: слишком большой код

Декомпиляция этого файла класса Enum, как представляется, вызвана кодом, сгенерированным для каждого значения перечисления в статическом конструкторе (в основном).

Максимальный размер любого метода в Java составляет 65536 байт. Хотя теоретически вы можете иметь большой переключатель или больше значений перечисления, его максимальный размер метода, который вы, скорее всего, нажмете первым.

2 Brad Mace [2010-12-17 10:09:00]

В классе Enum используется int для отслеживания каждого значения ординала, поэтому max будет таким же, как int в лучшем случае, если не намного ниже.

И как говорили другие, если вы должны спросить, что вы делаете это неправильно

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

Получение максимального значения перечисления

Как вы получите максимальное значение перечисления?

Enum.GetValues ​​(), похоже, возвращает значения в порядке, поэтому вы можете сделать что-то вроде этого:

Edit

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

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

Я согласен с Мэттом. Если вам нужны только значения min и max int, вы можете сделать это следующим образом.

Максимум:

Минимум:

Согласно ответу Мэтта Гамильтона, я подумал о создании для него метода Extension.

Поскольку ValueType не принимается как ограничение параметра общего типа, я не нашел лучшего способа ограничить T для Enum но следующее.

Любые идеи будут по достоинству оценены.

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

Это слегка придирчиво, но фактическим максимальным значением любого перечисления является Int32.MaxValue (при условии, что это перечисление, полученное из int). Совершенно законно приводить любое значение Int32 к любому перечислению независимо от того, действительно ли оно объявило член с этим значением.

После того, как я попробовал другое время, я получил этот метод расширения:

Использование последней функции не может получить максимальное значение. Используйте функцию «max». Как:

В согласии с Мэтью J Салливаном, для С#:

Я действительно не уверен, почему кто-то захочет использовать:

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

Существуют методы получения информации о перечисляемых типах в System.Enum.

Итак, в проекте VB.Net в Visual Studio я могу ввести «System.Enum». и intellisense воспитывает все виды доброты.

Один из методов, в частности, — System.Enum.GetValues ​​(), который возвращает массив перечисленных значений. После того, как вы получите массив, вы сможете делать все, что подходит для ваших конкретных обстоятельств.

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

Когда вместо Boolean лучше использовать Enum и почему

Когда вместо Boolean лучше использовать Enum и почему

    Переводы , 8 мая 2020 в 20:46

Автор перевода Алина Уткина

Boolean — один из первых типов данных, которые изучают начинающие программисты. Почему бы и нет? Логический тип максимально прост, ведь принимает всего два значения: true и false .

Прим.ред. Речь идёт о языках программирования, в которых Boolean не может быть null .

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

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

Читать еще:  Универсальное расширение 1С для Google Таблиц и Документов — берите и пользуйтесь

Пример использования Boolean

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

В конце концов, в коде появляются такие функции:

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

Кто-то из команды предлагает изменить название функции на setUserOnline() , и поначалу этого решения оказывается достаточно. Но затем всё превращается в сущий кошмар, ведь требование дополняется необходимостью ввести ещё один статус: BLOCKED . Есть несколько способов решить поставленную задачу. Разберём их подробнее.

Одна булева переменная и три состояния

Boolean обычно принимает два значения. Но в некоторых языках, таких как Java, где у примитивных типов есть классы обёртки, можно использовать null для присвоения третьего состояния. В нашем примере для определения статуса BLOCKED будет использовано значение null .

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

Кроме того, в некоторых сценариях будет сложно отличить false от null . Возьмём, к примеру, свойство game.isPlaying . Значение true будет чётко указывать на то, что игра запущена. Но что если значение равно false или null ? false означает, что игра на паузе или остановлена? А на что в таком случае указывает null ?

Как видите, значение false недостаточно информативно, и наличие третьего состояния, привязанного к null , только усложнит логику кода.

К тому же, что произойдёт, если разработчиков попросят добавить ещё один статус — EXPIRED ? Становится понятно, что способ с использованием одной булевой переменной не подходит.

Несколько булевых переменных

В итоге команда решает расширить сигнатуру предыдущей функции, добавив два булевых параметра для новых состояний:

И вот какие проблемы их поджидают.

Появление скрытых зависимостей

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

Теперь будет две скрытые зависимости: isUserOnline — isUserExpired и isUserOnline — isUserBlocked . Придётся обрабатывать дополнительные условия, чтобы избежать конфликтующих состояний. Например, пользователь со статусом BLOCKED или EXPIRED не может быть со статусом ONLINE . Примеры таких условий:

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

Проблемы с безопасностью и читаемостью

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

setUserState(true, false, false)

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

Группа разработчиков из примера избежит перечисленных проблем, если вместо Boolean использует Enum.

Использование Enum

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

Рассмотрим главные преимущества Enum.

Чёткость и содержательность

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

Простое масштабирование

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

Высокая типобезопасность

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

Однако не все языки поддерживают Enum. В таких случаях вы можете создать собственные типы. Например, в JavaScript можно «заморозить» константы в объекте:

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

Заключение

Boolean — это не плохо. Его можно использовать, если вы уверены, что имеете дело с двумя взаимоисключающими состояниями, или если это стандартный метод, который подразумевает принятие булевого аргумента (например setEnabled(true) ).

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

Enum как работать и зачем нужно

enum – Это тип перечисление.
В enum записываются константы и каждой новой константе присваивается порядковый номер, чтобы было понятно привожу код C++

enum boolean < false , true >; // Перечислили две константы false и true
boolean flag ; //flag есть переменная типа перечисления boolean

void main ()
<
clrscr ();

flag = 0 ; //перечисление flag обращается к своему нулевому элементу, flag=false=0;
cout

void main ()
<
clrscr ();
enum boolean //=Верно и Неверно
boolean flag ; //flag есть переменная типа boolean
cout > ch ;
//Присвоили в ch введенный ответ

/*Возможны два варианта обращения к перечислению*/
if ( ch == 4 ) //если ввели 4, то flag=true =0
else //в противном случае flag=false=1

//то же самое можно написать так
if ( ch == 4 ) //если ввели 4, то flag=0
else //в противном случае flag=1

getch ();
return;
>
====================
Здесь показано, что к перечислению можно обращаться двумя способами.

  • В первом случае обращение идет к имени константы
  • Во втором случае обращение идет к номеру константы

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

Читать еще:  Ксв метр на 2 метровый диапазон. Ксв-метр на полосковых линиях

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

Код С++ Вытащить строковое значение из enum
==========================

void main ()
<
clrscr ();
enum boolean < true , false >; //boolean -тип перечисление
boolean flag ; //flag переменная типа boolean

//Обращаемся по порядковому номеру

flag = 0 ; // Явное привидение flag=0;
cout May 3, 2012

Урок №58. Перечисление (enum)

Обновл. 30 Дек 2019 |

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

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

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

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

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

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

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

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

Распространено добавление названия перечисления в качестве префикса к перечислителям, например: ANIMAL_ или COLOR_ , как для предотвращения конфликтов имён, так и в целях комментирования кода.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ответ №3

Правда. Перечислителю без значения будет неявно присвоено целочисленное значение предыдущего перечислителя + 1. Если предыдущего перечислителя нет, то тогда присвоится значение 0.

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

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

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

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

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

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

Очень мотивируют живые примеры с оружием и монстрами, а не с поднадоевшими студентами

Прочитав урок 3 раза и туго понимая что к чему, я таки нашел ключевую фразу, которая сразу прояснила все в голове. Все стало понятно. Думаю не я один такой, поэтому рассказываю:
для меня этой ключевой фразой послужил 3-ий сверху комментарий в 1-ом коде урока. // Это все возможные значения этого типа данных
…Шит!… это же ТИП данных, такой же как int или char! А перечисление — это буквально ПЕРЕЧИСЛЕНИЕ всех символьных имен этого( создаваемого нами самими типа), с присвоением им порядковых, или иных, на выбор, номеров! Т.е. просто перечисляем по очереди имена всех возможных значений этого типа, и присваиваем им ( или это делает автоматически компилятор) целочисленные идентификационные значения (номера). И конечно, они могут быть только константными(постоянными). Это же логично. К примеру, в типе CHAR , мы же заранее знаем все символьные значения и их числовые эквиваленты, и все это неизменно. А здесь у нас свобода назвать свой тип данных, выбрать символы и их числовые эквиваленты. Кстати, получается таблица ASII с ее символами и нумерацией, это тоже своего рода перечисление, только по умолчанию. Вот и все!

Перечисления перечислениями , а мне непонятно одно — для чего нужны переменные типа перечисления если и без них всё работает. Ответа нигде не нашёл.

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

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

Ссылка на основную публикацию
Статьи c упоминанием слов:

Adblock
detector