Перерахування (перелічуваний тип даних) в С++ / Уроки по С++ / aCode

C++ дозволяє програмістам створювати свої власні (користувацькі) типи даних.

Зміст:

Перелічуваний тип даних
Імена перерахувань
Значення енумераторів
Обробка перерахувань
Виведення енумераторів
Виділення пам’яті для перерахувань
Користь від перерахувань
Тест

Перелічуваний тип даних

Перерахування (або ще “перелічуваний тип даних“) — це тип даних, де будь-яке значення (або ще “енумератор/елемент“) визначається як символьна константа. Оголосити перерахування можна за допомогою ключового слова enum. Наприклад:

// Оголошуємо нове перерахування Colors
enum Colors
{
    // Нижче знаходяться енумератори
    // Це всі можливі значення цього типу даних
    // Кожний енумератор розділяється комою (НЕ крапкою з  комою)
    COLOR_RED,
    COLOR_BROWN,
    COLOR_GRAY,
    COLOR_WHITE,
    COLOR_PINK,
    COLOR_ORANGE,
    COLOR_BLUE,
    COLOR_PURPLE, // про останню кому читайте нижче
}; // але сам enum повинен закінчуватися крапкою з комою
 
// Визначаємо декілька змінних перелічуваного типу Colors
Colors paint = COLOR_RED;
Colors house(COLOR_GRAY);

// Оголошуємо нове перерахування Colors

enum Colors

{

// Нижче знаходяться енумератори

// Це всі можливі значення цього типу даних

// Кожний енумератор розділяється комою (НЕ крапкою з комою)

COLOR_RED,

COLOR_BROWN,

COLOR_GRAY,

COLOR_WHITE,

COLOR_PINK,

COLOR_ORANGE,

COLOR_BLUE,

COLOR_PURPLE, // про останню кому читайте нижче

}; // але сам enum повинен закінчуватися крапкою з комою

// Визначаємо декілька змінних перелічуваного типу Colors

Colors paint = COLOR_RED;

Colors house(COLOR_GRAY);

Оголошення перерахувань не вимагає виділення пам’яті. Тільки коли змінна перелічуваного типу визначена (наприклад, як змінна paint в прикладі вище), тільки тоді виділяється пам’ять для цієї змінної.

Зверніть увагу, кожен енумератор розділяється комою, а саме перерахування закінчується крапкою з комою.

Примітка: До C++11, кінцева кома після останнього елементу (як після COLOR_PURPLE в прикладі вище) була заборонена (хоча не всі компілятори на це скаржились). Однак, починаючи з C++11, кінцева кома дозволена.

Імена перерахувань

Імена перерахувань часто починаються з великої літери, а імена елементів взагалі складаються тільки з великих букв. Оскільки елементи знаходяться в одному і тому ж просторі імен, що і саме перерахування, то одне і те ж ім’я одного енумератора не може бути використано в кількох перерахувань одного і того ж простору імен:

enum Colors
{
	YELLOW,
	BLACK, // BLACK знаходиться в глобальному просторі імен
	PINK
};

enum Feelings
{
	SAD,
	ANGRY,
	BLACK // отримаємо помилку, так як BLACK вже використовується в enum Colors
};

enum Colors

{

YELLOW,

BLACK, // BLACK знаходиться в глобальному просторі імен

PINK

};

enum Feelings

{

SAD,

ANGRY,

BLACK // отримаємо помилку, так як BLACK вже використовується в enum Colors

};

Також поширено додавання назви перерахування в якості префіксу до його елементів, наприклад: ANIMAL_ чи COLOR_ — як для запобігання конфліктів імен, так і з метою коментування коду.

Значення енумераторів

Кожному енумератору автоматично присвоюється цілочисельне значення в залежності від його позиції в списку перерахування. За замовчуванням, першому елементу присвоюється ціле число 0, а кожному наступному — на одиницю більше, ніж попередньому:

#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;
}

