Андрей Смирнов
Время чтения: ~18 мин.
Просмотров: 0

Что такое enum и как это работает?

Как проходит авторизация ENUM?

Для каждого способа авторизации, предоставляемых сервисом ENUM, вам потребуется выполнить определенные действия, в качестве примера давайте рассмотрим авторизацию через вопрос – ответ:

  1. Сначала, пользователи переходят к защищенному функционалу ENUM, используя при этом программу или веб интерфейс страниц в интернете. Всё, что требуется, это указать свой Email, после чего появляется число – вопрос.
  2. Чтобы получить ответ на число – вопрос, необходимо воспользоваться ENUM клиентом и указать вопрос в специальной форме, после чего будет получен ответ. Помимо этого, число ответ можно получить по SMS.
  3. Последнее действие, это ввод числа – ответа, благодаря чему осуществляется переход к защищенным данным или подтверждается оплата. Ничего сложного в использовании ENUM нет, следовательно, каждый пользователь Webmoney может усилить защиту своих финансов, потратив совсем немного времени.

Каждый желающий может зарегистрироваться в системе ENUM и настроить параметры авторизации по собственному усмотрению.

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

Вход в WM Keeper, а так же подтверждение исходящих транзакций, это один из процессов, который так же можно сопровождать функционалом сервиса ENUM.

При осуществлении входа в клиентское приложение Webmoney, и используя при этом ENUM, вам не потребуется файл ключей, логин и пароль, а так же для пользователей WM Keeper Light снимается необходимость использования персонального сертификата.

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

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

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

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

Перечисления¶

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

Тело перечисления состоит из нуля или более элементов. Элементы перечисления имеют численное значение ассоциированное с именем, и могут быть либо константой, либо могут быть вычислены. Элемент перечисления считается константой, если:

  • Он не имеет инициализатора, предшествующий элемент перечисления был константой. В этом случае значение текущего элемента перечисления будет равняться значению предшествующего элемента перечисления плюс единица. Исключением является первый элемент перечисления. Если элемент не имеет инициализатора, ему присваивается значение .
  • Элемент перечисления инициализирован с константным выражением перечисления. Константное выражение перечисления — это подмножество TypeScript выражений, которое может быть полностью вычислено во время компиляции. Выражение является константным выражением перечисления, если оно является либо:
  • численным литералом
  • ссылкой к прежде определённому константному элементу перечисления (она может быть определёна в различных перечислениях). Если элемент определён в том же перечислении, на него можно сослаться, используя неквалифицированное имя.
  • константным выражением перечисления, взятым в круглые скобки
  • унарным оператором , , , применённым к константному выражению перечисления
  • бинарным оператором , , , , , , , , , , с константным выражением перечисления как операнд. Константное выражение перечисления, вычисляемое в или , приводит к ошибке во время компиляции

Во всех остальных случаях считается, что элемент перечисления вычисляем.

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

компилируется в:

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

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

в сгенерированном коде превратится в

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

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

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

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

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

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

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

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

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

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

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

Детали системы

Для использования услуги ENUM абоненту следует получить у регистратора следующие данные и полномочия:

1. Персональный (URI), используемый в сегменте сети, работающем по IP, подробнее см. ниже;

2. Номер телефона стандарта E.164, ассоциируемый с упомянутым выше URI, используемый в сегменте ТфОП;

3. Полномочия на изменение информации о переадресации и терминировании вызовов в записи NAPTR, доступной по персональному URI.

Это работает следующим образом: (1) Регистратор обеспечивает Подписчика (или Регистратора) именем домена, URI, которые будут использоваться, чтобы обратиться к DNS серверу, чтобы получить запись NAPTR, (2) персональный номер телефона E.164 (номер ENUM). Имя домена URI (1) — одно-двух-значно ассоциированное (взаимно-однозначно отображаемый) с E.164 номером подписчика ENUM (2). Наконец (3) запись NAPTR корреспондируется на подписчика содержащее предпочтения переадресации/завершения вызова подписчика.

