[C++] 型が浮動小数点数かどうかを判定する方法

#include <iostream>
#include <type_traits>
int main() {
    // float型の判定
    bool isFloat = std::is_floating_point<float>::value;
    std::cout << "floatは浮動小数点数型か: " << isFloat << std::endl;
    // int型の判定
    bool isInt = std::is_floating_point<int>::value;
    std::cout << "intは浮動小数点数型か: " << isInt << std::endl;
    return 0;
}

floatは浮動小数点数型か: 1
intは浮動小数点数型か: 0

#include <iostream>
#include <type_traits>
template<typename T>
void checkFloatingPoint() {
    if (std::is_floating_point<T>::value) {
        std::cout << "Tは浮動小数点数型です。" << std::endl;
    } else {
        std::cout << "Tは浮動小数点数型ではありません。" << std::endl;
    }
}
int main() {
    checkFloatingPoint<double>(); // double型のチェック
    checkFloatingPoint<int>();    // int型のチェック
    return 0;
}

Tは浮動小数点数型です。
Tは浮動小数点数型ではありません。

#include <iostream>
#include <type_traits>
template<typename T>
void isFloatingPoint() {
    if (std::is_floating_point<T>::value) {
        std::cout << "型は浮動小数点数型です。" << std::endl;
    } else {
        std::cout << "型は浮動小数点数型ではありません。" << std::endl;
    }
}
int main() {
    isFloatingPoint<float>();  // float型のチェック
    isFloatingPoint<char>();   // char型のチェック
    return 0;
}

型は浮動小数点数型です。
型は浮動小数点数型ではありません。

#include <iostream>
#include <type_traits>
int main() {
    // double型の判定
    if (std::is_floating_point<double>::value) {
        std::cout << "doubleは浮動小数点数型です。" << std::endl;
    } else {
        std::cout << "doubleは浮動小数点数型ではありません。" << std::endl;
    }
    // bool型の判定
    if (std::is_floating_point<bool>::value) {
        std::cout << "boolは浮動小数点数型です。" << std::endl;
    } else {
        std::cout << "boolは浮動小数点数型ではありません。" << std::endl;
    }
    return 0;
}

doubleは浮動小数点数型です。
boolは浮動小数点数型ではありません。

#include <iostream>
#include <type_traits>
template<typename T>
void checkType() {
    if (std::is_floating_point<T>::value) {
        std::cout << "Tは浮動小数点数型です。" << std::endl;
    } else {
        std::cout << "Tは浮動小数点数型ではありません。" << std::endl;
    }
}
int main() {
    checkType<float>();  // float型のチェック
    checkType<int>();    // int型のチェック
    return 0;
}

Tは浮動小数点数型です。
Tは浮動小数点数型ではありません。

#include <iostream>
#include <typeinfo>
void checkTypeRuntime(const std::type_info& type) {
    if (type == typeid(float) || type == typeid(double) || type == typeid(long double)) {
        std::cout << "型は実行時に浮動小数点数型と判定されました。" << std::endl;
    } else {
        std::cout << "型は実行時に浮動小数点数型ではないと判定されました。" << std::endl;
    }
}
int main() {
    float f = 0.0f;
    int i = 0;
    checkTypeRuntime(typeid(f));  // float型のチェック
    checkTypeRuntime(typeid(i));  // int型のチェック
    return 0;
}

型は実行時に浮動小数点数型と判定されました。
型は実行時に浮動小数点数型ではないと判定されました。

#include <iostream>
#include <type_traits>
template<typename T>
void checkTypeCompileTime() {
    static_assert(std::is_floating_point<T>::value, "Tは浮動小数点数型でなければなりません。");
    std::cout << "コンパイル時に型が浮動小数点数型であることが確認されました。" << std::endl;
}
int main() {
    checkTypeCompileTime<double>();  // double型のチェック
    // checkTypeCompileTime<int>(); // この行を有効にするとコンパイルエラーになります
    return 0;
}

#include <iostream>
#include <type_traits>
template<typename T>
class Matrix {
public:
    void performOperation() {
        if (std::is_floating_point<T>::value) {
            std::cout << "浮動小数点数型の行列演算を実行します。" << std::endl;
            // 浮動小数点数型に特化した演算を実行
        } else {
            std::cout << "整数型の行列演算を実行します。" << std::endl;
            // 整数型に特化した演算を実行
        }
    }
};
int main() {
    Matrix<double> floatMatrix;
    floatMatrix.performOperation();
    Matrix<int> intMatrix;
    intMatrix.performOperation();
    return 0;
}

浮動小数点数型の行列演算を実行します。
整数型の行列演算を実行します。