#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;

}

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

4

Можна й самому визначати значення елементів. Вони можуть бути як додатними, так і від’ємними, або взагалі мати аналогічні іншим елементам значення. Будь-які енумератори, що не визначені вами, — матимуть значення на одиницю більше, ніж значення попередніх елементів. Наприклад:

// Визначаємо новий перелічуваний тип Animals
enum Animals
{
    ANIMAL_PIG = -4,
    ANIMAL_LION, // присвоюється -3
    ANIMAL_CAT, // присвоюється -2
    ANIMAL_HORSE = 6,
    ANIMAL_ZEBRA = 6, // має те ж значення, що і ANIMAL_HORSE
    ANIMAL_COW // присвоюється 7
};

// Визначаємо новий перелічуваний тип Animals

enum Animals

{

ANIMAL_PIG = -4,

ANIMAL_LION, // присвоюється -3

ANIMAL_CAT, // присвоюється -2

ANIMAL_HORSE = 6,

ANIMAL_ZEBRA = 6, // має те ж значення, що і ANIMAL_HORSE

ANIMAL_COW // присвоюється 7

};

Зверніть увагу, ANIMAL_HORSE і ANIMAL_ZEBRA мають однакові значення. Хоча C++ це не забороняє, присвоювати одне значення декільком енумераторам в одному перерахуванні не рекомендується.

Порада: Не присвоюйте свої значення енумераторам.

Правило: Не присвоюйте однакові значення двом енумераторам в одному перерахуванні, якщо на це немає вагомої причини.

Обробка перерахувань

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

#include <iostream>

// Визначаємо новий перелічуваний тип Animals
enum Animals
{
	ANIMAL_PIG = -4,
	ANIMAL_LION, // присвоюється -3
	ANIMAL_CAT, // присвоюється -2
	ANIMAL_HORSE = 6,
	ANIMAL_ZEBRA = 6, // має те ж значення, що і ANIMAL_HORSE
	ANIMAL_COW // присвоюється 7
};

int main()
{
	int mypet = ANIMAL_PIG;
	std::cout << ANIMAL_HORSE; // конвертується в int, а потім виводиться на екран

	return 0;
}

#include <iostream>

// Визначаємо новий перелічуваний тип Animals

enum Animals

{

ANIMAL_PIG = -4,

ANIMAL_LION, // присвоюється -3

ANIMAL_CAT, // присвоюється -2

ANIMAL_HORSE = 6,

ANIMAL_ZEBRA = 6, // має те ж значення, що і ANIMAL_HORSE

ANIMAL_COW // присвоюється 7

};

int main()

{

int mypet = ANIMAL_PIG;

std::cout << ANIMAL_HORSE; // конвертується в int, а потім виводиться на екран

return 0;

}

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

6

Компілятор не буде неявно конвертувати цілочисельне значення в значення енумератора. Наступне викличе помилку компіляції:

Animals animal = 7; // викличе помилку компіляції

1	Animals animal = 7; // викличе помилку компіляції

Тим не менш, ви можете зробити подібне за допомогою оператора static_cast:

Colors color = static_cast<Colors>(5); // але так робити не рекомендується

1	Colors color = static_cast<Colors>(5); // але так робити не рекомендується

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

#include <iostream>

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
};

int main()
{
	Colors color;
	std::cin >> color; // викличе помилку компіляції

	return 0;
}

#include <iostream>

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

};

int main()

{

Colors color;

std::cin >> color; // викличе помилку компіляції

return 0;

}

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

int inputColor;
std::cin >> inputColor;
 
Colors color = static_cast<Colors>(inputColor);

int inputColor;

std::cin >> inputColor;

Colors color = static_cast<Colors>(inputColor);

Кожен перелічуваний тип вважається окремим типом. Отже, спроба присвоїти енумератор з одного перерахування енумератору з іншого — викличе помилку компіляції:

Animals animal = COLOR_BLUE; // викличе помилку компіляції