Вызов, использующий новый персональный номер E.164 (ENUM номер) к поиску в базе данных, следовательно является косвенным вызовом, поддерживаемый сервисом.

URI могут быть использованы, чтобы искать в DNS интернет-адреса для сервисов, типа SIP VoIP-телефонии. Записи NAPTR используются, чтобы установить персональные настройки переадресации/завершения вызовов абонентов. Поэтому целая система может ‘транслировать’ адреса E.164 в адреса SIP. Пример записи NAPTR:

  1. Запрос посылается Системе Доменных Имен (DNS), для выяснения ищется домен ENUM 1.2.3.4.5.6.7.8.9.4.3.e164.arpa.
  2. Приложение оконечного устройства теперь устанавливает коммуникационное соединение, а вызов маршрутизируется через Интернет.

Пользователь ENUM не замечает ничего из этой реверсии и поиска в базе данных DNS, поскольку это сделано автоматически и не на переднем плане, используя пользовательское программное обеспечение агента в компьютере, или в оконечном устройстве, или в PABX или в шлюзе. Например, когда пользователь набрал номер телефона в своём браузере, ENUM вызывает агента и указывает, какой информационный объект он ищет (адрес электронной почты, номер телефона, адрес сети и т. д.) в компьютере или в оконечном устройстве, номер конвертируется в имя домена. Его посылают серверам ENUM в Интернет, которые возвращают назад записи NAPTR, связанные с именами. Информация доступа и различные приоритеты, обозначенный для них, сохранены в них. Пользователю на его компьютер или оконечное устройство возвращают требуемый адрес. ENUM поэтому фактически функционирует как механизм того, чтобы перевести номер телефона в название домена с требуемым адресом или числом, связанным с ним, но без рассмотрения пользователя, как это выполнено, так же, как он даже не знает, что он использует DNS, что когда он делает вызов он осуществляется соединение через Интернет или что это осуществляется в телефонном коммутаторе.

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

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

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

int readFileContents()
{
if (!openFile())
return -1;
if (!parseFile())
return -2;
if (!readFile())
return -3;

return 0; // если всё прошло успешно
}

1
2
3
4
5
6
7
8
9
10
11

intreadFileContents()

{

if(!openFile())

return-1;

if(!parseFile())

return-2;

if(!readFile())

return-3;

return;// если всё прошло успешно

}

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

enum ParseResult
{
SUCCESS = 0,
ERROR_OPENING_FILE = -1,
ERROR_PARSING_FILE = -2,
ERROR_READING_FILE = -3
};

