列挙型 | Programming Place Plus　新C++編

このページの概要

このページでは、列挙型を取り上げます。列挙型は、何かしらの関係性があるいくつかの整数定数を１つの型で定義します。整数定数にはそれぞれ名前を付けることができ、それぞれを同じ型の仲間として取り扱えるようになります。名前付きの整数定数なら constexpr変数でも実現できるので、必須とまではいえない機能ですが、意外と便利なものです。

以下は目次です。要点だけをさっと確認したい方は、「まとめ」をご覧ください。

• 列挙型
  • 列挙型と constexpr変数
• 基底型
• scoped enum
  • 整数型との型変換
• unscoped enum
  • 整数型との型変換
• enum宣言
• まとめ
• 練習問題
• 参考リンク
• 更新履歴

列挙型

前のページまでで蔵書リストのプログラムに関する話題は終了し、ここからは新しいテーマを設定して進めていきます。

次のテーマは、トランプを使ったゲーム「ポーカー」です。ポーカーにはいくつか異なるルールもありますが、ここでは、以下のようにします。

• ジョーカーを除く全53枚のカードから、２人のプレイヤーに 5枚ずつ配る
• 各プレイヤーは配られたカードから捨てるものを 0～5枚選び、捨てた枚数だけ、新しいカードの補充を受ける
• 手元の５枚のカードから役の判定を行い、相手よりも勝っていれば勝利

トランプを使ったゲームを作るにあたって、まずカードを表現できるようにしなければなりません。ポーカーに限らず、どんなトランプゲームにでも流用できるかたちで整えることを考えてみましょう。カードをグラフィカルに表示できると見栄えもいいのですが、C++ の標準機能だけでは画像の表示が行えないので、引き続き、文字ベースの方法を採ることにします。

カードに必要な情報は、数字とマークです（ジョーカーは省いています）。数字は int型の変数で簡単に扱えます。マークについては、“spade” のような文字列で表せますが、ここでは列挙型 (enumeration type) を使ってみることにします。

列挙体 (enumeration) と呼ばれることもあります。

列挙型は、名前の付いた整数定数を任意の個数だけ定義し、それぞれを同一の型で取り扱えるようにします。カードのマークでいえば、スペード、クラブ、ダイヤ、ハートに 0～3 の整数定数を割り当て、それぞれを CardMark型として取り扱えます。

列挙型を使うためには、構造体のときと同じく、まずは型の定義から始めます。列挙型を定義する方法は以下のように複数あります。

enum class 列挙名 {
    列挙子のリスト
};

enum struct 列挙名 {
    列挙子のリスト
};

enum 列挙名 {
    列挙子のリスト
};

このうち最初の２つは同じ意味です（新C++編では enum class の方で統一していきます）。この２つの方法で定義される列挙型は、scoped enum（スコープ付きの列挙型）と呼ばれており、C++11 から追加された新しい方法です。３つ目の記法は、古いバージョンの C++ から存在するものですが、仕様上いくつか危険な面があるため、scoped enum を使うことを勧めます。対比のため、３つ目の記法は unscoped enum と呼ばれます。

【Ｃ言語プログラマー】unscoped enum はＣ言語の enum を受け継いだものですが、scoped enum の機能の一部が加えられています。

「列挙名 (enum name)」は、列挙型の名前のことです。「列挙子のリスト」には、この列挙型に含まれる定数の名前を , で区切りながら記述します。１つ１つの定数を列挙子 (enumerator) と呼びます。

【Ｃ言語プログラマー】Ｃ言語の列挙型タグのような考え方はなく、すべて列挙名と呼びます。列挙型の名前を使うとき、enum キーワードを使う必要もなくなっています。

カードのマークをあらわす列挙型を次のように記述できます。

// scoped enum の場合
enum class CardMark {
    spade,
    club,
    diamond,
    heart,
};

// unscoped enum の場合
enum CardMark {
    spade,
    club,
    diamond,
    heart,
}

列挙子を１行に１つずつ書くスタイルが多いですが、横に並べても構いません。また、最後の列挙子のうしろに , があってもなくても構いません。

列挙子の名前をすべて大文字で書くスタイルを見かける場合がありますが、避けるべきとするガイドラインもあります¹。