1	Animals animal = COLOR_BLUE; // викличе помилку компіляції

Як і у випадку з константами, перерахування відображаються в відлагоджувачі, що робить їх ще більш корисними.

Виведення енумераторів

Спроба вивести енумератор за допомогою 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!";
}

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!";

}

Виділення пам’яті для перерахувань

Перелічувані типи вважаються частиною сімейства цілочисельних типів, і компілятор сам визначає, скільки пам’яті виділяти для змінних типу enum. Офіційно, C++ повідомляє, що розмір перерахування повинен бути досить великим, щоб мати можливість вмістити всі енумератори. Але найчастіше розміри змінних enum будуть такими ж, як і розміри звичайних змінних типу int.

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

Користь від перерахувань

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

Наприклад, функції часто повертають цілі числа назад в викликаючу функцію в якості кодів помилок, якщо щось пішло не так. Як правило, невеликі від’ємні числа використовуються для представлення можливих кодів помилок. Наприклад:

int readFileContents()
{
    if (!openFile())
        return -1;
    if (!parseFile())
        return -2;
    if (!readFile())
        return -3;
 
    return 0; // якщо все пройшло успішно
}

int readFileContents()

{

if (!openFile())

return -1;

if (!parseFile())

return -2;

if (!readFile())

return -3;

return 0; // якщо все пройшло успішно

}

Однак магічні числа, як в прикладі вище, — не дуже ефективне рішення. Альтернативним рішенням є використання перерахувань:

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; // якщо все пройшло успішно
}

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; // якщо все пройшло успішно

}

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

if (readFileContents() == SUCCESS)
    {
    // Робимо що-небудь
    }
else
    {
    // Виводимо повідомлення про помилку
    }

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;
}

#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;

}

Або, якщо ви пишете функцію для сортування групи значень:

enum SortType
{
    SORTTYPE_FORWARD,
    SORTTYPE_BACKWARDS
};
 
void sortData(SortType type)
{
    if (type == SORTTYPE_FORWARD)
        // сортування даних в одному порядку
    else if (type == SORTTYPE_BACKWARDS)
        // сортування даних в зворотному порядку
}

enum SortType

{

SORTTYPE_FORWARD,

SORTTYPE_BACKWARDS

};

void sortData(SortType type)

{

if (type == SORTTYPE_FORWARD)

// сортування даних в одному порядку

else if (type == SORTTYPE_BACKWARDS)

// сортування даних в зворотному порядку

}

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

Тест

Завдання №1

Напишіть перерахування з наступними енумераторами: ogre, goblin, skeleton, orc і troll.

Відповідь №1

enum MonsterType
{
    MONSTER_OGRE,
    MONSTER_GOBLIN,
    MONSTER_SKELETON,
    MONSTER_ORC,
    MONSTER_TROLL
};

enum MonsterType

{

MONSTER_OGRE,

MONSTER_GOBLIN,

MONSTER_SKELETON,

MONSTER_ORC,

MONSTER_TROLL

};

Завдання №2

Оголосіть змінну перелічуваного типу, який ви визначили в завданні №1, і присвойте їй тип ogre.

Відповідь №2

MonsterType eMonsterType = MONSTER_OGRE;

1	MonsterType eMonsterType = MONSTER_OGRE;

Завдання №3

Правда чи брехня:

Енумераторам можна:

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

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

явно присвоювати значення типу з плаваючою крапкою;

присвоювати значення попередніх енумераторів (наприклад, COLOR_BLUE = COLOR_GRAY).

Енумератори можуть бути:

від’ємними;

не унікальними.

Відповідь №3

Енумераторам можна:

Правда.

Правда. Енумератору без значення буде неявно присвоєно цілочисельне значення попереднього енумератора +1. Якщо попереднього енумератора немає, то тоді присвоїться значення 0.

Брехня.

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

Енумератори можуть бути:

Правда.

Оцінити статтю: