[C++] 型が列挙型かどうかを判定する方法

#include <iostream>
#include <type_traits>
enum class Color { Red, Green, Blue };
int main() {
    // Color型が列挙型かどうかを判定
    if (std::is_enum<Color>::value) {
        std::cout << "Colorは列挙型です。" << std::endl;
    } else {
        std::cout << "Colorは列挙型ではありません。" << std::endl;
    }
    return 0;
}

Colorは列挙型です。

#include <iostream>
#include <type_traits>
enum class Fruit { Apple, Banana, Orange };
enum class Vehicle { Car, Bike, Truck };
template<typename T>
void checkEnumType() {
    if (std::is_enum<T>::value) {
        std::cout << "指定された型は列挙型です。" << std::endl;
    } else {
        std::cout << "指定された型は列挙型ではありません。" << std::endl;
    }
}
int main() {
    checkEnumType<Fruit>();   // Fruit型の判定
    checkEnumType<Vehicle>(); // Vehicle型の判定
    checkEnumType<int>();     // int型の判定
    return 0;
}

指定された型は列挙型です。
指定された型は列挙型です。
指定された型は列挙型ではありません。

#include <iostream>
#include <type_traits>
enum class Animal { Dog, Cat, Bird };
template<typename T>
void processType() {
    if (std::is_enum<T>::value) {
        std::cout << "列挙型に特化した処理を実行します。" << std::endl;
    } else {
        std::cout << "一般的な型の処理を実行します。" << std::endl;
    }
}
int main() {
    processType<Animal>(); // Animal型の処理
    processType<int>();    // int型の処理
    return 0;
}

列挙型に特化した処理を実行します。
一般的な型の処理を実行します。

#include <iostream>
#include <type_traits>
enum class Status { Success, Failure, Unknown };
template<typename T>
void checkStatus(T status) {
    static_assert(std::is_enum<T>::value, "Tは列挙型でなければなりません。");
    if (status == Status::Success) {
        std::cout << "操作は成功しました。" << std::endl;
    } else {
        std::cout << "操作は失敗しました。" << std::endl;
    }
}
int main() {
    checkStatus(Status::Success); // 正しい使用
    // checkStatus(1); // コンパイルエラー: Tは列挙型でなければなりません。
    return 0;
}

操作は成功しました。

#include <iostream>
#include <type_traits>
enum class ErrorCode { NotFound, PermissionDenied, Unknown };
template<typename T>
void debugType() {
    if (std::is_enum<T>::value) {
        std::cout << "デバッグ: 列挙型が使用されています。" << std::endl;
    } else {
        std::cout << "デバッグ: 列挙型ではありません。" << std::endl;
    }
}
int main() {
    debugType<ErrorCode>(); // ErrorCode型のデバッグ
    debugType<double>();    // double型のデバッグ
    return 0;
}

デバッグ: 列挙型が使用されています。
デバッグ: 列挙型ではありません。

#include <iostream>
#include <type_traits>
enum class Shape { Circle, Square, Triangle };
template<typename T>
void efficientCheck() {
    static_assert(std::is_enum<T>::value, "Tは列挙型でなければなりません。");
    std::cout << "効率的に列挙型を判定しました。" << std::endl;
}
int main() {
    efficientCheck<Shape>(); // Shape型の判定
    return 0;
}

#include <iostream>
#include <type_traits>
// 色を表す列挙型
enum class Color { Red, Green, Blue };
// 列挙型を判定する関数
template<typename T>
void checkEnum() {
    // Tが列挙型かどうかを判定
    if (std::is_enum<T>::value) {
        std::cout << "Tは列挙型です。" << std::endl;
    } else {
        std::cout << "Tは列挙型ではありません。" << std::endl;
    }
}
int main() {
    checkEnum<Color>(); // Color型の判定
    return 0;
}

#include <iostream>
#include <type_traits>
enum class Status { Active, Inactive, Pending };
template<typename T>
void ensureTypeSafety(T status) {
    static_assert(std::is_enum<T>::value, "Tは列挙型でなければなりません。");
    if (status == Status::Active) {
        std::cout << "ステータスはアクティブです。" << std::endl;
    } else {
        std::cout << "ステータスはアクティブではありません。" << std::endl;
    }
}
int main() {
    ensureTypeSafety(Status::Active); // 正しい使用
    // ensureTypeSafety(1); // コンパイルエラー: Tは列挙型でなければなりません。
    return 0;
}