列挙子の値は、先頭の列挙子が 0、そのあとは +1 ずつ割り振られていきます。そのため、spade は 0、club は 1、diamond は 2、heart は 3 になります。このように自動的に採番されるため、具体的な値にはこれといって意味がない場合に便利です。

列挙子の値を、自動採番に任せず、任意に指定したい場合は、次のように = を使います。= の右側には、整数になる定数式を記述します。

enum class CardMark {
    spade = 100,
    club,
    diamond,
    heart,
};

この場合は、spade が 100、それ以降は +1 されていきます。したがって、club は 101、diamond は 102、heart は 103 です。

値を明示する列挙子と、そうでない列挙子がどのように混在しても構いませんし、先に記述した列挙子を後続で使うこともできます。意味があるとは思えませんが、たとえば次のようにできます。

enum class CardMark {
    spade = 10,            // 10
    club,                  // 11
    diamond = spade + 100, // 110
    heart,                 // 111
};

値を指定すると、どの列挙子にどんな値が割り振られているのか把握しづらくなり、誤って、同じ値を持った列挙子を作ってしまうなどの事故を起こす可能性が高まります。それなりの事情がない限り、値を指定することは避けるのが無難です。前述したように、列挙型は「具体的な値にはこれといって意味がない場合」に向いています。

なお、列挙型の変数を宣言するとき、初期化子を {} とした場合の初期値は 0 であるため、列挙子の中には値が 0 のものを含めておくと良いです。

constexpr int spade = 0;
constexpr int club = 1;
constexpr int diamond = 2;
constexpr int heart = 3;

void f1(int mark);       // 引数には渡す整数がどんなものが不明瞭
void f2(CardMark mark);  // 引数に渡すものが明確
CardMark f3(void);       // 返されるものが明確

基底型

列挙子の値として使える整数の範囲は、基底型（根底型） (underlying type) という型によって決定されます。基底型は自動的に決定されますが、次のように明示的に指定することもできます。

enum class 列挙名 : 基底型 {
    列挙子のリスト
};

enum struct 列挙名 : 基底型 {
    列挙子のリスト
};

enum 列挙名 : 基底型 {
    列挙子のリスト
};

「基底型」のところに int とか unsigned int といったように、任意の整数型を記入します。int型を指定したのなら、列挙子の値として使える範囲は int型で表現できる範囲と同じになります。unsigned int型を指定したなら unsigned int型と同じになるので、正の上限値が増える代わりに負数が使えなくなります。まだ登場していませんが、整数型には、int型よりも大きいものと小さいものとがそれぞれ存在するので、これらを使い分けることもできます。

char型や bool型も整数型の一種なので使用できます。ただ、char型は文字として使うべき型ですし、bool型には true/false の２つの値しか存在しないため、基底型として使うことはないでしょう。

基底型の指定を行わなかった場合のあつかいは、scoped enum と unscoped enum とで異なります³。

• scoped enum の場合は、int型になる
  • int型で表現できない列挙子があるときはコンパイルエラー
• unscoped enum の場合は、定義したすべての列挙子の値を表現できる型が自動選択される（具体的には処理系定義）
  • ただし、int や unsigned int で収まるのに、それらより大きな型が選ばれることはない
  • すべての列挙子を表現できる型が存在しない場合は、コンパイルエラー

unscoped enum の場合、処理系定義の選択に任せず、明示的に指定したほうがいいかもしれません。

【上級】scoped enum で、int型で表現できない値を使うには、基底型に long long型など、より大きな整数型を指定しなければなりません。unscoped enum の場合は、自動的に大きな整数型が使われますが、何が選ばれるかは処理系定義です。

scoped enum

scoped enum の CardMark型を次のように使用できます。

#include <iostream>
#include <string>

enum class CardMark {
    spade,
    club,
    diamond,
    heart,
};

std::string get_mark_string(CardMark card_mark)
{
    // switch文の caseラベルに使える
    switch (card_mark) {
    case CardMark::spade:
        return "spade";
    case CardMark::club:
        return "club";
    case CardMark::diamond:
        return "diamond";
    case CardMark::heart:
        return "heart";
    default:
        return "";
    }
}