ParseResult readFileContents()
{
if (!openFile())
return ERROR_OPENING_FILE;
if (!parseFile())
return ERROR_PARSING_FILE;
if (!readfile())
return ERROR_READING_FILE;

return SUCCESS; // если всё прошло успешно
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

enumParseResult

{

SUCCESS=,

ERROR_OPENING_FILE=-1,

ERROR_PARSING_FILE=-2,

ERROR_READING_FILE=-3

};

ParseResult readFileContents()

{

if(!openFile())

returnERROR_OPENING_FILE;

if(!parseFile())

returnERROR_PARSING_FILE;

if(!readfile())

returnERROR_READING_FILE;

returnSUCCESS;// если всё прошло успешно

}

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

if (readFileContents() == SUCCESS)
{
// Делаем что-нибудь
}
else
{
// Выводим сообщение об ошибке
}

1
2
3
4
5
6
7
8

if(readFileContents()==SUCCESS)

{

// Делаем что-нибудь

}

else

{

// Выводим сообщение об ошибке

}

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

#include <iostream>
#include <string>

enum ItemType
{
ITEMTYPE_GUN,
ITEMTYPE_ARBALET,
ITEMTYPE_SWORD
};

std::string getItemName(ItemType itemType)
{
if (itemType == ITEMTYPE_GUN)
return std::string(«Gun»);
if (itemType == ITEMTYPE_ARBALET)
return std::string(«Arbalet»);
if (itemType == ITEMTYPE_SWORD)
return std::string(«Sword»);
}

int main()
{
// ItemType — это перечисляемый тип, который мы объявили выше
// itemType (с маленькой i) — это имя переменной, которую мы определяем ниже (типа ItemType)
// ITEMTYPE_GUN — это значение перечислителя, которое мы присваиваем переменной itemType
ItemType itemType(ITEMTYPE_GUN);

std::cout << «You are carrying a » << getItemName(itemType) << «\n»;

return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#include <iostream>
#include <string>

enumItemType

{

ITEMTYPE_GUN,

ITEMTYPE_ARBALET,

ITEMTYPE_SWORD

};

std::stringgetItemName(ItemType itemType)

{

if(itemType==ITEMTYPE_GUN)

returnstd::string(«Gun»);

if(itemType==ITEMTYPE_ARBALET)

returnstd::string(«Arbalet»);

if(itemType==ITEMTYPE_SWORD)

returnstd::string(«Sword»);

}

intmain()

{

// ItemType — это перечисляемый тип, который мы объявили выше

// itemType (с маленькой i) — это имя переменной, которую мы определяем ниже (типа ItemType)

// ITEMTYPE_GUN — это значение перечислителя, которое мы присваиваем переменной itemType

ItemType itemType(ITEMTYPE_GUN);

std::cout<<«You are carrying a «<<getItemName(itemType)<<«\n»;

return;

}

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

enum SortType
{
SORTTYPE_FORWARD,
SORTTYPE_BACKWARDS
};

void sortData(SortType type)
{
if (type == SORTTYPE_FORWARD)
// Сортировка данных в одном порядке
else if (type == SORTTYPE_BACKWARDS)
// Сортировка данных в обратном порядке
}

1
2
3
4
5
6
7
8
9
10
11
12
13

enumSortType

{

SORTTYPE_FORWARD,

SORTTYPE_BACKWARDS

};

voidsortData(SortType type)

{

if(type==SORTTYPE_FORWARD)

// Сортировка данных в одном порядке

elseif(type==SORTTYPE_BACKWARDS)

// Сортировка данных в обратном порядке

}

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

Как установить E-num (+ видео-инструкция)

Чтобы начать использовать E-num на мобильном устройстве с ОС Андроид необходимо скачать установочный файл с расширением *.apk с официального сайта или установить приложение из Play Маркета. Сама программа интуитивно понятная и ее использование не вызывает затруднений. Сразу после установки система предложит войти в свой аккаунт, а при отсутствии оного – зарегистрировать его.

Современные смартфоны и планшеты предоставляют пользователям возможность установки графического или цифрового пароля на приложение. В случае с E-num данная функция встроена в саму программу, но рекомендуется не пренебрегать дополнительными мерами безопасности и установить блокировку на само приложение. В случае кражи мобильного устройства это усложнит задачу злоумышленникам.

Помимо операционной системы Андроид, клиент E-num также разработан для пользователей следующих операционных систем:

  • Apple iOS;
  • WindowsPhone;
  • BlackBerry.

На официальном сайте E-num, а также на странице Wiki.WebMoney, посвященной данному клиенту, есть ссылки на установку приложения.

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

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

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

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

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

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

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

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

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

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

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

Безопасно ли использовать e-num?

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

Перечисления enum

Последнее обновление: 03.10.2018

Кроме примитивных типов данных в C# есть такой тип как enum или перечисление. Перечисления представляют набор логически связанных констант.
Объявление перечисления происходит с помощью оператора enum. Далее идет название перечисления, после которого указывается тип перечисления — он обязательно
должен представлять целочисленный тип (byte, int, short, long). Если тип явным образом не указан, то по умолчанию используется тип int.
Затем идет список элементов перечисления через запятую:

enum Days
{
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday
}
 
enum Time : byte
{
    Morning,
    Afternoon,
    Evening,
    Night
}

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

enum Operation
{ 
    Add = 1,   // каждый следующий элемент по умолчанию увеличивается на единицу
    Subtract, // этот элемент равен 2
    Multiply, // равен 3
    Divide    // равен 4
}

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

enum Operation
{ 
    Add = 2,
    Subtract = 4,
    Multiply = 8,
    Divide = 16
}

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

enum Color
{
	White = 1,
	Black = 2,
	Green = 2,
	Blue = White // Blue = 1
}

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

enum Operation
    {
        Add = 1,
        Subtract,
        Multiply,
        Divide
    }
class Program
{
    static void Main(string[] args)
    {
        Operation op;
		op = Operation.Add;
		Console.WriteLine(op); // Add
		
        Console.ReadLine();
    }  
}

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

Operation op;
op = Operation.Multiply;
Console.WriteLine((int)op); // 3

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

enum Operation
{
	Add = 1,
	Subtract,
	Multiply,
	Divide
}
class Program
{    
    static void Main(string[] args)
    {
        Operation op;
		op = Operation.Add;
		Console.WriteLine(op); // Add
		
        Console.ReadLine();
    }  
}

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

class Program
{
    enum Operation
    {
        Add = 1,
        Subtract,
        Multiply,
        Divide
    }

    static void MathOp(double x, double y, Operation op)
    {
        double result = 0.0;

        switch (op)
        {
            case Operation.Add:
                result = x + y;
                break;
            case Operation.Subtract:
                result = x - y;
                break;
            case Operation.Multiply:
                result = x * y;
                break;
            case Operation.Divide:
                result = x / y;
                break;
		}

        Console.WriteLine("Результат операции равен {0}", result);
    }

    static void Main(string[] args)
    {
        // Тип операции задаем с помощью константы Operation.Add, которая равна 1
        MathOp(10, 5, Operation.Add);
        // Тип операции задаем с помощью константы Operation.Multiply, которая равна 3
        MathOp(11, 5, Operation.Multiply);
            
        Console.ReadLine();
    }  
}

Здесь у нас имеется перечисление Operation, которое представляет арифметические операции. Также у нас определен метод MathOp, который
в качестве параметров принимает два числа и тип операции. В основном методе Main мы два раза вызываем процедуру MathOp, передав в нее
два числа и тип операции.

НазадВперед

Регистрация, настройка, восстановление доступа¶

  • смартфон или планшет с ОС Android;
  • iPhone, iPad или iPod Touch с Apple iOS;
  • мобильное устройство, работающее на ОС Windows Phone и BlackBerry.

Адрес электронной почты, указываемый в Аттестате Вашего WMID WebMoney Transfer, необходимо использовать и в сервисе E-num.

Зарегистрироваться в системе E-num можно тремя способами:

  • самостоятельно на сайте сервиса — www.enum.ru;
  • автоматически при подтверждении оплаты или авторизации на сайтах системы;
  • из приложения E-num клиент (пока доступно только в приложении на Android);
  • новые участники системы WebMoney Transfer, использующие мобильное приложение, могут зарегистрироваться в сервисе E-NUM автоматически.

Пошаговая инструкция по регистрации в системе E-num приведена в основной статье Регистрация в сервисе E-num. Порядок действий при авторегистрации — в дополнительных инструкциях: Создание E-num аккаунта на сервисе Мерчант и Создание E-num аккаунта при подтверждении авторизации.

Реализация возможностей системы E-num осуществляется с использованием мобильного клиента или мобильного приложение WM Keeper для Android. Описание процедур установки и настройки E-num клиентов для различных платформ смотрите в статье E-num клиент и Подтверждение операций в Keeper Android.

Инструкцию по установке параметров E-num аккаунта смотрите в статье Настройка учетной записи E-num.

При утере доступа к E-num аккаунту воспользуйтесь инструкциями по восстановлению.

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

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

#include <iostream>

enum Colors
{
COLOR_YELLOW, // присваивается 0
COLOR_WHITE, // присваивается 1
COLOR_ORANGE, // присваивается 2
COLOR_GREEN, // присваивается 3
COLOR_RED, // присваивается 4
COLOR_GRAY, // присваивается 5
COLOR_PURPLE, // присваивается 6
COLOR_BROWN // присваивается 7
};

int main()
{
Colors paint(COLOR_RED);
std::cout << paint;

return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include <iostream>
 

enumColors

{

COLOR_YELLOW,// присваивается 0

COLOR_WHITE,// присваивается 1

COLOR_ORANGE,// присваивается 2

COLOR_GREEN,// присваивается 3

COLOR_RED,// присваивается 4

COLOR_GRAY,// присваивается 5

COLOR_PURPLE,// присваивается 6

COLOR_BROWN// присваивается 7

};

intmain()

{

Colors paint(COLOR_RED);

std::cout<<paint;

return;

}

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

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

// Определяем новый перечисляемый тип Animals
enum Animals
{
ANIMAL_PIG = -4,
ANIMAL_LION, // присваивается -3
ANIMAL_CAT, // присваивается -2
ANIMAL_HORSE = 6,
ANIMAL_ZEBRA = 6, // имеет то же значение, что и ANIMAL_HORSE
ANIMAL_COW // присваивается 7
};

1
2
3
4
5
6
7
8
9
10

// Определяем новый перечисляемый тип Animals

enumAnimals

{

ANIMAL_PIG=-4,

ANIMAL_LION,// присваивается -3

ANIMAL_CAT,// присваивается -2

ANIMAL_HORSE=6,

ANIMAL_ZEBRA=6,// имеет то же значение, что и ANIMAL_HORSE

ANIMAL_COW// присваивается 7

};

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

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

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

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

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

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

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

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

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

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

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

enum Colors
{
COLOR_PURPLE, // присваивается 0
COLOR_GRAY, // присваивается 1
COLOR_BLUE, // присваивается 2
COLOR_GREEN, // присваивается 3
COLOR_BROWN, // присваивается 4
COLOR_PINK, // присваивается 5
COLOR_YELLOW, // присваивается 6
COLOR_MAGENTA // присваивается 7
};

void printColor(Colors color)
{
if (color == COLOR_PURPLE)
std::cout << «Purple»;
else if (color == COLOR_GRAY)
std::cout << «Gray»;
else if (color == COLOR_BLUE)
std::cout << «Blue»;
else if (color == COLOR_GREEN)
std::cout << «Green»;
else if (color == COLOR_BROWN)
std::cout << «Brown»;
else if (color == COLOR_PINK)
std::cout << «Pink»;
else if (color == COLOR_YELLOW)
std::cout << «Yellow»;
else if (color == COLOR_MAGENTA)
std::cout << «Magenta»;
else
std::cout << «Who knows!»;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

enumColors

{

COLOR_PURPLE,// присваивается 0

COLOR_GRAY,// присваивается 1

COLOR_BLUE,// присваивается 2

COLOR_GREEN,// присваивается 3

COLOR_BROWN,// присваивается 4

COLOR_PINK,// присваивается 5

COLOR_YELLOW,// присваивается 6

COLOR_MAGENTA// присваивается 7

};

voidprintColor(Colors color)

{

if(color==COLOR_PURPLE)

std::cout<<«Purple»;

elseif(color==COLOR_GRAY)

std::cout<<«Gray»;

elseif(color==COLOR_BLUE)

std::cout<<«Blue»;

elseif(color==COLOR_GREEN)

std::cout<<«Green»;

elseif(color==COLOR_BROWN)

std::cout<<«Brown»;

elseif(color==COLOR_PINK)

std::cout<<«Pink»;

elseif(color==COLOR_YELLOW)

std::cout<<«Yellow»;

elseif(color==COLOR_MAGENTA)

std::cout<<«Magenta»;

else

std::cout<<«Who knows!»;

}

Рейтинг автора
5
Материал подготовил
Максим Иванов
Наш эксперт
Написано статей
129
Ссылка на основную публикацию
Похожие публикации