[C++] enum classの基本的な使い方と利点

#include <iostream>
// 色を表すenum classの定義
enum class Color {
    Red,    // 赤
    Green,  // 緑
    Blue    // 青
};
int main() {
    Color myColor = Color::Red;  // Color型の変数にRedを代入
    // 色を判定する
    if (myColor == Color::Red) {
        std::cout << "色は赤です。" << std::endl;
    }
    return 0;
}

#include <iostream>
// 曜日を表すenum classの定義
enum class Day {
    Sunday,    // 日曜日
    Monday,    // 月曜日
    Tuesday,   // 火曜日
    Wednesday, // 水曜日
    Thursday,  // 木曜日
    Friday,    // 金曜日
    Saturday   // 土曜日
};

#include <iostream>
enum class Day {
    Sunday,
    Monday,
    Tuesday
};
int main() {
    Day today = Day::Monday;  // Day型の変数にMondayを代入
    if (today == Day::Monday) {
        std::cout << "今日は月曜日です。" << std::endl;
    }
    return 0;
}

#include <iostream>

// 色を表すenum class
enum class Color {
    Red,
    Green,
    Blue
};

// 警告レベルを表すenum class
enum class WarningLevel {
    Red,
    Yellow,
    Green
};

int main() {
    Color myColor = Color::Red;
    WarningLevel myWarning = WarningLevel::Red;

    // 同じ名前の列挙子を異なるenum classで使用
    if (myColor == Color::Red && myWarning == WarningLevel::Red) {
        std::cout << "Color is Red and Warning Level is Red." << std::endl;
    }

    return 0;
}

#include <iostream>
// 小さな整数型を基底型として指定
enum class SmallEnum : char {
    A,
    B,
    C
};
int main() {
    SmallEnum value = SmallEnum::A;
    if (value == SmallEnum::A) {
        std::cout << "値はAです。" << std::endl;
    }
    return 0;
}

#include <iostream>
enum class Color {
    Red,
    Green,
    Blue
};
enum class TrafficLight {
    Red,
    Yellow,
    Green
};
int main() {
    Color myColor = Color::Red;
    TrafficLight light = TrafficLight::Red;
    // 型が異なるため、直接比較はできない
    // if (myColor == light) { // コンパイルエラー
    //     std::cout << "同じ色です。" << std::endl;
    // }
    return 0;
}

#include <iostream>
enum class Color {
    Red,
    Green,
    Blue
};
enum class Fruit {
    Apple,
    Orange,
    Red  // 同じ名前の列挙子
};
int main() {
    Color myColor = Color::Red;
    Fruit myFruit = Fruit::Red;
    // 別々のenum classで同じ名前の列挙子を使用可能
    if (myColor == Color::Red && myFruit == Fruit::Red) {
        std::cout << "赤い果物です。" << std::endl;
    }
    return 0;
}

#include <iostream>
enum class Status {
    Active,
    Inactive,
    Pending
};
void printStatus(Status status) {
    switch (status) {
        case Status::Active:
            std::cout << "ステータスはアクティブです。" << std::endl;
            break;
        case Status::Inactive:
            std::cout << "ステータスは非アクティブです。" << std::endl;
            break;
        case Status::Pending:
            std::cout << "ステータスは保留中です。" << std::endl;
            break;
    }
}
int main() {
    Status currentStatus = Status::Active;
    printStatus(currentStatus);
    return 0;
}

#include <iostream>
// ステートマシンの状態を表すenum class
enum class State {
    Idle,
    Running,
    Paused,
    Stopped
};
void handleState(State state) {
    switch (state) {
        case State::Idle:
            std::cout << "システムはアイドル状態です。" << std::endl;
            break;
        case State::Running:
            std::cout << "システムは実行中です。" << std::endl;
            break;
        case State::Paused:
            std::cout << "システムは一時停止中です。" << std::endl;
            break;
        case State::Stopped:
            std::cout << "システムは停止しています。" << std::endl;
            break;
    }
}
int main() {
    State currentState = State::Idle;
    handleState(currentState);
    currentState = State::Running;
    handleState(currentState);
    return 0;
}

#include <iostream>
// フラグを表すenum class
enum class Permission : unsigned int {
    Read = 0x01,   // 読み取り権限
    Write = 0x02,  // 書き込み権限
    Execute = 0x04 // 実行権限
};
inline Permission operator|(Permission lhs, Permission rhs) {
    return static_cast<Permission>(static_cast<unsigned int>(lhs) |
                                   static_cast<unsigned int>(rhs));
}
int main() {
    Permission userPermission = Permission::Read | Permission::Write;
    if (static_cast<unsigned int>(userPermission) &
        static_cast<unsigned int>(Permission::Read)) {
        std::cout << "読み取り権限があります。" << std::endl;
    }
    if (static_cast<unsigned int>(userPermission) &
        static_cast<unsigned int>(Permission::Write)) {
        std::cout << "書き込み権限があります。" << std::endl;
    }
    return 0;
}

#include <iostream>
// エラーコードを表すenum class
enum class ErrorCode {
    None,
    NotFound,
    InvalidInput,
    Timeout
};
void handleError(ErrorCode error) {
    switch (error) {
        case ErrorCode::None:
            std::cout << "エラーはありません。" << std::endl;
            break;
        case ErrorCode::NotFound:
            std::cout << "エラー: 見つかりません。" << std::endl;
            break;
        case ErrorCode::InvalidInput:
            std::cout << "エラー: 無効な入力です。" << std::endl;
            break;
        case ErrorCode::Timeout:
            std::cout << "エラー: タイムアウトしました。" << std::endl;
            break;
    }
}
int main() {
    ErrorCode error = ErrorCode::InvalidInput;
    handleError(error);
    return 0;
}

#include <iostream>
enum class Color {
    Red,
    Green,
    Blue
};
int main() {
    Color myColor = Color::Red;
    // 暗黙的な型変換はできないため、明示的なキャストが必要
    int colorValue = static_cast<int>(myColor);
    std::cout << "Color value: " << colorValue << std::endl;
    return 0;
}

#include <iostream>
// char型を基底型として指定
enum class SmallEnum : char {
    A,
    B,
    C
};
int main() {
    SmallEnum value = SmallEnum::A;
    std::cout << "SmallEnum value: " << static_cast<int>(value) << std::endl;
    return 0;
}

#include <iostream>
enum class Status {
    Active,
    Inactive,
    Pending
};
int main() {
    Status currentStatus = Status::Active;
    // 直接比較はできないため、明示的なキャストが必要
    if (static_cast<int>(currentStatus) == 0) {
        std::cout << "ステータスはアクティブです。" << std::endl;
    }
    return 0;
}