int main()
{
    CardMark mark {CardMark::spade};  // 変数の宣言と初期化
    mark = CardMark::diamond;         // 代入
    std::cout << std::boolalpha << (mark == CardMark::diamond) << "\n";  // 比較

    std::cout << get_mark_string(mark) << "\n";
}

実行結果：

true
diamond

定義した scoped enum の列挙名を使って、これまで通りの方法で変数を宣言できます。初期化子を {} とした場合は 0 で初期化されます（「構造体」のページを参照）。初期化子を与えなかった場合の値は不定なので、これは避けましょう。

特徴的なのは列挙子へのアクセスの方法で、:: を使って「列挙名::列挙子名」のように記述しなければなりません。:: はスコープ解決演算子 (scope resolution operator) と呼ばれる演算子の一種です。“scoped” enum という名前はここから来ており、列挙子の名前は、列挙名とセットになっています。記述がやや面倒になる反面、ほかの列挙型に含まれる同名の列挙子と確実に区別され、衝突することがありません。

【C++20】using enum宣言を行うことで、スコープ解決演算子を用いずに列挙子を使えるようになりました⁴。

get_mark_string関数は、列挙子の名前に応じた文字列を作って返すものです。列挙子から文字列への変換は時折必要になるのですが、自力で実装する必要があります。

CardMark mark {CardMark::spade};  // scoped enum (基底型は int)
mark = mark + 2;  // コンパイルエラー
if (mark == 1) {  // コンパイルエラー
}
std::cout << mark << "\n";  // コンパイルエラー

CardMark mark {CardMark::diamond};  // scoped enum (基底型は int)
mark = static_cast<CardMark>(static_cast<int>(mark) + 2);  // OK。だが、+2 した結果が CardMark として正常なものであると保証できるのか？
if (static_cast<int>(mark) == 1) {  // OK。だが mark == CardMark::club が適切だろう
}
std::cout << static_cast<int>(mark) << "\n";  // OK

#include <iostream>
#include <type_traits>

enum class CardMark : unsigned int {
    spade,
    club,
    diamond,
    heart,
};

int main()
{
    CardMark mark {CardMark::diamond};
    auto mark_value = static_cast<std::underlying_type_t<CardMark>>(mark);
    std::cout << mark_value << "\n";
}

2

// CardMark の基底型は unsigned int とする

mark = 3;  // コンパイルエラー
mark = static_cast<CardMark>(3);   // OK
mark = static_cast<CardMark>(7);   // OK だが危険（想定されていない値）
mark = static_cast<CardMark>(-1);  // OK だが危険（基底型で表現できない値）

unscoped enum

今後は unscoped enum の場合の話です。最初に書いたとおり、通常は scoped enum を使うことを勧めます。

#include <iostream>
#include <string>

enum CardMark : int {
    spade,
    club,
    diamond,
    heart,
};

std::string get_mark_string(CardMark card_mark)
{
    // switch文の caseラベルに使える
    switch (card_mark) {
    case spade:
        return "spade";
    case club:
        return "club";
    case diamond:
        return "diamond";
    case heart:
        return "heart";
    default:
        return "";
    }
}

int main()
{
    CardMark mark {spade};            // 変数の宣言と初期化
    mark = diamond;                   // 代入
    std::cout << std::boolalpha << (mark == diamond) << "\n";  // 比較

    std::cout << get_mark_string(mark) << "\n";
}

実行結果：

false
diamond

unscoped enum の変数を宣言するとき、初期化子を {} とした場合は 0 で初期化されます（「構造体」のページを参照）。初期化子を与えなかった場合の値は不定なので、これは避けましょう。

unscoped enum の場合、列挙子名は列挙名とセットではなく、スコープ解決演算子（::）を使う必要がありません（使ってもいいです）。このため、unscoped enum では、ほかの unscoped enum に同名の列挙子があると衝突を起こしてエラーになります。

enum CardMark : int {
    spade,
    club,
    diamond,
    heart,
};

enum BodyParts : int {
    hands,
    legs,
    heart,  // エラー。heart はすでにほかの unscoped enum にある
    head,
};

そのため、unscoped enum を使う場合は、列挙子名の先頭に、列挙名に由来する名前を付け足して、衝突を防ぐと良いです。

