Перечисление c: Перечисления в C++ | Уроки С++

C++ | Перечисления

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

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

Перечисления (enum) представляют еще один способ определения своих типов. Их отличительной особенностью является то, что они содержат набор числовых констант.

Определим простейшее перечисление:


enum seasons
{
	spring,
	summer,
	autumn,
	winter
};

Для определения перечисления применяется ключевое слово enum, после которого идет название перечисления. Затем в фигурных скобках идет перечисление констант через запятую. Каждой константе по умолчанию будет присваиваться числовое значение начиная с нуля. То есть в данном случае spring=0, a winter=3.

Используем перечисление:


#include <iostream>
enum seasons
{
	spring,
	summer,
	autumn,
	winter
};
int main()
{
	seasons currentSeason = autumn;
	// или так
	// seasons currentSeason = seasons::autumn;
	std::cout << "Season: " << currentSeason << std::endl;
	return 0;
}

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

Season: 2

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

seasons currentSeason = 2;	// ошибка

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


enum seasons
{
	spring = 1,
	summer,	//2
	autumn,	//3
	winter	//4
};

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

Также можно задать значение для каждой константы:


enum seasons
{
	spring = 1,
	summer = 2,
	autumn = 4,
	winter = 8
};

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


#include <iostream>
enum operations
{
	add = 1,
	subtract = 2,
	multiply = 4
};
int main()
{
	int operation;
	int x1;
	int x2;
	int result;

	std::cout << "Add: 1 \tSubtract: 2 \tMultiply: 4" << std::endl;
	std::cout << "Input x1: ";
	std::cin >> x1;
	std::cout << "Input x2: ";
	std::cin >> x2;
	std::cout << "Input operation number: ";
	std::cin >> operation;

	switch (operation)
	{
	case operations::add: 
		result = x1 + x2;
		break;
	case operations::subtract:
		result = x1 - x2;
		break;
	case operations::multiply:
		result = x1 * x2;
		break;
	}

	std::cout << "Result: " << result << std::endl;
	return 0;
}

В данном случае все арифметические операции хранятся в перечислении operations. В зависимости от выбранной операции в конструкции switch производятся определенные действия.

Перечисляемые типы или перечисления в C ++

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

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

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

Синтаксис:

enum enumerated-type-name{value1, value2, value3…..valueN};

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

  1. Это может быть объявлено во время объявления перечислимых типов, просто добавьте имя переменной перед semicolon.or,
  2. Кроме того, мы можем создавать перечисляемые переменные типа так же, как и обычные переменные.

    enumerated-type-name variable-name = value;

Пример 1:

#include <bits/stdc++.h>

using namespace std;

  

int main()

{

    

    enum Gender { Male,

                  Female };

  

    

    Gender gender = Male;

  

    switch (gender) {

    case Male:

        cout << "Gender is Male";

        break;

    case Female:

        cout << "Gender is Female";

        break;

    default:

        cout << "Value can be Male or Female";

    }

    return 0;

}

Выход:

Gender is Male

Пример 2:

#include <bits/stdc++.h>

using namespace std;

  

enum year { Jan,

            Feb,

            Mar,

            Apr,

            May,

            Jun,

            Jul,

            Aug,

            Sep,

            Oct,

            Nov,

            Dec };

int main()

{

    int i;

  

    

    for

(i = Jan; i <= Dec; i++)

        cout << i << " ";

  

    return 0;

}

Выход:

0 1 2 3 4 5 6 7 8 9 10 11

Рекомендуемые посты:

Перечисляемые типы или перечисления в C ++

0.00 (0%) 0 votes

Перечисление через перечисление в C++

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

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

если у нас было перечисление, определяющее коды ошибок html, и мы знали, что коды ошибок в 500-х годах являются ошибками сервера, было бы лучше прочитать что-то вроде:

enum HtmlCodes {CONTINUE_CODE=100,CLIENT_ERROR=400,SERVER_ERROR=500,NON_STANDARD=600};

if(errorCode >= SERVER_ERROR && errorCode < NON_STANDARD)

чем

if(errorCode >= 500 && errorCode < 600)

ключевой частью является то, что они похожи на массивы! но привыкли к cast целочисленные значения.

короткий пример:

enum Suit {Diamonds, Hearts, Clubs, Spades};
//does something with values in the enum past "Hearts" in this case
for(int i=0;i<4;i++){
   //Could also use i or Hearts, because the enum will turns these both back into an int 
   if( (Suit)(i) > 1 )
   {
      //Whatever we'd like to do with (Suit)(i)
   }
}

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

char* Suits[4] = {"Diamonds", "Hearts", "Clubs", "Spades"};
//Getting a little redundant
cout << Suits[Clubs] << endl;
//We might want to add this to the above
//cout << Suits[(Suit)(i)] << endl;

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Theme: Overlay by Kaira Extra Text
Cape Town, South Africa