enum CardMark : int {
    cardMarkSpade,
    cardMarkClub,
    cardMarkDiamond,
    cardMarkHeart,
};

enum BodyParts : int {
    bodyPartsHands,
    bodyPartsLegs,
    bodyPartsHeart,
    bodyPartsHead,
};

// CardMark の基底型は int とする

CardMark mark {cardMarkDiamond};
int mark_value {mark};  // OK
std::cout << mark << "\n";
mark_value = mark + 1;

#include <iostream>
#include <type_traits>

enum CardMark : unsigned int {  // 基底型は unsigned int
    cardMarkSpade,
    cardMarkClub,
    cardMarkDiamond,
    cardMarkHeart,
};

int main()
{
    CardMark mark {cardMarkDiamond};
    std::underlying_type_t<CardMark> mark_value = mark;
    std::cout << mark_value << "\n";
}

2

if (mark == bodyPartsHead) {  // CardMark型と BodyParts型を誤って比較。
                              // それぞれが整数型に変換されて、比較される。本来比較できるべきではない。
}

// CardMark の基底型は unsigned int とする

mark = 3;  // コンパイルエラー
mark = static_cast<CardMark>(3);   // OK
mark = static_cast<CardMark>(7);   // OK だが危険（想定されていない値）
mark = static_cast<CardMark>(-1);  // OK だが危険（基底型で表現できない値）

enum宣言

列挙型を宣言しておくこともできます。宣言には列挙子の指定が含まれず、列挙名と基底型だけを記述します。

enum class 列挙名;
enum struct 列挙名;

enum class 列挙名 : 基底型;
enum struct 列挙名 : 基底型;
enum 列挙名 : 基底型;

scoped enum の場合は「基底型」を省略できますが、unscoped enum では「基底型」を記述しなければなりません。これは、列挙子を書かないため、基底型が分かっていないと、必要な大きさが分からないためです（scoped enum は基底型を指示しなければ int型というルールがあるため、省略可能）。

宣言には列挙子が含まれていないので、どこかに定義も必要です。宣言と定義で、列挙名と基底型が一致していなければなりません。

宣言さえ見えていれば、列挙名を使えますが、列挙子の名前を使うには定義が見えていなければなりません。

#include <iostream>

// 宣言
enum CardMark : unsigned int;

void f(CardMark mark);  // OK。CardMark の宣言が上にあるので、CardMark という名前を使える

int main()
{
    f(CardMark::spade);  // エラー。この位置からは列挙子が見えてない
}

// 定義
enum CardMark : unsigned int {
    spade,
    club,
    diamond,
    heart,
};

void f(CardMark mark)
{
    if (mark == CardMark::spade)  // OK。この位置からは定義が見えるので、列挙子も使える
    {
        // ...
    }
}

現時点では、enum の宣言を活用できる場面はありませんが、ソースファイルを複数使うようになってくると必要性が出てきます。

この話題は「ヘッダファイル」のページで取り上げます。

まとめ

• 列挙型を使って、関係性のある複数の整数定数を、名前付きでまとめられる
  • それぞれの整数定数を列挙子と呼ぶ
• 列挙型には、使い方に制約を持たせて安全性を高めた scoped enum と、制約が緩い反面、危険な面がある unscoped enum の２種類がある
• 列挙子の値は、基底型という型によって表現される
  • scoped enum で基底型を明示しなかった場合は、int型になる
  • unscoped enum で基底型を明示しなかった場合は、処理系定義の型になる
• 基底型は、std::underlying_type_t で取得できる（std::underlying_type_t<CardMark> のように）
  • std::underlying_type_t を使うには、#include <type_traits> が必要
• scoped enum と整数型の相互の変換は、static_cast によって明示しなければならない
• unscoped enum は整数型（基底型）に暗黙的に変換される
• 整数型から unscoped enum への変換には、static_cast が必要である
• 列挙型には宣言もある

新C++編の【本編】の各ページには、末尾に練習問題があります。ページ内で学んだ知識を確認する簡単な問題から、これまでに学んだ知識を組み合わせなければならない問題、あるいは更なる自力での調査や模索が必要になるような高難易度な問題をいくつか掲載しています。